CST438 - Week 3

 Hey everyone,

This week’s lessons focused on two essential aspects of software engineering — testing and version control with Git. Through the readings, videos, and labs, I learned how both areas are crucial for building reliable software and working effectively in a team. The testing materials emphasized the importance of having a strong suite of automated tests to ensure that code works as expected and can be changed safely over time. The Git labs and videos helped me understand how developers collaborate on code, manage changes, and prevent conflicts in shared projects.

From the testing labs and readings, I learned that testing isn’t just something done at the end of development; it’s an ongoing process that supports every stage of building software. The concept of the testing pyramid stood out — most tests should be unit tests (around 80%), followed by integration tests (15%) and a small number of end-to-end tests (5%). I also learned that small tests are limited to a single process, making them fast and reliable. The benefits of testing became clear: it reduces debugging time, gives more confidence when making changes, improves documentation, and can even lead to better API design. I also found it interesting that, before Google fully adopted automated testing, a large percentage of their production changes had to be rolled back due to bugs — showing how vital testing truly is.

In the Git labs, I learned about the basic commands and workflows that allow developers to work together efficiently. Commands like git add, git commit, and git branch help track changes, save progress, and organize development work. I also learned how to resolve merge conflicts, which occur when two developers make changes to the same line of code. The videos on reviewing pull requests in GitHub demonstrated how collaboration and code review ensure quality before changes are merged into the main branch. Overall, Git allows teams to experiment safely, manage versions of their code, and keep a clear record of every change.

Using Git for source code management has many advantages that make it the industry standard for software development today. One of the main strengths of Git is its distributed nature — every developer has a full copy of the repository, including its entire history. This allows developers to work independently, even without an internet connection, and still have access to all project versions. Git also makes branching and merging easy and efficient, encouraging experimentation and parallel development. Developers can create branches to try new features, fix bugs, or test ideas without affecting the main codebase. Once changes are tested and reviewed, they can be merged back into the main branch. Git also provides a detailed history of changes, showing who made what modifications and why, which is extremely useful for tracking bugs and understanding project evolution. Integration with platforms like GitHub or GitLab adds powerful collaboration tools such as pull requests and code reviews, improving teamwork and code quality.

However, while Git handles merging very well at the technical level, there are still problems it cannot solve automatically. Git’s merge tool can only resolve changes in text — it doesn’t understand the meaning of code. For example, if two developers modify the same function in different ways, Git can identify the conflict, but it cannot determine which change is logically correct. Similarly, even if changes occur in different parts of the code and Git merges them without conflicts, logical conflicts may still occur — meaning the program may compile but behave incorrectly. Git also cannot handle design inconsistencies that arise when multiple developers implement features that overlap or contradict each other. In short, Git efficiently manages code versions and tracks changes, but it cannot replace communication, coordination, and thoughtful code review among team members.

In summary, Git is an excellent tool for source code management because it supports collaboration, provides reliable version tracking, and enables flexible workflows. But successful collaboration also depends on human judgment — developers must still communicate, review, and test carefully to catch integration issues that Git cannot detect on its own.

Finally, the Agile and project setup videos helped me understand how modern teams organize their work. Agile emphasizes iteration, communication, and flexibility — values that tie closely with both testing and Git practices. Setting up our group project repository on GitHub allowed us to apply what we learned in a practical way, combining Agile teamwork with solid testing and version control habits.

Overall, this week taught me how testing and Git form the foundation of professional software development. Testing ensures that software is correct and reliable, while Git enables collaboration and continuous improvement. Together, they create a workflow that helps teams build high-quality software efficiently and confidently.

Comments

Post a Comment

Popular posts from this blog

CST 370 - Week 1

 Hey everyone, This week, we learned several important topics that form the foundation of computer science and programming. We started with GitHub and practiced using manual commands like git init, git add, git commit, and git push to manage our code. This helped us understand version control and how to keep track of changes when working on projects, especially when collaborating with others. We were also introduced to algorithms and learned what they are—step-by-step methods for solving problems. One example we focused on was Euclid’s Algorithm for finding the greatest common divisor (GCD) of two numbers. It uses a simple but powerful idea: repeatedly replace the numbers with GCD(b, a % b) until the second number becomes zero. We also practiced writing pseudocode, which helped us plan out algorithms in plain language before coding. We also had a homework assignment to help us further understand GitHub commands. Later in the week, we learned about graphs, both weighted and unweight...
Read more

CST 370 - Week 5

 Hey everyone! This week, I explored several important algorithm design techniques and deepened my understanding of how they are applied in solving complex problems efficiently. One of the key highlights was learning about Quick Sort , a widely used sorting algorithm that relies on the Divide-and-Conquer strategy. I now understand how Quick Sort works by dividing the array into smaller parts around a pivot, sorting those parts recursively, and then combining the results. I also learned about its efficiency and how its performance depends on the choice of the pivot. I also studied Binary Tree traversal methods, such as inorder, preorder, and postorder, and how each serves a specific purpose when working with hierarchical data. Alongside traversal, I learned how to calculate the height of a binary tree , which is a foundational concept for evaluating the balance and efficiency of tree-based data structures. I even added my insights on the class Discord group, explaining an easy calc...
Read more

CST 370 - Week 4

 Hey everyone! This week in class, I focused on two main things: learning about Merge Sort and reviewing for the upcoming midterm . We covered Merge Sort in detail, and it really helped me understand how divide-and-conquer algorithms work. I learned that Merge Sort breaks down an array into smaller parts, sorts each part, and then merges them back together in a sorted order. What stood out to me is how efficient it is, especially for large datasets, with a time complexity of O(n log n) . I found the recursive nature of the algorithm interesting, and practicing it helped me see how smaller problems can be solved independently and then combined to solve the larger problem. Aside from learning new material, a big part of this week was focused on reviewing for the midterm . I went over topics from previous weeks like brute-force algorithms, string matching, and graph traversal methods (DFS and BFS). I also spent time practicing problems and using flashcards to reinforce key concepts....
Read more