A Practical Guide to Building Software That Can Change: Software Design Principles, Trade-offs, and Architecture for Working Developers

Your code works. Will it survive the next change?

Every developer knows the moment: a "one-line change" that takes a week, a fix that breaks something nobody touched, a module the whole team is afraid of. The problem is rarely the syntax. It is the design. This book shows you how to build software that stays easy to change, from a single method to the architecture of a whole system.

AI can generate code quickly. It cannot reliably decide whether that code belongs in the right module, whether an API contract will survive change, whether a business rule has a single owner, or whether a system will remain understandable after six months of new requirements. The developers who thrive with AI agents are not the ones who merely prompt tools; they are the ones who can evaluate generated solutions, spot hidden coupling, reason about complexity, design stable interfaces, and prevent an AI-generated shortcut from becoming tomorrow’s production incident.

What you will learn

• The core principles and their trade-offs: DRY, KISS, YAGNI, coupling and cohesion, separation of concerns, clean code and SOLID, as tools rather than laws.
• Object-oriented design that protects your business rules: invariants, value objects, composition over inheritance, and polymorphism that removes repeated conditionals.
• Design for testability: reproduce a double-charge bug in a test that runs in milliseconds, prefer fakes to brittle mocks, and change legacy code safely.
• What to do when principles conflict: eight common conflicts, and the questions that settle them.
• Boundaries, data and APIs: error contracts, idempotency, pagination, versioning, authorization, transactions, migrations and caching.
• From requirements to architecture: measurable quality goals, modular monoliths, ports and adapters, circuit breakers and decision records.
• Communicating design: the diagrams that pay off, the C4 model, and diagrams the build keeps true.
• Soft skills for design decisions: explain technical risk in money and customers, write a one-page proposal, review designs without conflict, and turn disagreement into a decision.

Inside the book

• 11 chapters in three parts: Changeable Code, Changeable Systems, Design in Practice
• Three case studies that start from a blank page: a buyer-supplier system, a restaurant ordering API and a B2B product integration
• 70 figures drawn for this edition
• Exercises and checklists in every chapter, plus a one-page design review for your next code review
• A "from symptom to principle" guide, a glossary and recommended reading
• Complete, tested Java 17 code on GitHub, chapter by chapter, with no frameworks in the way

Who this book is for

Developers who can already write working code and want that code to be easy to change. Perhaps you work in a business-focused company where design is learned by accident. Perhaps you are preparing for a senior, lead or architect role. Perhaps you have read about SOLID and still wonder when it matters. This book gives you a method you can use on Monday morning. The examples are in Java; the ideas apply equally to C#, Kotlin, TypeScript, Python and other languages.

This second edition is a complete rewrite of Software Design Principles: A Practical Guide (2022), with new chapters on testing, conflicting principles, boundaries and architecture.

Stop fearing the next change request. Scroll up and get your copy today.