Domain-Driven Refactoring (Alessandro Colla, Alberto Acerbis)（Z-Library）

【One-Line Pitch】 A practical playbook for turning a tangled legacy monolith into a modular, event-driven system using DDD as the compass—written for developers, architects, and tech leads who want incremental, test-backed refactoring rather than a big-bang rewrite. 【Book Arc】 - **Opening (~0%–12%)**: Sets the stage by tracing DDD's evolution from the 1960s "software crisis" through Evans, CQRS, and microservices, framing why domain-driven thinking is the antidote to code-and-fix development. - **Early (~12%–36%)**: Builds the conceptual toolkit—complexity and the Cynefin framework, EventStorming, cognitive biases in refactoring, then strategic patterns (bounded contexts, context mapping, subdomains) and tactical patterns (entities, value objects, aggregates, repositories, domain/integration events). - **Middle (~36%–62%)**: Moves into hands-on legacy refactoring: establishing CI/CD and observability, applying SOLID and the strategy pattern, identifying core domains, building a modular monolith with mediator/facade, then integrating events via CQRS and Event Sourcing, refactoring the database, and wiring DDD into continuous integration. - **Late (~62%–100%)**: Escalates to distributed systems—when and why to move from modular monolith to microservices, managing event versioning (upcasting, schema evolution), and orchestrating complex business processes with sagas, choreography vs. orchestration, and consistency under failure. 【Key Takeaways】 - **Refactoring is strategic, not just cleanup** (Opening): The book frames domain-driven refactoring as preparing software for future evolution, not merely repairing past technical debt—a forward-looking stance that shapes every later technique. - **Complexity must be diagnosed before it's solved** (Early): Cynefin, residuality theory, and deliberate discovery give readers a vocabulary for distinguishing clear, complicated, complex, and chaotic problems—so refactoring effort lands where it matters. - **Bounded contexts are the unit of decomposition** (Early): Dividing the domain into meaningful boundaries, then mapping relationships (shared kernel, customer-supplier, ACL, OHS, published language), is presented as the foundation for both modular monoliths and microservices. - **Tactical patterns earn their keep through events** (Early–Middle): Entities, value objects, aggregates, and repositories are paired with domain vs. integration events, showing how event flow and information flow differ in a real application (the brewery example). - **Safe change requires CI/CD and tests first** (Middle): The book insists on establishing continuous integration, observability, and the testing pyramid—including specification tests—before touching legacy code, making refactoring reversible and measurable. - **Modular monolith is a legitimate destination, not a waypoint** (Middle): Mediator and facade patterns, clear interfaces, and event-driven CQRS let teams stabilize a monolith before considering distribution—avoiding premature microservices. - **Database refactoring follows domain boundaries** (Middle): Shared tables are refactored using patterns like Expand/Contract, evolutionary database development, and distributed data access strategies (replicated caching, schema replication) to keep consistency while extracting services. - **Microservices demand readiness assessment** (Late): The book weighs monolith vs. microservices trade-offs, distributed-computing fallacies, and readiness signals—arguing that a modular monolith is the proper foundation and that mediator patterns fall short for true decoupling. - **Events evolve; plan for it** (Late): Event versioning via upcasting, schema evolution, and content negotiation, plus sagas and choreography/orchestration, address the long-term consistency challenges of event-sourced distributed systems. 【Reading Tips】 - **Deep-read Parts 1 and 2** if you're new to DDD or facing a legacy codebase—the strategic and tactical patterns plus the CI/CD/testing groundwork are the book's practical core. - **Skim the historical opening** (Chapter 1) if you already know DDD's lineage; return to it only for the framing of essential vs. accidental complexity. - **Treat Part 3 as a decision guide**, not a mandate—use the readiness signals and trade-off discussions to judge whether microservices are right for your context before adopting sagas or event versioning. - **Follow the brewery application** as a running case study; tracing one domain through strategic patterns, CQRS, and database refactoring cements how the pieces connect. - **Keep the pattern catalog handy** (context mapping types, database refactoring patterns, event evolution strategies) as reference during real refactoring work rather than reading linearly. 【Coverage Limits】 The excerpts cover the book's structure, chapter summaries, and conceptual framing thoroughly, but contain little verbatim code or worked examples beyond the brewery application's outline; specific implementation details and chapter-level depth are only partially represented.