sequenceDiagram
participant A as Instance A (client half)
participant B as Instance B (server half)
Note over A,B: point the implementation at itself — two origins, meeting as strangers
A->>B: GET u — follow a foreign name (R3)
B-->>A: read(u, S) — a document (S4)
A->>B: ⟦q⟧ to endpoint e — a window over B's state
B-->>A: Data — the solution
A->>B: PATCH (D⁻, D⁺) — the delta as a graph-scoped SPARQL Update
B-->>A: S′(u) = (S(u) ∖ D⁻) ∪ D⁺ (Prop. 7.1)
Note over A,B: every capability crosses the wire — no in-process shortcut
Chapter 18. No New Standard
Chapter 17’s build log ran on deployed standards end to end, and this chapter shows that nothing more is needed. Three questions remain: how names relate to addresses, how the seams no Recommendation covers get filled, and what shape federation forces on a reference implementation. Each resolves by composing pieces that already ship. No new standard is proposed; the chapter closes with the existence proof, an implementation that runs the assembly.
Names and addresses
The first question arrives with the first GET. It is the web’s oldest identity crisis, filed at the TAG (the W3C Technical Architecture Group) as httpRange-14: what does dereferencing the name of a thing return, when the thing is a turbine rather than a page? A decade of W3C argument produced a 303-or-fragment resolution, a note (Cool URIs for the Semantic Web), a reopening, and a deployed practice that largely ignores all of it.
The model here has a shorter account. Names and addresses are different roles, typed apart since Chapters 4 and 5: a URI in a fact position names (R3); a URI addressing a projection locates (S4). So the question computes rather than debates. Dereferencing a name returns read(name, S), a description of the named entity. Its address may coincide with the name, differ by a fragment, or differ by a redirect — a wire-level encoding the architecture is indifferent to. Only the collision is real. Put the name and the address on one string, and statements about the thing share a subject with statements about its description. That is a data-discipline cost — measurable, like Chapter 9’s mismatches — and keeping the two apart, either way, avoids it.
The exhibits resolved the question both ways without instruction. The Guardian’s articles collapse the two harmlessly — an article is its own description — while the wind farm’s panels sit one hash away as fragments (#panel-14). That fragment is the convention the reference implementation adopts: one GET serves entity and description alike. The crisis, relocated: a typing discipline the model already draws, plus an encoding choice the deployment already made.
Composition, not creation
Three seams lack Recommendations: identity, access control, and the form-native write. The first two have candidates with running code, and both fill their seam with the model itself. WebID has been incubated at the W3C since 2005 and never advanced to Recommendation. It makes an identity a URI whose dereference is a profile: an agent is an entity, its identity a graph, authentication a proof that the keyholder and the profile agree. WebAccessControl is an ontology grown on the W3C wiki, since adopted by Solid, Berners-Lee’s re-decentralization project. It states permissions as facts — who, which mode, over what — so an ACL is data in the same state model it guards. Identity and authorization collapse into the substrate they protect — Chapter 19’s thesis arriving early — and the reference implementation below runs both. For the third seam, Chapter 9’s bridge — RDF/POST — slots a plain HTML form into the write side. RDF/POST is specified, not standardized. And as Chapter 9 showed, it is an encoding rather than an invention — no new model, no new protocol.
This part has contained no proposal for a new standard, and that absence is the finding. Part III showed the read side complete by 2014. The write side’s last mile is an encoding of what already ships. The remaining seams have candidates that compose deployed pieces. Nothing here waits on a working group. The community’s long reflex — meeting every gap with a new specification — aims at the wrong layer, and Chapter 9 already scored one instance of it. After the reveal, the remaining work was never specification. It was combination: an implementation that assembles the standards in the derived shape. Composition, not creation, one level up — the doctrine that governed RDF/POST, governing the whole construction.
The reflex has a Recommendation-grade instance: the Linked Data Platform (LDP, 2015), which claimed this book’s exact slot — a read-write Linked Data architecture — at the interaction layer. The Graph Store Protocol — HTTP’s methods addressed to whole graphs — was already standardized. LDP’s one addition to it is the container, a server-side collection with protocol-managed membership. But a container is a canned selection, a query frozen into the interface. It arrived after SPARQL had already made every collection open-ended: any members, by any pattern, composed at request time. Subtract the containers and nothing remains that the Graph Store Protocol does not already do: LDP added interface where query semantics sufficed. The gap was never in the protocols; it was in the implementations that never combined what they already offered.
The chapter’s exhibit mirrors Chapter 3’s, deliberately. The two sites we stripped are rebuilt as dataspaces. The strip-2 fact lists are loaded as state, with a small ontology per domain: articles and sections for one, panels and readings for the other. Each dataspace gets one select term per window, an arrange term per layout, and a stylesheet per look. Front page and dashboard become two declarative packages over the same generic machine, the domain living entirely in data. Chapter 3 computed the factorization by hand; this chapter runs it forward, on the same material. Analysis and synthesis meet on worked examples. (The full-scale reconstruction is being built in the open, as Chapter 3’s exhibit once was; the miniature below runs today.)
Interactive exhibit (online edition): the reconstruction in miniature. The two datasets from Chapter 3 under one generic engine — swap the data, the selection, the arrangement, or the stylesheet, and the factors you did not touch hold still. The full-scale reconstruction runs the real stack; this one runs the derivation.
The federation test
Federation needs a client, and the derivation says so before any implementation does. R3 put foreign names inside local facts. At deployment grain, following one is dereferencing another party’s read. A window over another party’s state is ⟦q⟧ posed to another party’s endpoint. Consuming dataspaces is therefore not a feature an application adds; it is the other half of the architecture, and a dataspace that only serves is a leaf. So a reference implementation has a forced shape, both halves at once: a server publishing (17.1)’s four components — origin, ontology, endpoint, stylesheet — and a client consuming anyone’s.
Both halves in one implementation enable a test no bespoke system can run: point the implementation at itself. Two instances, two origins; one browses, queries, and writes against the other. Every capability crosses the wire or fails visibly — no in-process shortcut exists for a demo to lean on. This is the strategy itself, not a stunt. Interoperating with itself is how the implementation does federation: two instances meet as strangers, and the first federation is its own. And the test is not circular. S2 leaves the two instances nothing private to share. Everything that crosses the wire is terms of closed languages — data, query, delta, arrangement — so they meet only on the specifications’ surface, with no side channel to agree over. The standards process proves interoperability with two independent implementations. A reference implementation proves it with two instances of itself — weaker as evidence, earlier by years, and honest exactly as long as the wire carries only spec-terms. A second implementation joins by implementing the same denotations: the door that self-federation proves open is the door that strangers walk through.
The federation test, drawn. Each instance runs both halves. Here Instance A’s client consumes Instance B’s server across three exchanges. It dereferences a foreign name (R3) for a document (S4). It poses ⟦q⟧ to the endpoint e for a window. It submits a delta (Prop. 7.1) as a PATCH — a graph-scoped SPARQL Update. Because S2 leaves nothing private, the meeting surface is the specifications’ surface alone.
The document web bootstrapped exactly this way — the box below dates it. The pattern, one level down: a server+client pair whose self-interoperability is the first running instance of a protocol anyone may join.
The first instance, dated. This is not an analogy; it happened. In 1990 the first web server (info.cern.ch) and the first browser ran on two NeXT machines at CERN and interoperated with each other before there was a third program in the world to interoperate with. That browser — WorldWideWeb, soon renamed Nexus so the web could keep the name — was also an editor: reading and writing went through one program. The write side was there on day one, then lost for a generation as the read-only browser became the thing everyone shipped. The federation test above is that first day made a permanent requirement.
The existence proof
This chapter is where the book’s existence proof enters as evidence. The architecture has a reference implementation: LinkedDataHub, open source, in production for years. It federates the way the section above requires: instance to instance, its client half consuming what its server half serves. It cashes the chapter’s other promises too: WebID and WebAccessControl running, RDF/POST accepted on the write side, entity and description served one hash apart. And the online edition of this book is being built on it, keeping the promise the preface made. Disclosure, once for the chapter: the implementation and the RDF/POST spec are the author’s. The point of an existence proof one can install is that belief is optional.