When I first started this class, I assumed it would be all about building a web application—learning the programming languages, frameworks, and tools needed to create a functional app by the end of the semester. That is definitely part of it, but I quickly realized it’s about much more than just writing code. It’s about understanding the core principles of software engineering, where each line of code reflects a deeper understanding of structure, organization, and collaboration. As we moved from basic HTML and CSS to more complex frameworks like Next.js, I started to see that the process isn’t just about making something that works, but making something that’s reliable, maintainable, and scalable. It’s about thinking like an engineer, solving problems, and building software that can grow and adapt as needed. I’ve come to appreciate that building a web application is just one example of applying these broader, foundational concepts, and that the real lessons lie in the practices that make good software possible.
Coding standards are a bit like the rules we follow when writing an essay. Just as essays have guidelines for structure, tone, and grammar, code has its own set of rules that help keep things organized and clear. These standards cover everything from how to name variables and functions to how to format code blocks and handle indentation. They ensure that code is not just functional, but also readable and maintainable, both for the original author and for others who might work on it later. Without these guidelines, even a small project can become a tangled mess, just like a poorly organized essay.
One tool we used in this course to enforce these standards is ESLint. ESLint is a code analysis tool that automatically checks your code for formatting issues, potential bugs, and style inconsistencies. For example, it can flag code that isn’t properly indented, variables that are declared but never used, or functions that are too complex. It’s like having a digital editor that constantly reviews your work, helping you catch mistakes early and stick to a consistent style. As Martin Fowler, author of Refactoring: Improving the Design of Existing Code, famously said, “Any fool can write code that a computer can understand. Good programmers write code that humans can understand.” This captures the heart of why coding standards matter—not just to make the computer happy, but to make the code understandable to other developers.
Beyond web development, this kind of discipline is just as important in other areas of software engineering. For example, if you’re building a game, sticking to coding standards can make it much easier to debug issues, optimize performance, and add new features down the line. It also helps if you plan to release your game as open-source, where other developers might want to contribute to your code. Just like a well-written essay makes it easier for readers to follow your argument, clean, standardized code makes it easier for other developers to understand and build on your work.
User Interface (UI) frameworks are like the building blocks of modern web applications. They provide a set of pre-written components and tools that make it faster and easier to create interactive, responsive, and visually appealing user interfaces. Without them, developers would have to build everything from scratch, which can be time-consuming and error-prone. In this course, we used frameworks like React and Next.js, which take care of many common tasks like handling user interactions, managing state, and updating the user interface efficiently.
To put this in perspective, building a web app without a UI framework is a bit like trying to build a house without power tools. You could technically do it, but it would take a lot more time and effort, and the final product might not be as polished. With a framework, you get a solid foundation to build on, along with reusable components like buttons, forms, and navigation bars. This not only speeds up development but also encourages a consistent design across your app, which improves the overall user experience.
Beyond web development, the idea of using frameworks extends into other types of software as well. For example, mobile developers often rely on frameworks like SwiftUI for iOS or Jetpack Compose for Android to speed up their work. Even game developers use frameworks like Unity or Unreal Engine to handle complex graphics and physics, allowing them to focus on the creative aspects of their projects. The concept is the same—by using a framework, you free yourself from reinventing the wheel and can instead focus on building something unique.
Agile Project Management is a way of organizing work that focuses on flexibility, collaboration, and continuous improvement. Unlike traditional project management, which often follows a strict, step-by-step plan, agile methods are more adaptive and responsive to change. In this course, we practiced a style of agile called Issue Driven Project Management (IDPM), which breaks projects into smaller, manageable tasks, each represented by an issue.
To put it simply, it’s like trying to climb a mountain. Instead of focusing only on the peak, you break the journey into smaller, more achievable steps, adjusting your route as you go based on what you encounter. This approach allows teams to adapt to unexpected challenges, prioritize the most important features, and deliver value quickly.
Beyond web development, this mindset is valuable in any field where projects can be unpredictable or complex. For example, if you’re part of a marketing team launching a new campaign, using an agile approach means you can tweak your strategy based on real-time feedback, rather than being locked into a rigid plan. It’s also useful in event planning, product design, or even personal projects, where being able to pivot quickly can make all the difference. Overall, learning to work this way has helped me appreciate the importance of flexibility and collaboration in software engineering. It’s not just about getting the code right, but about building the right thing, with the right priorities, at the right time.
As I reflect on this course, it’s clear that I’ve gained more than just the technical skills needed to build a web application. I’ve learned the importance of writing clean, readable code through coding standards, the power of user interface frameworks in creating seamless user experiences, and the value of agile project management in keeping projects organized and adaptable. These are not just technical tools, but foundational concepts that shape how software is designed, built, and maintained. What stands out most is how these lessons extend beyond just web development. Whether I’m working on a game, building a mobile app, or even tackling a project outside of tech, the principles I’ve learned here will stay with me. They’ve given me a broader perspective on what it means to be a software engineer—not just a coder, but a problem solver, a collaborator, and a designer of meaningful solutions. In the end, this course has been a reminder that building great software isn’t just about writing code that works, but about writing code that lasts, adapts, and can be understood by others. It’s about thinking beyond the browser and embracing the full craft of software engineering.
This essay was written with the help from AI. I collaborated with AI to help brainstorm and organize the structure of this essay, but all the final content, voice, and personalization were reviewed and tailored by me.