Reference
Glossary
The Architecture Reference teaches software architecture; here are short, plain-language definitions of the core terms and acronyms the pages use — each with a link to learn it in depth. If a page drops a term you don’t recognize, it’s probably here.
Foundations & Trade-offs
- Architecture characteristic →
- A non-domain capability (an “-ility”) the system must support that needs special structure and is critical to success.
- Trade-off (First Law) →
- “Everything in software architecture is a trade-off” — every choice buys one quality at the cost of another.
- Fitness function →
- Any objective, automatable check that protects an architecture characteristic as the system changes.
- Connascence →
- A precise vocabulary for how two components are coupled; refactor toward weaker, more local forms.
- Architecture quantum →
- An independently deployable artifact with high functional cohesion; the number of quanta decides monolith vs distributed.
- Architecture Decision Record (ADR) →
- A short record of a significant decision — context, decision, and consequences — emphasizing the why.
- Evolutionary architecture →
- Architecture that supports guided, incremental change across multiple dimensions.
Domain-Driven Design
- Domain-Driven Design (DDD) →
- Modeling software around the business domain and its shared language.
- Bounded context →
- The consistency boundary of a ubiquitous language; within it every term has exactly one meaning.
- Ubiquitous language →
- One shared, consistent business language used by everyone in conversation, docs, tests, and code.
- Aggregate →
- A consistency and transactional boundary, mutated only through its root and committed atomically.
- Context mapping →
- The patterns for integrating bounded contexts (ACL, open-host service, conformist, shared kernel, …).
- EventStorming →
- A collaborative workshop that models a business process as a timeline of domain events.
Distributed Systems
- CAP theorem →
- During a network partition a replicated system must choose between consistency and availability.
- Eventual consistency →
- Replicas converge to the same value once all updates propagate; reads may be briefly stale.
- Consensus (Raft / Paxos) →
- Getting failing nodes to agree on one value or order; use etcd/ZooKeeper, never hand-rolled.
- Sharding / partitioning →
- Splitting data across nodes by hash, range, or value to scale beyond a single machine.
- Fallacies of distributed computing →
- False assumptions — the network is reliable, latency is zero, … — that break across the network.
- Idempotency →
- Processing the same request twice has the same effect as once — the key to safe retries.
Events & Messaging
- Event-driven architecture →
- Decoupled processors react asynchronously to events, for scalability and fault tolerance.
- Event sourcing →
- Store every state change as an append-only event; derive current state by replaying them.
- CQRS →
- Command Query Responsibility Segregation — one write model and any number of read projections.
- Event-carried state transfer (ECST) →
- An event carries the entity’s whole public state, so consumers never need to call back.
- Outbox pattern →
- Write an event in the same transaction as the state change; a relay publishes it later.
- Data mesh →
- Treating data as a first-class product with domain ownership and federated governance.
Microservices & Delivery
- Microservices →
- Independently deployable services modeled around a business domain that own their own data.
- Monolith →
- A single deployable application containing all of a system’s features — a valid default.
- Saga →
- A cross-service process modeled as local transactions, each with a compensating undo.
- Strangler fig →
- Migrate a monolith incrementally by intercepting calls and redirecting them to new services.
- Circuit breaker →
- Fails fast after a failure threshold, then probes for recovery — stopping cascading failure.
- Progressive delivery →
- Separating deployment from release via blue-green, canary, and feature toggles.
APIs & Cloud
- REST →
- An architectural style for APIs built on resources, representations, and HTTP verbs.
- gRPC →
- A high-performance RPC framework using protobuf over HTTP/2, with generated typed clients.
- GraphQL →
- A query language letting clients request exactly the fields they need from one endpoint.
- Service mesh →
- Sidecar proxies plus a control plane that handle service-to-service networking concerns.
- Serverless →
- Run code without managing servers; pay per use with implicit scaling (e.g. AWS Lambda).
- Multitenancy →
- One system serving many tenants with isolation of their data and load.