The engineering notebook

How the machine at linemode.dev was built, what each of its claims is measured against, and the places it was wrong before something caught it. The front page is the argument. This is the working.

Nothing here was written from memory

Six protocols, seven specifications, and not one grammar on the front page typed out from what I remembered of it. Each RFC is fetched once, stored beside the page, and recorded in a manifest with its length and its sha256. The claims test reads those files off disk and greps the page's assertions out of them, so a sentence that drifts away from its source fails a test rather than surviving because it sounds right.

That matters more here than it looks. I worked on this material in 1994 and 1995, at Spry in Seattle, on a crawler for Usenet news, and knowing a protocol from having debugged it is exactly the state in which a person writes a confident wrong sentence. The whole point of keeping the archive is that being familiar with something is not evidence about it.

The RFCs wrap their text at seventy-odd columns, so a quotation that crosses a line break will not match the file it came from unless the whitespace is collapsed first. The test collapses it. Presentation is not the claim.

One rule is code, and it is swept rather than sampled

Almost everything on the front page is a grammar written down: a command is a line, a reply starts with three digits, a block ends with a period. Those are quotations and they are checked as quotations. One thing is different. The doubling of a leading period is a transformation with an inverse, so it is implemented, and something implemented can be tested properly.

Two thousand generated messages, with a fixed seed so a failure reproduces exactly, drawn from an alphabet that is mostly periods. Random English would almost never produce the case that matters — a line that is only a period, inside the body — so the generator is biased towards it and the test then asserts that the sweep really contained it. A sweep that never hits the dangerous input passes for the wrong reason, which is worse than failing.

The counterexample is checked too. Without the rule, a body containing a lone period truncates at that line: the test asserts that the unprotected form loses everything after it, and that the protected form arrives whole. A test that only proves the good case cannot tell you the rule is doing anything.

Two framing rules, and only one gives the text back

The second framing rule went unnoticed for the first version of this page, and it is the more interesting of the two. A block of text ends with a lone period. A reply ends a different way: RFC 959 brackets it, first line code-and-hyphen, last line code-and-space. Same hazard, since a line of the body could look like the closing line, and the standard's answer is to pad the front of any intermediary line beginning with three digits.

Then it stops. The reader is told to find the code followed by a space and to ignore every line before it, and that is the whole rule. There is no collapsing step, nothing removes the pad, and so the text does not come back as it was sent. The period's rule is called a transparency procedure and earns the name; this one protects the frame at the payload's expense.

It is also broader than the danger. Only the same code and a space really ends a reply, so a line beginning "220" inside a 211 reply was never going to truncate anything — and it gets padded anyway, because the routine writing the body does not always know which code will wrap it. The sweep asserts the asymmetry rather than assuming it: every body that could not collide comes back byte-exact, and every body that could does not. A test demanding both rules be lossless would have been wrong about the standard and would have looked like diligence.

Six protocols, and the seventh that was cut

The plan had seven. Archie came out on research rather than for space. RFC 1580 is a guide to network tools, and it documents how a person reached Archie — a local client, a telnet login, or electronic mail — without defining a wire protocol of its own. A service you reach by logging into somebody else's program and typing at that is a different kind of thing from a protocol with a grammar, and it would have been the only one of the seven unable to answer the question this page asks.

Which is a better reason to cut something than length, and worth recording. Running out of room and not belonging look identical from outside, and only one of them is a judgement anybody else can check.

The era's two ends, and the one that moved

1971 is RFC 114, A File Transfer Protocol, dated 16 April 1971. Both the title and the date are checked against the archived text rather than against a memory of it.

The other end moved during the build. The roster said 1994, which is when SSL 1.0 existed inside Netscape and was never released because it was broken. The first version an ordinary person could run was SSL 2.0, in Navigator 1.1, in February 1995. Ending the era at a version nobody could run would have been a rounder number and a worse fact, so the roster was changed rather than the page. The twenty-four years the front page claims is derived from the two ends rather than typed, and a test checks that the subtraction agrees with the sentence.

Where this page was wrong first

