Key Principles for Code Review and Software Architecture

The article begins by referencing a previous long essay on code review and introduces this companion piece that systematically presents well‑known architectural principles, engineer self‑cultivation, and common anti‑patterns observed in large‑scale development.

Known Architecture Principles – Inspired by books such as “The Pragmatic Programmer”, “Clean Architecture” and “The Art of Unix Programming”, the author emphasizes that design and architecture are inseparable, that low‑level details are part of the overall architecture, and that documentation should be close to the code.

Self‑Explanatory Code – Code should be self‑documenting; when comments are needed they must be placed near the relevant code. The article advocates using tools like Go’s godoc and keeping documentation in source.

ETC Value – The “easy to change” (ETC) mindset encourages writing code that can be quickly adapted in agile projects, avoiding hard‑coded values and excessive inheritance.

Key Principles – The text lists and explains DRY, orthogonality, inheritance tax, early failure, avoiding chain calls, avoiding excessive logging, error‑propagation, and the SOLID principles, illustrating each with Go, Java and Python snippets such as:

type Botton interface {
    TurnOn()
    TurnOff()
}

func applyDiscount(customer Customer, orderID string, discount float32) {
    customer.Orders.Find(orderID).GetTotals().ApplyDiscount(discount)
}

It also discusses the importance of dependency inversion (DIP), composition over inheritance, and the use of interfaces to achieve decoupling.

Testing and Reliability – Emphasizes “test early, test often, automate”, the need for fast automated tests, and the practice of writing tests while designing the API (contract‑driven development).

Unix Philosophy – Highlights modularity, clarity, composition, separation of concerns, and the principle “do not communicate by sharing memory; instead share memory by communicating”.

Practical Advice – Includes recommendations on avoiding magic numbers, hard‑coded IPs, excessive init functions, shadow writes, and ensuring that empty implementations are explicitly documented.

Overall, the article provides a comprehensive checklist of best practices for writing clean, maintainable, and collaborative code in modern backend development.