# Glossary
> Short, plain definitions. Follow the links for the full notes.

### accidental complexity
Complexity caused by design choices that no longer fit, as opposed to complexity inherent in the business. Remove it. See [Chapter 11](/ch11#growth).

### active record
An object that holds a data structure and knows how to load and save itself. It suits simple logic over complex data. See [Chapter 5](/ch5#active-record).

### aggregate
A cluster of entities and value objects that guards its own consistency. It is changed only through its root's commands and saved as one transaction. See [Chapter 6](/ch6#aggregate).

### aggregate root
The single entry-point entity of an aggregate. Inner objects are changed only through it. See [Chapter 6](/ch6#aggregate).

### anticorruption layer
A translation layer that a downstream context builds so that an upstream model doesn't leak into
its own. See [Chapter 4](/ch4#anticorruption-layer-acl).

### big ball of mud
A codebase that grew without structure after many quick fixes and unexamined design decisions. See [Chapter 11](/ch11#growth).

### bounded context
An explicit boundary inside which one model and its language stay consistent. It is designed, not
discovered, and it also marks a deployable unit and a single team's ownership. See [Chapter 3](/ch3#bounded-contexts).

### business domain
A company's main area of activity: what customers pay it for. See [Chapter 1](/ch1#business-domains-and-subdomains).

### command
A request to change state, run by an aggregate after it checks the rules. See [Chapter 6](/ch6#aggregate).

### conformist
An integration where the downstream side adopts the upstream model as it is. See [Chapter 4](/ch4#conformist).

### context map
A diagram of all bounded contexts and the integration patterns between them. See [Chapter 4](/ch4#context-map).

### core subdomain
Where the company competes: complex, frequently changing work that sets it apart. Build it
in-house. See [Chapter 1](/ch1#core-subdomains).

### CQRS
Command-Query Responsibility Segregation: one strongly consistent model for changes, plus any number of rebuildable read models. See [Chapter 8](/ch8#cqrs).

### domain event
A past-tense message describing something significant that happened in the business. See [Chapter 6](/ch6#domain-events).

### domain expert
A person who knows how the business really works and is the source of the knowledge being modeled.
See [Chapter 1](/ch1#domain-experts).

### domain model
An object model that puts data and behavior together to handle complex business logic. See [Chapter 6](/ch6#domain-model).

### domain service
A stateless object for business logic that belongs to no single aggregate, often a calculation that reads several. See [Chapter 6](/ch6#domain-services).

### entity
An object identified by an ID rather than its values, whose state changes over time. See [Chapter 6](/ch6#entity).

### essential complexity
Complexity inherent in the business domain itself. Manage it with DDD tools rather than trying to remove it. See [Chapter 11](/ch11#growth).

### event sourcing
Storing every state change as an event and deriving state by replaying the events. See [Chapter 7](/ch7#event-sourcing).

### event store
An append-only database of events, with fetch-by-ID and append-with-expected-version. See [Chapter 7](/ch7#source-of-truth-and-event-store).

### EventStorming
A sticky-note workshop for mapping a business process as a timeline of domain events, then adding commands, policies, aggregates and contexts. See [Chapter 12](/ch12).

### generic subdomain
A complex but already-solved problem that every company handles the same way. Buy or adopt it.
See [Chapter 1](/ch1#generic-subdomains).

### heuristic
A rule of thumb that is good enough to decide quickly without being guaranteed correct. See [Chapter 10](/ch10#what-a-heuristic-is).

### idempotent
Giving the same result however many times it is repeated. See [Chapter 5](/ch5#where-it-goes-wrong).

### layered architecture
Presentation, business logic and data access layers, each depending only on the layer below. See [Chapter 8](/ch8#layered-architecture).

### migration event
A single explicit event that starts an event stream for data migrated from a state-based system. See [Chapter 11](/ch11#domain-model--event-sourced-domain-model).

### model
A purposeful simplification that keeps only what a specific problem needs. See [Chapter 2](/ch2#models).

### open-host service
An integration where the upstream side exposes a consumer-friendly published language, separate
from its internal model. See [Chapter 4](/ch4#open-host-service-ohs).

### optimistic concurrency
Saving a change only if the data hasn't changed since it was read, usually checked with a version number. See [Chapter 6](/ch6#aggregate).

### outbox
Saving new events in the same transaction as the state change, then having a relay publish them. Delivery is at least once. See [Chapter 9](/ch9#outbox).

### partnership
An integration where two teams coordinate changes in both directions as they come up. See [Chapter 4](/ch4#partnership).

### pivotal event
An EventStorming event that marks a change of phase in a process. It often hints at a bounded-context boundary. See [Chapter 12](/ch12#the-ten-steps).

### policy (EventStorming)
An automation rule saying 'when this event happens, run that command'. See [Chapter 12](/ch12#the-ten-steps).

### ports & adapters
An architecture where the core defines interfaces (ports) and infrastructure implements them (adapters). Also called hexagonal, onion or clean architecture. See [Chapter 8](/ch8#ports--adapters).

### process manager
An explicitly started, stateful coordinator whose business logic decides each next step of a multi-step process. See [Chapter 9](/ch9#process-manager).

### projection
A state or read model derived from events or from the command model. See [Chapter 7](/ch7#store-the-story) and [Chapter 8](/ch8#two-kinds-of-model).

### published language
The public, integration-focused model exposed by an open-host service. See [Chapter 4](/ch4#open-host-service-ohs).

### read model (EventStorming)
The information an actor looks at before issuing a command. See [Chapter 12](/ch12#the-ten-steps).

### saga
A process spanning several transactions that reacts to events with commands and compensates on failure. See [Chapter 9](/ch9#saga).

### separate ways
Choosing to duplicate a capability instead of integrating it. See [Chapter 4](/ch4#separate-ways).

### shared kernel
A small piece of model that several contexts share and change together. See [Chapter 4](/ch4#shared-kernel).

### snapshot
A cached projection that lets you replay only the newer events, as an optimization. See [Chapter 7](/ch7#faq).

### subdomain
A smaller area of business activity: core, generic or supporting. It is discovered, not designed.
See [Chapter 1](/ch1#types-of-subdomains).

### supporting subdomain
A simple, necessary activity with no competitive value. Build it cheaply or outsource it. See
[Chapter 1](/ch1#supporting-subdomains).

### testing diamond
A testing strategy weighted toward integration tests. It suits active record. See [Chapter 10](/ch10#picking-a-testing-strategy).

### testing pyramid
A testing strategy weighted toward unit tests. It suits domain models. See [Chapter 10](/ch10#picking-a-testing-strategy).

### transaction script
One procedure per system operation, each running as an all-or-nothing transaction. See [Chapter 5](/ch5#transaction-script).

### ubiquitous language
The shared business vocabulary used by everyone on the project, with one meaning per term inside a
bounded context. See [Chapter 2](/ch2#ubiquitous-language).

### value object
An immutable object defined entirely by its values, with no ID. See [Chapter 6](/ch6#value-objects).
