Week 8 Learning Journal- CST438

This class has provided a clear view of the transition from writing code to engineering systems. Below are the five most important things I learned in the course and the reasons why I believe they are vital for my development as a software engineer.

1. The Difference Between Programming and Engineering

I used to think these terms were interchangeable, but I now understand that software engineering is "programming integrated over time". Programming is about the immediate task of solving a problem, whereas engineering is about making sure that solution can survive changes in teams, technology, and requirements over several years. This shift in perspective is important because it changes how I prioritize code quality and documentation.

2. The Power of the Testing Pyramid

Before this class, I viewed testing as a final check rather than a continuous process. Learning about the "Testing Pyramid" taught me to build a foundation of many small, fast unit tests rather than relying only on slow system tests. I also practiced Test-Driven Development (TDD), which involves writing a failing test before writing any actual code. This ensures the requirements are clear and that I have a safety net for future changes.

3. Identifying and Managing Technical Debt

Technical debt is a concept that perfectly explains why "quick" fixes often cause long-term pain. It represents the future work required because a developer took a shortcut earlier in the project. I chose this because it is a practical reality in the industry. I learned that we should manage this debt by explicitly scheduling refactoring tasks during our development cycles so the codebase remains maintainable.

4. React State and the Importance of Immutability

On the technical side, working with React showed me why immutability is so critical for modern user interfaces. Instead of changing data directly, we use the spread operator to create new versions of state. This approach makes the application much more predictable because it allows React to efficiently track changes and update only the necessary parts of the screen. It effectively eliminates a whole category of bugs related to unexpected side effects.

5. Using Coupling and Cohesion to Guide Design

I learned that good architecture depends on two main things: high cohesion and low coupling. High cohesion means a single component stays focused on doing one job well. Low coupling ensures that different parts of the system do not depend too heavily on each other. This is especially important for Service-Oriented Architecture because it allows us to update or replace one service without breaking the entire application.

I chose these topics because they provide a roadmap for building professional software. They move beyond basic syntax and focus on the principles that keep a project healthy as it grows in size and complexity.