liveBook · Manning

Abstraction

As explained in Software Architecture Decision-Making

An abstraction is a deliberately simplified interface or representation that hides implementation details and permits variation behind a stable boundary.

Abstraction creates a stable boundary while hiding implementation detail, but it also adds complexity. Its value depends on evidence, consequence, and reversibility rather than imagined future variation. section 3.1

Judge an abstraction against the realities of delivery and operation:

  • Add it when real variation exists, changing the boundary later would be expensive, or delaying it would make evolution harder. section 3.1
  • Defer it when complexity addresses only hypothetical scenarios; preserve a seam or decision record instead of building the full capability. section 3.1
  • Prefer patterns the team can operate, debug, and evolve without external heroes. section 3.1

A narrow workflow becomes an architecture exercise

A three-month internal workflow project needs one workflow, one department, and a few known integrations. Splitting it into services, adding messaging, and designing for speculative scale turns abstraction into perfection drift. A simpler boundary is justified until concrete variation or costly reversal provides stronger evidence. section 3.1

Table 3.2 Responding to perfection drift
Signal
Diagnostic question
Better response
Over-engineering early
What current problem does this complexity solve?
Remove or defer the part that solves only a hypothetical problem. Keep only the structure needed for the known problem.
Designing for hypothetical future scenarios
What evidence suggests this future is likely soon?
Preserve a seam or decision record but avoid building the full future capability until the signal becomes real.
Building abstractions “just in case”
How many real variations exist today?
Wait until there are at least two or three concrete cases, unless reversal would be very expensive later.
Introducing patterns the team cannot maintain
Can the team operate, debug, and evolve this pattern without external heroes?
Choose a simpler pattern now and define the conditions that would justify moving to the more advanced one later.
Treating architecture as a personal project
Who else needs to understand, support, and change this design?
Bring the team into the decision and make ownership, trade-offs, and support expectations explicit.
Optimizing for an ideal end state instead of current value
What value is delayed by pursuing the ideal version now?
Deliver a focused slice first, then strengthen the architecture as real feedback appears.

Use the diagnostic table to distinguish over-engineering, hypothetical design, premature abstraction, and patterns beyond team capability. section 3.1

How Software Architecture Decision-Making covers it

How deep it goes
Explains trade-offs, diagnostic questions, and deferral strategies but stops short of implementation mechanics.
Examples
Uses an internal workflow system, speculative services, messaging, future scale, and a perfection-drift diagnostic table.
What it assumes
Assumes architectural judgment about requirements, operations, team capability, and future change.
What you can do after
Evaluate abstraction choices using evidence, reversal cost, concrete variation, and the team's ability to operate them.
How it connects
Connects abstraction with architecture, complexity, requirements, reversibility, scalability, and team capability.

Also explained in

Compare how 24 books explain abstraction →

Related concepts

This explainer was generated by Manning's knowledge graph from the text of Software Architecture Decision-Making. The section links point to the parts of the book it draws on.