Skip to content

Software Evolution & Entropy

Abstractions about why software degrades under change — Lehman's laws of increasing complexity and declining quality, anti-patterns like the inner-platform effect and Greenspun's tenth rule, and design maxims like the robustness principle, all treating entropy as the default trajectory of an unmaintained system.

7 abstractions in this family — domain-specific abstractions that sit near one another in structural-signature space (k-means over structural-signature embeddings). Each is shown with its short description.

  • Greenspun's Tenth Rule — The aphorism that any sufficiently complicated C or Fortran program contains an ad hoc, bug-ridden implementation of half of Common Lisp — because features a language withholds do not vanish but migrate inside the program as defective re-implementations.
  • Inner-Platform Effect — A system built on top of another tends to re-implement the host's facilities inside itself, badly, because the embedded sub-system's customisation surface is narrower than the host's while the requirements arriving at it are not bounded by that narrowness.
  • Lehman's law of continuing change — The empirical software-evolution law that an E-type system — one embedded in a moving real-world environment — must be continually adapted or it progressively becomes less satisfactory, because its fitness is relational (the gap between what the code does and what the world now requires) and that gap widens monotonically while the code stands still.
  • Lehman's law of declining quality — Read software quality as the system's fit to its present environment rather than its intrinsic defect count, so an unchanged, bug-free release still degrades in the field as the surrounding world drifts away from the conditions it was built for.
  • Lehman's law of increasing complexity — Observe that the structural, behavioral, and conceptual complexity of an evolving software system rises monotonically under unmanaged change — an entropy-positive default that only deliberate, non-feature restructuring can bend back down.
  • Robustness Principle
  • Software Entropy — Read a codebase's growing structural disorder as a predictable gradient under continuous modification: locally expedient edits flow toward the vast basin of working-but-disordered states, and order decays monotonically unless restoring engineering effort is continuously reinjected.