A quotation completed from memory. The NNTP passage ended "the first character is deleted", which is a paraphrase and not what RFC 977 says. It happened the ordinary way: a grep truncated the sentence, and the rest was filled in by somebody who knew what it meant. What the standard actually says is that the client must "determine either that this is the end of the text or whether to collapse the doubled period to a single one", which is a decision and not a deletion — and the difference is the whole mechanism. The claims test caught it before it shipped, because it greps for the exact words rather than for the sense.

A test that asserted the wrong thing. While writing the multi-line reply sweep, I added a check saying that an unpadded line beginning "220" would end a 211 reply three lines early. It would not: only the same code and a space does that. The check failed, and the failure was the test being wrong rather than the code. Correcting it produced the sharper claim now on the front page — that the padding rule is deliberately wider than the collision it prevents — so a wrong test bought a better sentence.

A dead control. The stepped FTP transfer shipped with a "Start over" button that did nothing at all when the stepper was already at the first line. The controls audit presses every control and requires something observable to change; it failed, and named the button. It is disabled until there is something to reset, like the reopen button beside the terminal.

The Cloudflare project on the wrong account. It was created by pages init, which defaults to the wrong one of the two accounts here. Account isolation is a hard rule, the audit caught it, and the project was deleted and made again in the right place before anything was served from it.

Structured data describing a page element that did not exist. The first deploy failed the canonical audit: the shared region supplies BreadcrumbList structured data, and the page had no visible breadcrumb navigation for it to describe. Machine markup that asserts something the page does not show is not a technicality; it is a claim to a reader who cannot see the page.

Two claims an outside reader caught, both testable and both wrong. The page used to say “PASV exists because of it” immediately after a paragraph about network address translation, which reads as a causal claim and is backwards by eight and a half years: PASV is in RFC 959, October 1985, and the first NAT specification is RFC 1631, May 1994. The true story is better — a mode built for a different problem turned out much later to be the only way an ordinary client could still move a file. And it used to say there is “no arrangement of keys that produces the byte 22”, which is false: 22 is a control character and a terminal emits those. What the model actually computes is that the bytes are outside printable ASCII, which is true; the prose had inflated a real measurement into an impossibility. The barrier is bigger than the keyboard anyway, and saying so is the stronger argument.

And one the same reader got wrong, which is worth as much. The review reported Transistor and CPU Cache serving an older generation of the site, quoting a title and two sentences from them. Fetched at the time of the report, the live title was different, one quoted sentence appeared nowhere on the page, and the two that did appear were inside the honesty ledger — in the paragraph that retracts them. A page that publishes its own corrections can be misread as still making the claim it withdrew. That is a cost of the format worth knowing about, and not a reason to stop.

The breadcrumb bug, again, on this very page. This notebook's first draft failed the canonical audit for exactly the fault described two paragraphs up: BreadcrumbList structured data supplied by the shared region, and no visible breadcrumb navigation for it to describe. Writing the lesson down and then reproducing it within the hour is a fair summary of why the gate exists and the write-up does not.

A footer running into both screen edges. Found months after launch, on a phone. The shared studio footer defends its own alignment and its own line length — each of those added after a host page imposed them — and declared no horizontal padding at all, so it took whatever inset its container gave it. This is the one site in the family where that footer sat as a bare child of the body, and the inset was nothing. Fixed twice over: the component keeps a gutter of its own now, and here the footer sits in the page's column like everywhere else. The parity gate that compares footers across the family had only ever measured at 1280 pixels, where every site looks the same; it takes a second pass at phone width now.

What is not here

Sockets. Obvious, repeatedly tempting, and not happening. It would need six servers still speaking six protocols, two of which are effectively gone, plus a proxy to reach them from a browser — and the honesty ledger would get longer rather than shorter, because the proxy would be doing the part the page claims you are doing.

Real transcripts. The replies are written from each protocol's published grammar. A real server differs in its greeting, its capabilities and most of its text. What is faithful is the shape: the commands are the commands, the codes are real codes in their real classes, and the terminators are the terminators.

Telnet option negotiation. RFC 854 is cited here for the Network Virtual Terminal, which is where the words "line mode" come from, and not for the IAC command stream. On these ports almost none of it was used — RFC 959 says FTP "relies on very little of the Telnet Protocol" — so a page about typing would have spent a section on the part nobody typed.

Gopher's item type, operated. The parser exists in the page's own code and nothing on the page calls it yet. That is a gap rather than a decision, and it is written down in the work tracker as one.