New
Pages
404
Published
2018
Programming
✨ New
Clean Architecture
A Craftsman's Guide to Software Structure and Design
Learn to structure software so that business rules stay independent of frameworks, databases, and UIs — and your systems stay maintainable for years.
Clean Architecture lays out a discipline for organizing software into layers where policy drives implementation, not the other way around. Robert C. Martin draws on decades of hard-won experience to show how the same principles that govern a single function — cohesion, coupling, separation of concerns — scale up to entire systems. The result is software that is testable, deployable, and replaceable piece by piece, without rewriting the core.
About this book
Most software rot starts with the same mistake: business logic that knows too much about the database, the framework, or the delivery mechanism. Fix that mistake and you fix a whole class of maintenance problems. That is what Clean Architecture is about.
Robert C. Martin — known to most developers as "Uncle Bob" — synthesizes decades of software craftsmanship into a coherent set of architectural principles. He starts from first principles: what software design is actually for, why structure matters, and how seemingly small decisions about dependency direction compound over years into systems that are either easy or painful to change.
The book walks through the SOLID principles with fresh emphasis on why they matter at the architectural level, not just inside a class. It then builds up to the component principles — cohesion and coupling — and shows how those translate directly into decisions you make every day: what belongs in a library versus a service, where to draw a boundary, how to insulate your core business rules from volatile details like databases and web frameworks.
The central idea — the Clean Architecture diagram with its concentric rings — is simple enough to sketch on a whiteboard and concrete enough to apply to a real codebase this week. Martin shows it working in a variety of contexts: web applications, embedded systems, and services. He is explicit about trade-offs and honest about when the full pattern is overkill.
- Understand why the dependency rule — pointing inward, always — prevents entire categories of design problems
- Apply SOLID principles at the system level, not just inside individual classes
- Draw boundaries that let you defer expensive infrastructure decisions until you have more information
- Recognize the difference between architecturally significant decisions and details that should be easy to swap
- Use the Humble Object pattern to make code that talks to databases, UIs, and external services unit-testable
If you have ever inherited a codebase where changing the database schema required touching the UI, or where unit tests required a running web server, this book explains exactly why that happened and how to prevent it. The lessons apply whether you are building a monolith, a set of microservices, or something in between.
🎯 What you'll learn
- Explain why software architecture exists and what it is actually trying to optimize for
- Apply the SOLID principles at the architectural scale, not just within a single class or module
- Identify and enforce component boundaries that protect business rules from framework and infrastructure churn
- Use the dependency rule to determine the correct direction of every relationship in your system
- Defer costly infrastructure decisions — database choice, framework selection — without blocking development
- Test business logic in isolation from databases, web servers, and external services
- Recognize common architectural patterns — layered, hexagonal, screaming — and understand what they have in common
👤 Who is this book for?
- Backend and full-stack engineers who write code that works today but becomes hard to change tomorrow
- Developers who have read about design patterns but want a principled way to structure entire systems
- Tech leads and architects who need a shared vocabulary for explaining structural decisions to their teams
- Engineers moving from writing features to owning codebases and making higher-level design choices
- Anyone who has felt the pain of a tightly coupled codebase and wants a practical framework for doing better
Table of contents
-
01
What Is Design and Architecture?
Martin establishes why architecture matters by showing that the cost of development grows over time in poorly structured systems — and that this growth is not inevitable. You examine what good architecture is actually optimizing for.
-
02
A Tale of Two Values
You learn to distinguish behavior from structure and understand why keeping structure clean has long-term business value, even when stakeholders push for features over refactoring.
-
03
Paradigm Overview and the Three Paradigms
A concise tour of structured, object-oriented, and functional programming shows how each paradigm removes a degree of freedom — and what that means for architectural discipline.
-
04
SOLID Principles
You work through each SOLID principle with emphasis on why each one matters at the module and architectural level, not just inside individual classes and methods.
-
05
Component Principles
Martin applies cohesion and coupling rules to components — libraries, services, and subsystems — giving you concrete criteria for deciding what belongs together and what must be separated.
-
06
What Is Architecture?
You get a precise definition of architecture as the shape of a system intended to support its lifecycle, and see how the dependency rule follows from that goal.
-
07
Boundaries and the Dependency Rule
This chapter makes the dependency rule concrete: every source-code dependency must point inward, toward higher-level policy. You see how to draw and enforce those boundaries in real code.
-
08
Business Rules and the Clean Architecture Diagram
Martin introduces the concentric-ring diagram and maps it to actual code — entities, use cases, interface adapters, and frameworks. You see how data crosses boundaries without violating the dependency rule.
-
09
The Main Component and Details
You learn how the outermost layer — the entry point of your application — acts as a plugin, and why the database, web framework, and UI are all details that should be easy to replace.
-
10
Case Studies and Closing Principles
Martin walks through architectural decisions on real systems, including an embedded target and a video sales site, then closes with honest guidance on when full Clean Architecture is warranted and when a simpler approach is the right call.
Frequently asked questions
Do I need to know a specific programming language to get value from this book?
No. The examples are language-agnostic or use Java and C-style pseudocode for illustration. The principles apply equally to Python, C#, Go, or any object-oriented or structured language you work in.
Is this book suitable for intermediate developers, or is it aimed at senior engineers?
It is written for any working developer who has shipped production code and started noticing that things get harder to change over time. Mid-level engineers will find it immediately applicable. Beginners who have not yet felt the pain of a badly structured codebase may find the motivation less obvious.
How does this book relate to the earlier Clean Code by the same author?
Clean Code focuses on writing readable, well-structured code at the function and class level. Clean Architecture operates at a higher level — components, boundaries, and the overall shape of a system. They complement each other but can be read independently.
Is the content still current given that the book was published in 2018?
Yes. The book deliberately focuses on principles that predate and outlast specific frameworks. The dependency rule, component cohesion, and boundary design are as relevant today as when the book was written.
Does the book cover microservices?
Microservices appear as one of several deployment options. Martin argues that the architectural principles are the same regardless of whether you deploy as a monolith or a set of services — the book focuses on those underlying principles rather than on microservices as a pattern.
You might also like
New
New
Introduction to Algorithms, fourth edition
The definitive reference on algorithms and data structures for students and practicing engineers
by Charles E. Leiserson, Clifford Stein, Ronald L. Rivest, Thomas H. Cormen
2022
View →
New
A Philosophy of Software Design
Timeless principles for managing complexity and writing software that lasts
2021
View →
New
Designing Data-Intensive Applications
The big ideas behind reliable, scalable, and maintainable systems
2017
View →