Chapter 13. Pre-Web Paradigms
Technology changes quickly; people’s minds change slowly. […] The next generation of programmers grows up only being shown one way of thinking about programming. […] They grow up with dogma. And once you grow up with dogma, it’s really hard to break out of it.
— Bret Victor, The Future of Programming, 2013
Four columns of failures have accumulated: two bracket stacks (Chapter 10), the single-page application (Chapter 11), and the applet (Chapter 12). The pattern repeats. The scores cannot say where architectures that fail this way keep coming from. The answer is that they do not come from the web. Relational databases, object orientation, object-relational mappers (ORMs), imperative languages, and MVC (model–view–controller) all predate the web. Each fails the derived requirements at one identifiable seam, and that is why each of them has a compensating industry at the web boundary. The industries are the evidence that the gaps are real: nobody builds a bridge across a gap that isn’t there. And the claim is falsifiable: it would be refuted by a paradigm that fails no derived requirement but has a compensating industry.
Relational
The relational model is the strongest of the pre-web paradigms and the most instructive. Inside one database it scores where nothing else pre-web does. Relational algebra is denotational, which means it had S2-grade semantics decades before the web. Its separation of query from storage is genuine S1 discipline. The failure is R3, and it is total: keys are database-scoped, so a reference is only meaningful to clients holding the same connection string, and two databases share no name for anything if their owners never coordinated. R2 fails as a consequence, because composition now requires a schema authority. The compensating industry is data integration: each pair of silos is bridged by hand, and every new pair needs a new bridge.
The relational world even rediscovered the triple shape (5.3) from the inside. Entity–attribute–value (EAV) is a schema of one three-column table. It appears wherever attributes cannot be fixed in advance (clinical records are the classic case). The practitioner literature files it under anti-pattern: the schema no longer names the attributes, and every query becomes self-joins. The audit agrees with both parties. EAV is the triple shape with both I positions stripped of global scope: entities are row keys, attributes are strings, both meaningful only inside one database. R3 still fails, so no second party can merge or join. The shape’s benefits are coordination-free merge and cross-party reference, and a single database has no other parties, so EAV carries the shape’s costs and none of its benefits. That is why the anti-pattern verdict is correct inside the silo.
Object orientation
Encapsulation is the deliberate fusion of state and behavior. That is R1 half-inverted: state exists, but in order to be hidden. Objects are designed neither to merge nor to be referenced from outside their runtime; identity is a pointer. The compensating industries are serialization frameworks and data-transfer-object (DTO) layers: machinery that re-extracts the hidden state every time it must leave the runtime.
ORM
An ORM is a type error between two wrong models: object graphs mapped onto relations, machine-local identity onto database-scoped keys. Each side fails a different requirement (R1 on the object side, R3 on the relational), and an ORM fails both at once. The size of the object-relational impedance-mismatch literature measures the scale of that failure.
Imperative languages
S2 is unreachable in principle here: an imperative program’s meaning is the trace of its execution. Chapter 11 made that argument about the fused term; here it applies to the language itself. The compensating industry is testing: unit, integration, and end-to-end suites. When meaning is execution, every claim about meaning must be executed before it can be checked, so semantics is recovered empirically per program, never once for the language.
MVC
MVC assembles the paradigms above. Its Model has neither R2 nor R3, its Views lack S2, and its Controllers fuse what S1 separates. Take it apart and each part has a derived generic replacement. The model gives way to the shape of a fact (5.3), the view to ⟦t⟧ and ⟦s⟧, and the controller to read and write themselves, which HTTP had already provided.
| Paradigm | Fails | The compensating industry |
|---|---|---|
| Relational | R3 (keys are database-scoped) | integration: hand-built bridges between silos |
| OOP | R1 half-inverted (state present but hidden) | serialization frameworks, DTO layers |
| ORM | a type error between two wrong models | the impedance-mismatch literature |
| Imperative | S2 unreachable in principle | test suites doing the work semantics should |
| MVC | all of the above, assembled | all of the above, assembled |
These are not outdated because they are old. HTTP is old. They are pre-web in the technical sense: their reference, composition, and semantics mechanisms are machine-local, and the web is definitionally the machine-spanning case. The 1960s–70s stack answers “how do I compute inside one machine”. The web asks “how do independent parties share state with no coordinator”. Theorem 5.4 shows that the second question forces one model, and none of these paradigms matches it.
Two columns cover the five paradigms. OOP and its ORM share one column. The audit of imperative languages comes down to a single cell, S2, which is unreachable in principle. A column for MVC would repeat the others.
| Relational | OOP/ORM | |
|---|---|---|
| R1 | ✓ — any domain, one schema at a time | ~ — state present but hidden |
| R2 | ✗ — no shared names, so composition needs a schema authority | ✗ — objects do not merge |
| R3 | ✗ — keys are database-scoped | ✗ — identity is a pointer |
| S1 | ✓ — query separated from storage | ✗ — encapsulation fuses state and behavior |
| S2 | ✓ — relational algebra is denotational | ✗ |
| S3 | ~ — within one vendor’s dialect | ~ — behind interfaces, within one runtime |
| S4 | ✗ — no value addressable from outside | ✗ |
The relational column is worth reading twice: it holds the highest pre-web score in the book, and it fails on exactly the machine-spanning properties. The diagnosis follows from the scores. The relational model is a correct answer to the single-machine question, applied to the machine-spanning question instead. The scores are final, but the compensating work goes on: the bridges, the serializers, the test suites. What the industry changed after a decade of that work is the next chapter.