#Design
40 articles
The Lineage of Programming Languages Leading to Go
A source-checked walk through the lineage of programming languages from Algol 60 to Go: Wirth's Pascal-to-Oberon path and Hoare's CSP path through Newsqueak, Alef, and Limbo, and how both streams merge into Go.
9 Books for Writing Good Code (Readability and Refactoring)
A reading list of 9 books for writing readable, change-tolerant code: the basics of readability, improvement through refactoring, facing complexity, and a couple of titles to widen your view. Each entry links to its full review.
12 Books for Learning Software Architecture, from Fundamentals to Practice
A staged reading list of 12 books for learning software architecture, from fundamentals to practice: design basics, trade-offs, domain-driven design, microservices, and API design. Each entry links to its full review.
Microservices Patterns
A review of Microservices Patterns. Chris Richardson's systematic organization of microservice design patterns. From decomposition strategies to Saga-based distributed transactions, API Composition, CQRS, and event sourcing, it lays out the challenges and standard solutions in distributed systems, complete with their trade-offs.
Why the Domain Fades From View in Web Development, and Why It Eventually Comes Back
Understand what a domain really means, why it works as an architectural boundary, and the structural reasons the domain fades from view in web development.
Hands-On API Learning
A review of Hands-On API Learning. A practical book you learn by building, spanning API design, implementation, testing, and operations. It covers essentials for long-term operation such as design principles, documentation, versioning, and security, and works as a checklist for revisiting your own API design.
Good Code, Bad Code
A review of Good Code, Bad Code. A book that concretely shows the difference between good and bad code through lenses like abstraction, modularity, error handling, and testing. It offers judgment criteria you can use directly in daily reviews, such as clarifying contracts, guarding against unexpected input, and making misuse hard.
Simplicity: Sustainable, Humane, and Effective Software Development
A review of Simplicity. A book that asks how to keep software development, so easily swallowed by complexity, simple. Beyond technical techniques, it makes you realize that choices about what not to build and where to stop are what let you keep developing healthily over the long term.
Accidental Complexity and the Absence of Decision Records
How accidental complexity emerges, and why the absence of ADRs and Design Docs makes it hard to tell what is essential from what is accidental.
The Abstraction Trap in Architecture Design
Why sharing domain logic can quietly turn into architectural debt, while technical concerns can safely be shared — with nuance around authorization and PII-sensitive logging.
Differentiating Architecture Strategy, Tactics, and Design
Differentiate architecture strategy, tactics, and design using 5W1H framework to clarify why, what, how, when, where, and who decisions.
Good Architecture Strategy, Bad Architecture Strategy
Even when you write an architecture strategy, it sometimes fails to work, ending up as a strategy in name only or never being executed. Drawing on the book Good Strategy, Bad Strategy, this article organizes the difference between good and bad strategies through the lens of diagnosis, guiding policy, and coherent actions.
Why and When to Write an Architecture Strategy
Develop architecture strategies to eliminate ad-hoc technology decisions and establish technology standards across teams.
Key Points to Consider When Writing an ADR
Master ADR writing by focusing on atomic decisions, documenting trade-offs, team discussions, and technical writing principles for architecture.
Requirements vs Constraints: What's the Difference? (ISO/IEC/IEEE 29148)
Requirements vs constraints, defined by ISO/IEC/IEEE 29148: requirements describe what stakeholders want and stay negotiable, while constraints limit the design space and rarely change. With examples, how to tell them apart, and why non-functional requirements act as constraints.
Balancing Coupling in Software Design: Principles of Modularity for Sustainable Growth
A review of Balancing Coupling in Software Design. A rare book that theoretically teaches how to manage architectural complexity through the lens of coupling. Its perspectives for analyzing coupling are exceptionally well organized, making it a reference you will want to consult while designing.
Clean Code Cookbook: A Recipe Collection for Improving Code Design and Quality
A review of the Clean Code Cookbook. Centered on concepts like bijection and accidental complexity, it lets you learn techniques for improving code design and quality in the form of a recipe collection. It comprehensively covers well-known principles too, making it a book worth keeping close.
Driving Domain with Data Modeling - Towards Distributed and Loosely Coupled Core Systems
A review of a book on driving the domain with data modeling. Centered on the concept of ledgers, it systematically explains data modeling for making core systems distributed and loosely coupled. It proposes splitting activity and management systems and a new 'balance' concept, offering practical guidance for DDD and microservices.
Practical Techniques for Building System Architecture
A review of Practical Techniques for Building System Architecture. A practical guide for engineers doing architecture design in the field. Where the prior book focused on why, this one covers how, from requirements definition to logical and physical design and documentation through views, introducing concrete techniques useful on the ground.
About Architecture, Architects, and Architecting
Understand architecture as essential system structure, architect responsibilities, and architecting activities for building aligned systems.