CST438 - Final Module

What did I learn in the final week of CST438?

The five most important things I learned within this course were TDD's Red-Green-Refactor cycle, the testing pyramid paired with first principles, REST/Spring fundamentals, Agile vs. Plan-and-Document process, and google's structured code review model. Each of those five were very informative on how one designs, implements, and coordinates given project specifications or code methodologies. The following are all five spoken in more depth:

1. TDD's Red-Green-Refactor cycle. The main point about this particular topic that makes it important is Martins rule over not writing production code without a failing test first, which turns things like unit tests into a design process rather than something done afterward to test everything as an afterthought.

2. The testing pyramid paired with first principles. This topic is important in that you would need to know how unit tests and system/end-to-end tests are combined with first principles, illustrating a standard structure or outcome of what a test should look like. Basically, the main gist of first is fast, independent, repeatable, self-checking, and timely, which makes it so that each test must follow that methodology to make a 'good test'.

3. REST/Spring fundamentals. This topic was important in that it set the basic tone towards implementing, organizing and testing everything through specific file structures to orchestrate both the backend and frontend functionality. Furthermore, DTOs were something I found to be strange at first, but they are meant to avoid infinite recursion, which keeps the database from leaking from a public API.

4. Agile vs. Plan-and-Document. This topic was important in that it illustrated the pros and cons of two separate coding processes. Agile did things through iterations that were flexible and without a fixed point of implementation, while a plan-and-document (waterfall process) is rigid and without flexibility, but can allow for a structured implementation process towards the necessary requirements without straying.

5. Google's structured code review model. This topic was important in how it showed three distinct review gates/approvals based on correctness, ownership, and readability. It framed the review process into clear divisions of responsibility rather than something one could simply overlook or gloss over. Basically, checking to see if the code matches what is used throughout the codebase, whether it is properly organized, and if everything works as intended.

In the end, I wouldn't remove any of the current topics as they are all fundamental in their own right, but I would like to add a topic that goes over @Query(...), as there wasn't much that was gone over for it and yet it was on the final exam anyway. Another thing I would like to have added to the course is simply more hands-on Mockito practice as that wasn't really used much outside of the labs.