Domain-Driven Design: Tackling Complexity in the Heart of Software

Foreword.
Preface.
Acknowledgments.

Part 1: PUTTING THE DOMAIN MODEL TO WORK.
1. Crunching Knowledge.
-Ingredients of Effective Modeling.
-Knowledge Crunching.
-Continuous Learning.
-Knowledge-Rich Design.
-Deep Models.

2. Communication and the Use of Language.
-UBIQUITOUS LANGUAGE.
-Modeling Out Loud.
-One Team, One Language.
-Documents and Diagrams.
-Written Design Documents.
-Executable Bedrock.
-Explanatory Models.

3. Binding Model and Implementation.
-MODEL-DRIVEN DESIGN.
-Modeling Paradigms and Tool Support.
-Letting the Bones Show: Why Models Matter to Users.
-HANDS-ON MODELERS.

Part 2: THE BUILDING BLOCKS OF A MODEL-DRIVEN DESIGN.
4. Isolating the Domain.
-LAYERED ARCHITECTURE.
-Relating the Layers.
-Architectural Frameworks.
-The Domain Layer Is Where the Model Lives.
-THE SMART UI "ANTI-PATTERN"
-Other Kinds of Isolation.

5. A Model Expressed in Software.
-Associations.
-ENTITIES (A.K.A. REFERENCE OBJECTS).
-Modeling ENTITIES.
-Designing the Identity Operation.
-VALUE OBJECTS.
-Designing VALUE OBJECTS.
-Designing Associations That Involve VALUE OBJECTS.
-SERVICES.
-SERVICES and the Isolated Domain Layer.
-Granularity.
-Access to SERVICES.
-MODULES (A.K.A. PACKAGES).
-Agile MODULES.
-The Pitfalls of Infrastructure-Driven Packaging.
-Modeling Paradigms.
-Why the Object Paradigm Predominates.
-Nonobjects in an Object World.
-Sticking with MODEL-DRIVEN DESIGN When Mixing Paradigms

6. The Life Cycle of a Domain Object.
-AGGREGATES.
-FACTORIES.
-Choosing FACTORIES and Their Sites.
-When a Constructor Is All You Need.
-Designing the Interface.
-Where Does Invariant Logic Go?
-ENTITY FACTORIES Versus VALUE OBJECT FACTORIES.
-Reconstituting Stored Objects.
-REPOSITORIES.
-Querying a REPOSITORY.
-Client Code Ignores REPOSITORY Implementation; Developers Do Not.
-Implementing a REPOSITORY.
-Working Within Your Frameworks.
-The Relationship with FACTORIES.
-Designing Objects for Relational Databases.

7. Using the Language: An Extended Example.
-Introducing the Cargo Shipping System.
-Isolating the Domain: Introducing the Applications.
-Distinguishing ENTITIES and VALUE OBJECTS.
-Role and Other Attributes.
-Designing Associations in the Shipping Domain.
-AGGREGATE Boundaries.
-Selecting REPOSITORIES.
-Walking Through Scenarios.
-Sample Application Feature: Changing the Destination of a Cargo.
-Sample Application Feature: Repeat Business.
-Object Creation.
-FACTORIES and Constructors for Cargo.
-Adding a Handling Event.
-Pause for Refactoring: An Alternative Design of the Cargo AGGREGATE.
-MODULES in the Shipping Model.
-Introducing a New Feature: Allocation Checking.
-Connecting the Two Systems.
-Enhancing the Model: Segmenting the Business.
-Performance Tuning.
-A Final Look.

Part 3: REFACTORING TOWARD DEEPER INSIGHT.
8. Breakthrough.
-Story of a Breakthrough.
-A Decent Model, and Yet...
-The Breakthrough.
-A Deeper Model.
-A Sobering Decision.
-The Payoff.
-Opportunities.
-Focus on Basics.
-Epilogue: A Cascade of New Insights.

9. Making Implicit Concepts Explicit.
-Digging Out Concepts.
-Listen to Language.
-Scrutinize Awkwardness.
-Contemplate Contradictions.
-Read the Book.
-Try, Try Again.
-How to Model Less Obvious Kinds of Concepts.
-Explicit Constraints.
-Processes as Domain Objects.
-SPECIFICATION
-Applying and Implementing SPECIFICATION.

