Clean Architecture A Craftsmans Guide to Software Structure and Design (Robert C. Martin)（Z-Library）

【One-Line Pitch】 A veteran architect's argument that software structure is governed by a small set of timeless rules, and that following them is the only way to stay productive as systems age. Best for working programmers, tech leads, and anyone who inherits or designs systems they'll have to live with for years. 【Book Arc】 - **Opening (~0%–10%)**: Frames design and architecture as the same discipline and attacks the "we'll clean it up later" mindset, arguing that mess-making is slower on every timescale, not just the long one. - **Early (~10%–25%)**: Surveys the three programming paradigms—structured, object-oriented, and functional—as disciplines that restrict what programmers may do, with OO recast as a tool for controlling source-code dependencies. - **Early–Middle (~25%–40%)**: Moves from code-level principles (SRP, OCP, LSP, ISP, DIP) to component principles (REP, CCP, CRP, ADP, SDP, SAP), explaining how classes cohere into releasable, acyclic, stable-yet-abstract units. - **Middle (~40%–55%)**: Turns to architecture proper: keeping options open, decoupling layers and use cases, and the warning that apparent duplication is often accidental and should not be merged. - **Late (~55%–80%)**: Presents the book's central prescription—boundaries, the Dependency Rule, and the layered shape that keeps high-level policy independent of databases, web servers, and frameworks. - **Ending (~80%–100%)**: Case studies of architectural failure and success (including FitNesse), plus guidance on embedded, service-oriented, and detail-heavy systems, closing on what is essential versus merely a "detail." 【Key Takeaways】 - **Architecture and design are the same thing** (Opening): The book refuses to separate high-level structure from low-level code decisions, so "architecture" is not a phase but a continuous activity. - **Mess slows you down immediately, not eventually** (Opening): Martin rejects the common belief that dirty code buys short-term speed, arguing the cost is paid right away and compounds. - **Paradigms are restrictions, not features** (Early): Structured programming removes goto, OO removes unrestricted function pointers, functional removes assignment—each discipline narrows what you can do to make reasoning possible. - **OO's real value is dependency control** (Early): Polymorphism lets architects invert source-code dependencies so high-level policy never depends on low-level detail, enabling independently deployable and developable modules. - **Components should be cohesive, acyclic, and stable-where-abstract** (Early–Middle): The component principles (REP, CCP, CRP, ADP, SDP, SAP) give concrete criteria for what belongs together and which direction dependencies should point. - **Delay decisions you don't need to make yet** (Middle): Databases, web servers, frameworks, and DI containers are details; keeping high-level policy ignorant of them preserves options and reduces rework. - **Not all duplication is real** (Middle): Similar screens, schemas, or algorithms often diverge later; merging them prematurely couples layers and use cases that should stay separate. - **The Dependency Rule is the spine of the book** (Late): Source-code dependencies must point inward, toward higher-level policy, with boundaries drawn so details plug into—not into—the core. 【Reading Tips】 - Read Part I and the paradigm chapters quickly for framing, then slow down for the SOLID and component-principle chapters—those are the load-bearing arguments. - Treat the case studies as calibration, not recipes: they show how premature framework adoption and SoA enthusiasm went wrong, which is more instructive than the success story. - Keep a mental (or literal) diagram of the Dependency Rule as you read; almost every later chapter is an application of it. - Skim the embedded and service-oriented material if it isn't your domain, but read the "what is a detail" discussion carefully—it reframes everyday technology choices. 【Coverage Limits】 The excerpts cover the book's framing, paradigm survey, SOLID and component principles, boundary/dependency discussion, and case-study material, but do not include the full text of every chapter or the detailed code examples. Specific chapter-level content beyond what is quoted here is not represented.