Complete Pattern Catalog
This book contains thirty patterns organized into five families. Each pattern solves a specific linguistic problem. Together, they form a complete pattern language for designing software through language.
Language Patterns
The foundation. These patterns help you design, split, merge, and govern the words in your lexicon.
Ubiquitous Lexicon
A living map of your core concepts. Not a glossary. A design artifact.
Explicit Context
Name the context that gives each word its meaning. Make the invisible visible.
Meaning Split
When one word carries multiple distinct meanings, split them into separate concepts.
Concept Merge
When two concepts are actually the same, merge them. One concept, one word.
Concept Canonicalization
Pick one canonical name for each concept. Translate all dialects to the canon.
Linguistic Ownership
Every word must have an owner. Someone responsible for its meaning and evolution.
Language Closure
Keep your vocabulary small. Every new word must earn its place.
Semantic Boundary
Draw architectural boundaries where meanings diverge. Protect each meaning.
Modeling Patterns
Translate language into domain models. Aggregates, events, policies, value objects.
State/Status Segregation
State is what something is. Status is where it is in a process. Never mix them.
Behavior as Data
Treat business rules as data, not code. Store, inspect, and orchestrate behavior.
Sequencer
Model sequences explicitly. Steps, transitions, boundaries, and invariants.
Narrative Modeling
Tell the story of what the system actually does. Keep the story with the code.
Intent Before Structure
Write the intent first. One sentence. Justification. Acceptance. Then build.
Conceptual Aggregate
Draw aggregate boundaries by meaning, not by data. Where invariants live.
Semantic Event
Events carry meaning, not just data. The event name is the meaning.
Policy as Language
Write business rules in plain language. Make them executable.
Vocabulary Objects
Tiny types that wrap primitives. Give meaning to strings and numbers.
Architectural Patterns
Draw boundaries, design APIs, integrate systems, and preserve meaning across services.
Lexicon-Oriented Services
Build services around meanings, not nouns. The lexicon defines the boundaries.
Anti-Corruption Vocabulary
Protect your language from external systems. Translate, don't import.
Language Gateway
External clients speak their own language. The gateway translates to yours.
Semantic Composition
Compose services into new meanings. The new meaning has its own language.
Context First APIs
Design APIs around client contexts, not database tables. One context, one endpoint.
Linguistic Contracts
Contracts are about meaning, not just syntax. Define what fields mean.
Meaning-Preserving Integration
Preserve meaning across integration boundaries. Events carry the story.
Refactoring Patterns
Clean up existing code. Renaming, extraction, cleanup, consolidation, decoupling, context recovery.
Design by Renaming
Renaming is not cosmetic. It is architecture. Change the name, change the design.
Concept Extraction
Find hidden concepts buried in code. Pull them out. Give them a home.
Semantic Cleanup
Remove dead concepts. Merge overlapping ones. Simplify the language.
Vocabulary Consolidation
Multiple words for the same concept? Pick one. Retire the rest.
Semantic Decoupling
Break shared names that create false dependencies. Different meanings, different names.
Context Recovery
Lost context makes words meaningless. Recover it. Make it explicit.
The Core Four
These four patterns appear in every composition. Learn them first.
Meaning Split
cleans the words
Semantic Boundary
draws the lines
Design by Renaming
keeps them honest
Narrative Modeling
connects them into a story
Pattern Relationship Map
Language Cluster
- Ubiquitous Lexicon
- Explicit Context
- Meaning Split
- Concept Merge
- Concept Canonicalization
- Linguistic Ownership
- Language Closure
- Semantic Boundary
- Lexicon is the foundation
- Explicit Context gives words meaning
- Split and Merge are opposites. Use both.
- Canonicalization creates a single source of truth
- Ownership assigns responsibility
- Closure keeps the vocabulary small
- Semantic Boundary draws the lines
Modeling Cluster
- State/Status Segregation
- Sequencer
- Conceptual Aggregate
- Semantic Event
- Intent Before Structure
- Narrative Modeling
- Policy as Language
- Vocabulary Objects
- State/Status Segregation separates two kinds of change
- Sequencer models explicit transitions
- Conceptual Aggregate draws boundaries by meaning
- Semantic Event carries meaning in its name
- Intent Before Structure starts with why
- Narrative Modeling tells the story
- Policy as Language makes rules executable
- Vocabulary Objects give meaning to primitives
Architectural Cluster
- Lexicon-Oriented Services
- Anti-Corruption Vocabulary
- Language Gateway
- Context First APIs
- Linguistic Contracts
- Meaning-Preserving Integration
- Lexicon-Oriented Services follow the lexicon
- Anti-Corruption Vocabulary protects from external systems
- Language Gateway translates for external clients
- Context First APIs are designed around client contexts
- Linguistic Contracts capture meaning, not just syntax
- Meaning-Preserving Integration preserves meaning across boundaries
Refactoring Cluster
- Design by Renaming
- Concept Extraction
- Semantic Cleanup
- Vocabulary Consolidation
- Semantic Decoupling
- Context Recovery
- Design by Renaming is the entry point
- Concept Extraction pulls out hidden concepts
- Semantic Cleanup removes dead concepts
- Vocabulary Consolidation merges synonyms
- Semantic Decoupling breaks shared names
- Context Recovery restores lost meaning
Cross-Cluster Connections
The Complete Web
At the center of all patterns is the Ubiquitous Lexicon. Every pattern feeds the lexicon. Every pattern reads from the lexicon.
The lexicon is the hub. The patterns are the spokes.
How to Use This Map
- New to LDD? Start at the Core Four. Then explore outward.
- Have a specific problem? Find the pattern. Follow its connections.
- Designing a system? Start at the lexicon. Move through modeling to architecture.
- Fixing an existing system? Start at refactoring. Move outward to language.
- Scaling an organization? Focus on ownership, closure, governance.
The map is not a prescription. It is a guide. Follow it when you are lost. Ignore it when you are not.