Accidental complexity
Accidental complexity is difficulty arising from implementation choices or technical constraints rather than from the essential requirements of the problem being solved.
Functional Design and Architecture: Examples in Haskell
Accidental complexity is complexity introduced by implementation choices, tools, or code rather than inherent requirements of the problem domain.
- How it is used
- Guides software design toward solutions that control implementation-driven complexity without sacrificing maintainability or useful abstraction.
- How deep it goes
- Defines the distinction, explains abstraction trade-offs, and stops short of prescribing a universally best solution.
- Examples
- Uses competing solution weights, a spaceship API, a unit-mismatch failure, and domain-specific language design as concrete illustrations.
- What you can do after
- Evaluate design choices and reduce unnecessary complexity using abstractions, interfaces, modularity, coupling, cohesion, and types.
Read how Functional Design and Architecture: Examples in Haskell explains accidental complexity →
Clean Applications with Hexagonal Architecture
The additional difficulty and disorder introduced by design choices, implementation shortcuts, and unnecessary coupling rather than by the problem domain itself.
- How it is used
- Frames accidental complexity as maintainability decay caused by design choices and uses Hexagonal Architecture to contain its ripple effects.
- How deep it goes
- Defines the problem, traces coupling to concrete maintenance failures, and connects explicit boundaries to isolation.
- Examples
- Uses changes that touch many files, mysterious test failures, database leakage into business logic, and transport models used as domain models.
- What you can do after
- Apply Ports and Adapters to isolate business logic and make external technology replaceable at system boundaries.
Read how Clean Applications with Hexagonal Architecture explains accidental complexity →
Also covered in
- The Art of Code
- Software Architecture Decision-MakingIn early access (MEAP)
- Collaborative Software Design: How to facilitate domain modeling decisions
What to know first
- domain-driven designDomain-driven design is a software design approach that centers models, structure, and terminology on the concepts, behavior, and boundaries of a problem domain.
Related concepts
- essential complexitycontrasts with · Essential complexity is the unavoidable difficulty inherent in a problem’s domain, rules, and required outcomes, which cannot be removed without sacrificing necessary behavior.
- complexitykind of · Complexity is the degree to which interacting elements or factors make a system or problem difficult to understand, predict, change, operate, or solve.
- domain-specific languageproduced by · A domain-specific language is a language or notation tailored to expressing concepts, operations, or solutions within a particular problem or application domain.
- abstractionaddressed by · Abstraction is a simplified representation that preserves relevant properties or behavior while omitting details unnecessary at a given level or for a given purpose.
- refactoringaddressed by · Refactoring is the disciplined restructuring of existing software to improve its internal qualities while preserving its externally observable behavior.
Questions about accidental complexity
What is accidental complexity?
Accidental complexity is difficulty arising from implementation choices or technical constraints rather than from the essential requirements of the problem being solved.
Which Manning books explain accidental complexity?
Functional Design and Architecture: Examples in Haskell and Clean Applications with Hexagonal Architecture.
What should I know before learning accidental complexity?
Manning books that teach accidental complexity usually introduce domain-driven design first.
What is the difference between accidental complexity and essential complexity?
Accidental complexity is difficulty arising from implementation choices or technical constraints rather than from the essential requirements of the problem being solved. Essential complexity is the unavoidable difficulty inherent in a problem’s domain, rules, and required outcomes, which cannot be removed without sacrificing necessary behavior.
What is accidental complexity a kind of?
Accidental complexity is a kind of complexity. Complexity is the degree to which interacting elements or factors make a system or problem difficult to understand, predict, change, operate, or solve.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.

