The Same
Machine

The previous page demonstrated a pipeline with stages. That was a simplification, and a misleading one, because it implies the stages are things. They are not. There is one relation — TABLE_SPECIFICATIONS, twenty columns, holding a source address, a target address and the function between them — and everything else in the estate is a projection from it.

Not generated by it in the sense of a code generator with templates on one side and output on the other. Projected from it: the DDL, the view, the load statement, the workflow XML, and the shell that invokes them are each a different walk over the same rows. Change a row and all nine change together, because there is nothing else for them to disagree with.

Step three is the one that matters and the one that is easy to miss. The specification table's own twenty columns are loaded into the specification table, sourced from ALL_TAB_COLUMNS — so the surface describes itself, and the same projection that builds a business view builds the view of the specification. That closure is not a trick. It is what makes the thing an engine rather than a script: there is no privileged layer holding the rules about the other layers, because the rules are addressed the same way everything else is.

The match rules are rows too. Step four adds a partner feed the page has never seen; before its rules exist, four of its addresses park as candidates rather than failing the load, and the cost of onboarding it is four rows in a rule table. No adapter, no transform, no pipeline. Then look at any of the nine projections again — the shell, the workflow XML, the DDL — and the new system is in all of them, from machinery that did not change.

The command tier is the part usually mistaken for scripting. A ksh wrapper, a .bat, an .ini, a WinTask macro and a CLI invocation are the same projection with different comment prefixes, because they address invocation rather than syntax: bind a context, carry a payload, fire. That is why one header block served all of them for two decades unchanged, down to the $Revision$ keywords left unbound for an archive layer that was never wired up.

The claim from the first build was that an estate's integration points are not designed but recovered: the systems already declare what they contain, and the catalogue is a set of relations you can query like any other. That was demonstrated against a simulated catalogue, which is fair enough as far as it goes.

Here it runs against a real one. SQLite compiled to WebAssembly — 686 KB, shipped in this package rather than fetched from anywhere — four tables created, then the loop: read sqlite_master and pragma table_info, generate DDL from what they report, execute it, and read the catalogue again to find the result. Nobody writes the DDL, and nobody writes down the schema for it to be written from.

The template is three placeholders and one line. Change it and every generated statement changes with it, which is the whole of the argument in block 8 of the first build: the artefact is exhaust, the rule is the asset.

What the modern engine adds is real and worth naming precisely. It runs in a browser tab, needs no server, and travels in the same folder as the page. What it does not add is the idea. Codd made the catalogue queryable in 1970 (CACM 13(6)); sqlite_master is that, and information_schema in every other engine is that. The loop above would have run on Oracle 7.

Scaled dot-product attention scores a query against every key, softmaxes the scores into weights, and returns the weighted sum of the values. Written down that way it is a soft read from a key–value store: the address is a similarity rather than an index, and the return is a blend rather than a row.

Drag the temperature down and watch the blend collapse. At low temperature one weight goes to 1 and the rest to 0, the sum returns a single value, and the mechanism has become an ordinary lookup. Nothing has been switched off — that is the same equation at a different setting.

The lineage is worth stating carefully, because it is easy to overreach here. Vaswani et al. (2017) did not restate an old idea — the architecture, the multi-head arrangement and the demonstration that attention alone suffices are genuine contributions. What is old is the primitive: retrieval by content rather than by address. Kanerva formalised that as sparse distributed memory in 1988, and a hash table is the hard-edged version that has been in every language since the 1950s.

One detail the instrument makes visible and most explanations skip: the raw dot product conflates aligned with large. A key twice as long scores twice as high in the same direction. That is why the mechanism is scaled, and why normalisation is not cosmetic.

An elementary cellular automaton is the smallest interesting rule there is: eight neighbourhood cases, one output bit each, 256 rules in total. Rule 110 is Turing-complete — conjectured by Wolfram in 1985, proved by Matthew Cook and published in Complex Systems 15 (2004).

Below, the same rule is computed twice: once on the CPU one cell at a time, and once as a WGSL compute shader running sixty-four lanes per workgroup. The outputs are compared bit for bit.

If the outputs match — and they do — then the rule is indifferent to what runs it, which is substrate independence: Church and Turing, both 1936. The shader is faster and that is genuinely useful, but speed is the only thing it changed. This is the cheapest possible demonstration of the most expensive result on the page.

