This series will update the summary and reading notes of Google's software engineering principles.
Time and Change#
Between one-time projects and decade-long projects, there is a transition: a project must start responding to constantly changing external factors.
For any project without an upgrade plan from the beginning, this transition can be very painful for three reasons, each of which complicates the others.
- You are executing tasks that are not yet completed in this project; more hidden assumptions have been established.
- Engineers attempting the upgrade are unlikely to have experience with such tasks.
- The scale of the upgrade is usually larger than usual, completing several years of upgrades at once instead of incremental upgrades.
We need a clearer understanding of the difference between "works by coincidence" and "maintainable."
Halem's Law - If there are enough users, your contractual commitments don't matter: all observable behavior of your system will be relied upon.#
Cleverness vs. Simplicity and Maintainability: Depending on the categorization of programming styles, code that relies on fragile or unreleased content falls into the former, while following best practices and planning for the future falls into the latter.
If this task is considered too costly and should be avoided in the future, we may still be using a compiler version from ten years ago. Missing out on optimization opportunities could result in a 25% increase in computational resources.
Stagnation is a choice, but often not a wise one.
Left Shift#
Shifting security issues to the left can reduce costs when problems are discovered early in the development process.
Investment in Decision Making - Distributed Architecture#
As the codebase grows larger, compilation times also increase. Investing more resources in local machines may not be a good investment, as high-performance desktop development machines are often idle in most cases.
Developing a distributed build system and deploying it in production speeds up the build process for everyone. However, over time, the distributed build system itself becomes bloated.
The cost savings from implementing a distributed build system may outweigh the negative costs of "building and maintaining." However, as these costs increase, we cannot foresee all of them.
Software Engineering vs. Programming#
Programming is the direct act of generating code; software engineering is a set of strategies, implementation methods, and tools.