liveBook · Manning

Accidental complexity

Accidental complexity is difficulty arising from implementation choices or technical constraints rather than from the essential requirements of the problem being solved.

How 2 Manning books explain it

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

What to know first

Related concepts

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.