10. Supple Design.
-INTENTION-REVEALING INTERFACES.
-SIDE-EFFECT-FREE FUNCTIONS.
-ASSERTIONS.
-CONCEPTUAL CONTOURS.
-STANDALONE CLASSES.
-CLOSURE OF OPERATIONS.
-DECLARATIVE DESIGN.
-Domain-Specific Languages.
-A Declarative Style of Design.
-Extending SPECIFICATIONS in a Declarative Style.
-Angles of Attack.
-Carve Off Subdomains.
-Draw on Established Formalisms, When You Can.

11. Applying Analysis Patterns.

12. Relating Design Patterns to the Model.
-STRATEGY (A.K.A. POLICY).
-COMPOSITE.
-Why Not FLYWEIGHT?

13. Refactoring Toward Deeper Insight.
-Initiation.
-Exploration Teams.
-Prior Art.
-A Design for Developers.
-Timing.
-Crisis as Opportunity.

Part 4: STRATEGIC DESIGN.
14. Maintaining Model Integrity. BOUNDED CONTEXT.
-Recognizing Splinters Within a BOUNDED CONTEXT
-CONTINUOUS INTEGRATION.
-CONTEXT MAP.
-Testing at the CONTEXT Boundaries.
-Organizing and Documenting CONTEXT MAPS.
-Relationships Between BOUNDED CONTEXTS.
-SHARED KERNEL.
-CUSTOMER/SUPPLIER DEVELOPMENT TEAMS.
-CONFORMIST.
-ANTICORRUPTION LAYER.
-Designing the Interface of the ANTICORRUPTION LAYER.
-Implementing the ANTICORRUPTION LAYER.
-A Cautionary Tale.
-SEPARATE WAYS.
-OPEN HOST SERVICE.
-PUBLISHED LANGUAGE.
-Unifying an Elephant.
-Choosing Your Model Context Strategy.
-Team Decision or Higher.
-Putting Ourselves in Context.
-Transforming Boundaries.
-Accepting That Which We Cannot Change: Delineating the External Systems.
-Relationships with the External Systems.
-The System Under Design.
-Catering to Special Needs with Distinct Models.
-Deployment.
-The Trade-off.
-When Your Project Is Already Under Way.
-Transformations.
-Merging CONTEXTS: SEPARATE WAYS-SHARED KERNEL.
-Merging CONTEXTS: SHARED KERNEL-CONTINUOUS INTEGRATION.
-Phasing Out a Legacy System.
-OPEN HOST SERVICE-PUBLISHED LANGUAGE.

15. Distillation.
-CORE DOMAIN.
-Choosing the CORE.
-Who Does the Work?
-An Escalation of Distillations.
-GENERIC SUBDOMAINS.
-Generic Doesn't Mean Reusable.
-Project Risk Management.
-DOMAIN VISION STATEMENT.
-HIGHLIGHTED CORE.
-The Distillation Document.
-The Flagged CORE.
-The Distillation Document as Process Tool.
-COHESIVE MECHANISMS.
-GENERIC SUBDOMAIN Versus COHESIVE MECHANISM.
-When a MECHANISM Is Part of the CORE DOMAIN.
-Distilling to a Declarative Style.
-SEGREGATED CORE.
-The Costs of Creating a SEGREGATED CORE.
-Evolving Team Decision.
-ABSTRACT CORE.
-Deep Models Distill.
-Choosing Refactoring Targets.

16. Large-Scale Structure.
-EVOLVING ORDER.
-SYSTEM METAPHOR.
-The "Naive Metaphor" and Why We Don't Need It.
-RESPONSIBILITY LAYERS.
-Choosing Appropriate Layers.
-KNOWLEDGE LEVEL.
-PLUGGABLE COMPONENT FRAMEWORK.
-How Restrictive Should a Structure Be?
-Refactoring Toward a Fitting Structure.
-Minimalism.
-Communication and Self-Discipline.
-Restructuring Yields Supple Design.
-Distillation Lightens the Load.

17. Bringing the Strategy Together.
-Combining Large-Scale Structures and BOUNDED CONTEXTS.
-Combining Large-Scale Structures and Distillation.
-Assessment First.
-Who Sets the Strategy?
-Emergent Structure from Application Development.
-A Customer-Focused Architecture Team.
-Six Essentials for Strategic Design Decision Making.
-The Same Goes for the Technical Frameworks.
-Beware the Master Plan.

Conclusion.
Appendix: The Use of Patterns in This Book.

Glossary.
References.
Photo Credits.