proomt

Search

Search posts, papers, and topics

Hall of Fame

Hall of FameBen Moseley, Peter Marks200698 min readpaperintermediate

Out of the Tar Pit

Summary

The paper argues that most complexity in large software systems is accidental, caused mainly by mutable state and tangled control flow. It proposes minimizing accidental complexity by using pure functional programming together with a relational data model, emphasizing simplicity over extensive testing.

  • Mutable state is the primary source of accidental complexity; reducing state simplifies reasoning.
  • A combination of pure functional programming and the relational model can eliminate many accidental complexities.
  • Testing cannot guarantee correctness; simplicity and clear mental models are more valuable for large systems.
  • Distinguish essential vs accidental complexity and target the latter with language and data model choices.

Software architects and senior engineers building large systems should care because managing accidental complexity directly improves reliability and maintainability.

6/10

Related reading

  1. No Silver Bullet: Essence and Accidents of Software Engineering

    Brooks argues that software development’s fundamental difficulty lies in essential complexity—conceptual design, conformity, changeability, and invisibility—rather than accidental implementation issues. Consequently, no single technology or management trick will yield an order‑of‑magnitude productivity boost; progress must come from disciplined, incremental improvements.

    Hall of Fameunc.edu34 minpaper
  2. Simple Made Easy

    Rich Hickey argues that simplicity, not easiness, is the foundation of reliable software. He outlines how to choose simple constructs and design abstractions to keep systems understandable and changeable.

    Hall of Fameinfoq.com9 mintalk
  3. Why Functional Programming Matters

    Hughes argues that functional programming’s real power lies in higher‑order functions and lazy evaluation, which act as new kinds of "glue" for modular design. He illustrates this with foldr and examples ranging from list processing to alpha‑beta pruning, showing how these features simplify and reuse code.

    Hall of Famekent.ac.uk38 minpaper
  4. Things You Should Never Do, Part I

    Joel Spolsky argues that rewriting a mature codebase from scratch is usually a strategic mistake, because it throws away bug fixes and delays shipping. Incremental refactoring of architecture, performance, or style issues is far safer.

    Hall of Famejoelonsoftware.com6 min
  5. Presentation: Complexity and Creativity in Software Engineering

    Phillip Mortimer argues that AI‑generated code makes all software effectively "write‑only" due to volume, and proposes managing this by treating tests as the sole specification, automating code reviews with LLMs, and decoupling intent from implementation.

    InfoQinfoq.com28 mintalk