CST 438 - Week 4

 Hey everyone,

    While reading Software Engineering at Google, the most interesting and impactful idea I encountered is the concept that software engineering is fundamentally about managing complexity over time, not just writing code that works today. Google frames software engineering as the discipline of building software that continues to be understandable, maintainable, and scalable as systems, teams, and lifespans grow. This long-term perspective reframed how I think about engineering work.

    What stood out most is Google’s idea of “time as the primary scaling factor.” Google’s codebases are expected to outlive individual engineers, teams, and even products. Because of this, Google optimizes for practices that reduce long-term friction—such as code readability, consistency, and maintainability—sometimes even at the expense of short-term productivity. The emphasis on making code easy for someone else to understand years later was striking. It reinforced that engineering isn’t only about solving problems efficiently, but also about communicating intent through code.

    Another aspect I found fascinating was how deeply this philosophy shapes Google’s engineering culture. The book explains how tools like the monorepo, code review norms, style guides, and automated testing systems all exist to preserve clarity and stability across millions of lines of code. I was especially surprised by the idea that readability matters so much that Google has a formal “readability” process, where engineers must be certified before approving changes in certain languages. Prior to reading this, I hadn’t appreciated how organizational mechanisms can reinforce technical values so systematically.

    Finally, what I found most thought-provoking is how Google treats software engineering as an ecosystem rather than a set of isolated practices. Tooling, culture, documentation, testing, and processes are all interdependent. The book made me recognize how large-scale engineering is less about brilliant individual contributions and more about creating an environment where thousands of engineers can collaborate reliably and safely.

    Overall, the biggest insight I gained is that long-term thinking is essential to high-quality engineering. Coding is transient; systems and maintenance endure. Software Engineering at Google helped me see that the real craft lies in building structures—both technical and organizational—that protect the future from the shortcuts of the present.

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