Tight Core, Open Edge
Appendix C

Sources & Further Reading

Every idea here was drawn from someone; the text and code are original, but the thinking is not. This is where to go next, organized by the thread each work feeds.

The book has two intellectual parents and a handful of close relatives. What follows is annotated rather than alphabetical, so each entry tells you why it is here and which part of the book it stands behind.

C.1 The Two Poles

These two books are the poles the whole argument runs between. If you read only two things after this one, read these — one for each discipline.

  • Scott Wlaschin, Domain Modeling Made Functional (2018). The constraint stream, Parts II–III: types that make illegal states unrepresentable, workflows as pipelines of transformations, and the "parse, don't validate" instinct applied to whole domains. Wlaschin's F# is a natural companion to this book's Nex.
  • Chris Hanson & Gerald Jay Sussman, Software Design for Flexibility (2021). The flexibility stream, Parts IV–V: generic operations, extensible evaluators, propagators, and unification. The source for nearly every technique past Chapter 8, and the deeper well to draw from when you want more.

C.2 Foundational

The two works the book's method rests on, one for the contract thesis and one for the flexibility tradition's origins.

  • Bertrand Meyer, Object-Oriented Software Construction, 2nd ed. (1997). The origin of Design by Contract; require, ensure, invariant, and variant descend directly from Meyer's Eiffel. The membrane idea — a contract as the interface between components that do not see inside one another — is his, extended here to the seam between a closed core and an open edge.
  • Harold Abelson & Gerald Jay Sussman, with Julie Sussman, Structure and Interpretation of Computer Programs, 2nd ed. (1996). The ancestor of the flexibility stream: data-directed programming, the metacircular evaluator, and streams. Chapters 9–11 are direct descendants; read it for the roots of generic dispatch and extensible interpreters.

C.3 On Complexity (Part I)

  • John Ousterhout, A Philosophy of Software Design (2018). Complexity as the enemy, deep modules, and information hiding — a modern vocabulary for the "two costs" framing of Chapter 1.
  • Ben Moseley & Peter Marks, Out of the Tar Pit (2006). Essential versus accidental complexity, and state as the root cost. Reads almost as a second statement of this book's opening argument in a different key.

C.4 Partial-Information Computation (Part V)

  • Alexey Radul & Gerald Jay Sussman, The Art of the Propagator (MIT CSAIL, 2009), and Alexey Radul, Propagation Networks: A Flexible and Expressive Substrate for Computation (PhD thesis, MIT, 2009). The primary sources for Chapter 12 — cells of partial information, monotone merge, and truth maintenance for retraction.
  • Daniel P. Friedman, William E. Byrd & Oleg Kiselyov, The Reasoned Schemer, 2nd ed. (2018). The gentlest route into unification and search (Chapter 13), via miniKanren; far friendlier than diving straight into Prolog theory.

C.5 Chapter-Specific

  • Alexis King, Parse, Don't Validate (2019). The essay Chapter 4 is named for; the clearest short statement of the parse-versus-validate distinction.
  • Gary Bernhardt, Boundaries (talk, 2012). "Functional core, imperative shell" — the shape of Chapter 6.
  • Eric Evans, Domain-Driven Design (2003). Ubiquitous language and bounded contexts, standing behind the workflow modelling of Chapter 5 and the domain languages of Chapter 10.
  • Yaron Minsky, Effective ML / "make illegal states unrepresentable" (2011). The origin of Chapter 3's title phrase, from the OCaml tradition.