Foreword
Preface
Acknowledgments

Part I. Putting the Domain Model to Work

1.       Crunching Knowledge

Why It Worked
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 II. 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
       Advantages
       Disadvantages
       Other Kinds of Isolation

5.       A Model Expressed in Software

Associations
Entities (aka 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 (aka 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 the Invariant Logic Go?
       ENTITY Factories Versus Value Object Factories
       Reconstituting Stored Objects
Repositories
       Querying a RepositorY
       Client Code Ignores RepositorY Implementation; Developer Does Not
       Implementing a RepositorY
       Working Within Your Frameworks
       The Relationship with Factories
Designing Objects for Relational Databases

7.       An Extended Example: Using the Language

Part III. Refactoring Toward Deeper Insight

8.       Breakthrough

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
       Validation

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 (aka Policy)
Composite
       Why Not Flyweight?

13.       Bringing the Pieces Together

Initiation
Exploration Teams
Prior Art
A Design for Developers
Timing
Crisis As Opportunity

Part IV. 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 Doesnt 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 Dont 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
Index