Chess is the case where recovery fails and learning is correct: the rules are entirely open, and yet no catalogue anywhere stores the best move, because the answer is not stored — it is searched for. Shannon put the tree at order 10¹²⁰ in 1950 and von Neumann defined optimal play against an adversary in 1928.

The engine here is byte-for-byte the one from the first build, whose move generator was checked against published perft counts. It now runs in a module worker. Press either button and keep scrolling: the page does not stall, because the search is not on this thread.

Perft is the honest check: count every legal position to a given depth and compare against numbers other people published. 20, 400, 8,902 and 197,281 — the last exercises castling, en passant and promotion, so matching it means the generator is right and the tree being walked is the real one.

A worker changed where the search happens. It did not make the tree smaller, and nothing about isolation touches the 10¹²⁰.

Fork a document, edit both copies independently, and merge them in either order. Conflict-free replicated data types guarantee both merges give the same result — not by choosing a winner, but because merge is a lattice join: commutative, associative and idempotent. Order of arrival stops mattering, so no coordinator is needed.

Shapiro, Preguiça, Baquero and Zawirski named and classified these in 2011, and the engineering that followed — collaborative editors that work offline and reconcile later — is a real achievement. The algebra underneath is Birkhoff's lattice theory, published in 1940. What 2011 supplied was the recognition that a join-semilattice is exactly the structure a replicated system needs, which is recognition of a normal form rather than invention of one.

It is also the second of this page's two spaces, appearing where you would least expect it. A lattice, in the algebraic sense, is what makes the merge safe.

Hash every block, hash the hashes in pairs, keep going until one root remains. Change nine characters anywhere and the root changes. More usefully, you can prove a single block belongs to the tree by handing over a handful of sibling hashes rather than the whole document — the proof below costs four hashes instead of ten.

Ralph Merkle published this in 1979 and patented it in 1982; the patent expired in 2002. Git's object store (2005) and IPFS's content identifiers (2014) are the same construction with different packaging, and the CID shown above is generated in the shape IPFS uses. The SHA-256 comes from the browser's own crypto, with no library involved.

The first build's ledger chained each block's hash to its predecessor's, which proves order. A Merkle tree proves membership without disclosing the rest, which is the stronger property and the reason the construction outlived its patent by a wide margin.

A schema states what shape a document must have and what happens when it does not. JSON Schema states it in JSON; the first build's schema states it in XML; a DTD stated it in 1986; and Backus (1959) and Naur (1960) stated the general form as BNF, which is why the notation for programming-language grammars still bears their names.

The failure behaviour is the part worth arguing about. Below, a violating instance is quarantined — kept, marked, and excluded from clean output — rather than dropped, because a region that silently vanished cannot be argued about later.

Five constraints do nearly all the work in any schema language anyone has shipped: this key is required, that one is not permitted, this value must come from a set, this list has bounds, and nothing outside the allow-list may appear. Compare the two panes above and the correspondence is exact, which is the point — a validator is a parser for a grammar written as data, and that has been true since 1959.

It would be cheap, and wrong, to conclude from all this that nothing has improved. A great deal has, and none of it is the form.

The distinction matters commercially rather than only intellectually. If a capability is a competent restatement of a settled result, the question to evaluate is implementation quality, and the pricing should follow that question rather than a novelty claim. Restating a settled form in a new substrate is cheap, and it inherits the guarantees — which is a reason for confidence in delivery, not a criticism of the work.

Each row is a form; each entry is the instrument above that instantiates it, and the result it restates. The column added here is current web platform, and it fills without opening a row of its own — which is the same finding the agentic column produced, arrived at from a different direction.

Three rows in the last column read none. Those are the cases where the modern instance is a straight restatement with no property the original lacked, and marking them honestly is what gives the other six their weight.

A service worker caches this page and its modules on first visit, so it runs with the network off and can be installed to a home screen. Combined with the Merkle root in block 7, the artefact carries its own integrity check: a reader can verify the contents without asking anyone, including whoever served it.

That is the one property in the whole build that has no antecedent worth naming — not because the idea is new, but because until recently there was nowhere to put it. An argument that can be checked offline, by its reader, with no account and no authority to appeal to, is a different kind of object from a document about the same subject.

The capsule sidecars are JSON here rather than XML: capsule/spine.json, capsule/ledger.json, capsule/schema.json. Which is block 8's point applied to this build's own packaging — the notation changed, and the constraints did not.