Sungwon Han

Reflect on Software Engineering

07 May 2025

Beyond Web Development: Foundational Lessons in Software Engineering

Software engineering is the part of computer science which is too difficult for the computer scientist. - Friedrich L. Bauer

When I first started this class, I assumed it would primarily teach me how to build web applications. While web development was a major part of the course, I soon realized that the true focus was much broader: learning the foundational principles of software engineering. These principles—such as coding standards, Agile project management, and design patterns—are not just tools for web developers; they are essential practices for any kind of software or team-based project. Through hands-on experience, I gained a deeper understanding of how professional software is built, maintained, and managed. This essay reflects on a few key topics from the course and explores how they apply beyond just web application development.

The Importance of Coding Standards in Team Collaboration

Coding Standards are a set of guidelines for developers that ensure code is written in a consistent and understandable way, making it easier for others to read, maintain, and collaborate on. One coding standard we learned in this class is ESLint, a tool that detects coding style errors. We were required to fix any ESLint errors we encountered, even if our code was functionally correct. Initially, this was frustrating because my code worked perfectly, yet I still had to fix minor issues. It became especially apparent when I tried to deploy my project on Vercel, a platform for hosting websites. Vercel wouldn’t allow deployment if any ESLint errors remained, which showed how strict and important these standards are.

However, as we progressed and began working more as a team, I realized the value of coding standards. When I needed to fix or understand my teammate’s code, it would have been much harder if it didn’t follow a consistent structure or style. This concept applies beyond software engineering. For instance, imagine working on a group presentation where each person is responsible for a few slides. To ensure the final presentation looks professional and cohesive, the team should follow shared rules like using the same font, consistent colors, or similar formatting. Just like in coding, having common standards in collaborative work helps the final product feel unified and easier to understand. Learning to follow coding standards is not just about writing better code-it’s about becoming a more effective and considerate team member in any collaborative project.

How Issue Driven Project Management Improves Teamwork and Accountability

Agile Project Management is a method of organizing and executing work in an iterative, flexible, and collaborative way. One specific approach within Agile that we learned in this class is Issue Driven Project Management (IDPM). In this method, the work is broken down into individual tasks called issues, which are then assigned to team members. Each member is responsible for completing a certain number of issues, while some may remain unassigned so that team members who finish early can take on additional work. This structure helps avoid duplication of effort and ensures clear task ownership. Issues are typically tracked using three states: Not Started, which indicates tasks that still need to be worked on; In Progress, meaning someone is currently working on the task; and Done, which signifies completed tasks. I never felt that this process was unnecessary or a waste of time-in fact, it was crucial for preventing confusion and ensuring that everyone knew who was doing what.

Reflecting on past experiences, I remember many high school group projects where communication was poor and work wasn’t evenly distributed. Often, one person ended up doing everything, not because others didn’t want to help, but because they simply didn’t know what to do. That’s why I believe this type of project management should be taught more widely, even outside of software engineering. It provides structure, improves collaboration, and reduces frustration, especially in group settings where teamwork is essential. If more students learned about issue tracking and task assignment early on, it could make group work far more manageable and fair for everyone involved.

The Power of Design Patterns: Reusability and Efficiency in Development

Design Patterns are general, reusable solutions to common problems that arise in software design. They provide a proven blueprint for solving recurring design challenges, allowing developers to avoid reinventing the wheel each time. One example that reflects this concept from our class is the Next.js application sample template. While a template itself is not a design pattern in the strictest sense, it incorporates many reusable design principles, such as database interactions and component structure that make it easier to build a functional web application. All of the project groups, including ours, used this sample template as a starting point and followed its logic to guide the development of our own websites. The way we were able to take this foundational structure, customize it, and build upon it aligns closely with the purpose of a design pattern: to offer a reliable starting point that can be adapted to specific needs.

Although I didn’t create a design pattern myself, I learned a lot about their value by using one created by others. Our collective use of this template showed that with just one solid design pattern, an entire class could efficiently develop complex projects. This concept extends beyond software engineering. For instance, in game development, if I needed to design multiple characters, I could create a few base character templates with varying attributes like height or shape, then adjust their appearance. That reuse of structure is also a form of design pattern. Ultimately, using or creating a good design pattern is a smart way to save time, reduce complexity, and maintain consistency. I would definitely recommend applying this approach in various fields—it truly makes development faster, more organized, and less stressful.

Lasting Lessons for Any Collaborative Project

Overall, this course taught me that software engineering is much more than writing code that works. It’s about writing code that works well with others. Whether it’s adhering to coding standards to ensure clarity, using structured project management techniques like Issue Driven Project Management to improve collaboration, or leveraging design patterns to save time and increase consistency, these practices are universally valuable. They not only make technical projects more efficient but also make teamwork more effective. What I’ve learned in this class will stay with me no matter what kind of project I take on in the future—inside or outside of software development.