Members' shelf
All 9 nodes on Naming & Classification are for members only.
Pay with the email you sign in with here, so the Pass is linked to this account.
Members' shelf
All 16 nodes on System Protection & Threat Modeling are for members only.
Pay with the email you sign in with here, so the Pass is linked to this account.
Domain-driven design (DDD)
- Holds when
- When experts and developers speak different vocabularies, and the conditions and exceptions in domain rules get lost in translation.
- Evidence
- Conceptual framework; Bibliography checked
- Breaks down when
- Adopting its terms without changing how people talk and divide the work, or using it where things were already simple: modelling effort spent, nothing clearer.
1. What happened
Whether to settle the architecture first, or first a vocabulary shared by domain experts and developers, is a trade-off to make as soon as work on a system begins. The position of Evans's 2003 book Domain-Driven Design is that the real difficulty in software lies in the business domain rather than in frameworks and databases[1]Evans, E. (2003). Domain-Driven Design: Tackling Complexity in the Heart of Software. Addison-Wesley. ISBN-13 978-0-321-12521-7. Bibliographic details checked against the publisher's record. 560 pages, published August 2003. The book systematises shared language, bounded contexts, the building blocks of model-driven design, and strategic design (context maps, distillation, the core domain). Passages in the book were not checked word for word here.. And the first bottleneck to getting knowledge into a system without loss is not technical. It is translation.
The typical failure looks like this. The domain expert speaks one set of terms, the developer translates them mentally into a second set, and then writes them down as a third (the variable and class names in the code). Every translation drops a little, and what it usually drops are conditions and exceptions. The expert says this kind of customer normally does not prepay, unless there was a dispute on the last order, and what reaches the code is one boolean field.
The book's first requirement is therefore a shared language: one vocabulary used by domain experts and developers alike, with no translation layer between them, and those terms become the names in the model and in the code. That sounds like advice about communication. It is actually a design constraint: if a concept has no name in the vocabulary, it should not have an implementation quietly growing for it in the code.
The second requirement comes from scale. A large system cannot sustain one unified model: the same word already means different things in sales and in logistics, and forcing them together only turns the model into a compromise nobody is happy with. The book's handling is to cut into several bounded contexts: meaning stays consistent inside each, what crosses between them is managed explicitly through a map, and where necessary a layer of anti-corruption translation sits at the join so the shape of an external model does not seep in[1]Evans, E. (2003). Domain-Driven Design: Tackling Complexity in the Heart of Software. Addison-Wesley. ISBN-13 978-0-321-12521-7. Bibliographic details checked against the publisher's record. 560 pages, published August 2003. The book systematises shared language, bounded contexts, the building blocks of model-driven design, and strategic design (context maps, distillation, the core domain). Passages in the book were not checked word for word here..
The third requirement is about allocating resources: design effort is finite, so put it first into the core domain, the part that actually produces the difference, and buy the peripheral and generic parts off the shelf wherever you can.
2. Why this matters to you
The most direct use of this page is that it explains why your collaboration with a model so often comes apart on a single word.
You hold a vocabulary of your own: what a certain file is called, what a certain stage is called, what a certain criterion is called. When you hand work over, you use your terms and the model uses the general sense it learned from the whole internet. Eight tenths of that overlaps. The remaining two tenths is where the misunderstanding comes from, and the misunderstanding does not show up as the model failing to answer; it shows up as a very fluent answer to a different question.
The shared-language move transfers directly. Fix your vocabulary, one name per concept, and carry those definitions in the context you give the model. That costs less than correcting it repeatedly, because you are repairing the input rather than the output.
The bounded-context layer is more interesting, because it licenses inconsistency in return. You do not have to make the word project mean the same thing everywhere. You only have to be consistent inside each context, and to convert explicitly when something crosses. That is unusually useful for one person running several lines at once: delivery on the client line and delivery on your own line were never the same thing, and forcing them together costs more than keeping them apart.
In practice this page offers three moves. First, write your vocabulary down, one name per concept, with synonyms marked as synonyms. Second, when you find one word meaning different things on two lines, do not unify, draw a context. Third, put design effort first into the part that genuinely differentiates you; if you cannot say how some part differs from the usual way of doing it, handle it the usual way and do not build a vocabulary and contexts for it.
Lab cases Written only where there is evidence
No field record for this node yet.
- A common account says domain-driven design is that set of naming conventions (entities, value objects, aggregates, repositories). That is the tactical layer. According to a report of a 2009 talk, the author said this set of building blocks is over-emphasised, and that bounded contexts and the core domain deserve more weight. Adopting the naming without doing the language and the contexts degrades into ordinary create-read-update-delete with fancier names. Nor can the set of building blocks be credited as a whole to Evans's 2003 book Domain-Driven Design: the Repository pattern, for one, was already included in the book on enterprise application architecture patterns published the year before, where the entry is credited to two other authors, Hieatt and Mee. #
- A common account says one bounded context is one microservice. The two are orthogonal: one service can hold several contexts, and the reverse. Binding context boundaries hard to deployment boundaries cuts in the wrong places. #
How to read the source notes “Bibliographic details checked” means author, year, title and venue were confirmed. It does not mean the source's claims were checked. Definitions as of 2026-09-20.
- [1] Evans, E. (2003). Domain-Driven Design: Tackling Complexity in the Heart of Software. Boston: Addison-Wesley Professional. ISBN-13 978-0-321-12521-7. 560 pp. ↩
Tell me when a new shelf opens
Tell me when a new shelf opens
Shelf notices are sent only when a new shelf opens or when the reading rules change.
Tell the editor privately: a correction, a counter-example or where it applies
Submissions are read only by the editor, and nothing is published before they are handled. Once a note is handled, a summary and response written by the editor are published. No sign-up is needed, and the nickname may be left blank.
We have your note