Changelog — 2.186–2.196
Releases 2.186.0 through 2.196.2. Current releases are on the main changelog, and every band is listed in the release archive.
Loading audio...
Version 2.196.2
August 22, 2026A note in the margin made one machine disappear from the list
- Nothing you can see changed. Still the release tooling — the checklist that tells us which machines an update needs to reach.
- One machine was quietly missing from that list. The list is built by reading each machine’s own configuration file. One of those files has an explanatory note written in the middle of its settings, and our reader treated the note as the end of the settings — so it saw the first line and none of the rest.
- The reason it went unnoticed is the shape of the mistake. It made the list shorter, and a machine that is absent looks exactly like a machine that genuinely had no changes. Nothing failed; the checklist was just quieter than it should have been. Faults that make something disappear are far harder to spot than faults that make noise.
- The test for it uses the real file, not a stand-in. That configuration file is the only one written that way, and it failed this exact check before the fix — so we tested the thing that was actually wrong rather than a copy of it made to look wrong.
- We also corrected our own explanation of the fix. The first draft claimed the fault had broken a second setting too. It had not — that setting had never done anything in the first place. A note that describes a behaviour which never existed is worse than no note at all.
- Nothing to do at your end.
Version 2.196.1
August 22, 2026Our checklist asked a question and answered it itself
- Nothing you can see changed. The improvement described just below — the one that walks us through each machine during an update — had a fault, and it was caught on the very first rehearsal, before anything was published.
- It asked “ready for the next one?” and then read its own list as the reply. So it answered its own question with the name of the next machine, decided that wasn’t a yes, and stopped after the first one. Every time.
- We had already written down this exact hazard, one screen above the code that repeated it. There is a longstanding note in the same file about a different command doing the same thing, and a check that guards against it. The guard was written for that one command rather than for the shape of the mistake — so it watched the front door while this came in the side.
- The reason our tests missed it is the part worth keeping. One test rehearsed the version of the process that never asks any questions. The other replaced the question-asking with a stand-in that didn’t actually ask — removing the one thing that was broken. A stand-in for the thing being tested is not a test of it. There is now a real one.
- Nothing to do at your end.
Version 2.196.0
August 22, 2026Our undo button would have completed successfully and undone nothing
- Nothing you can see changed. This is about the tool we use to publish updates — and specifically about the part that puts things back if an update goes wrong.
- The undo instructions were missing one line, and without it they did nothing at all. They told us to fetch the software and restart it — but not to say which version to fetch. Left unsaid, it fetches the newest one: exactly the thing being undone. Every command would have succeeded, and we would have been told it worked.
- Two of our own written notes said this could not be fixed. Both claimed our systems had no version numbers to fall back to. We checked instead of believing them, and found they do — and have done since a change months ago that one of those notes actually named as the reason it was impossible. It was describing the world before its own fix.
- The tool now walks us through each machine one at a time. Previously it explained the process thoroughly when undoing an update and barely at all when making one, for exactly the same machines. Now it is the same set of instructions either way — written once, so the two cannot drift apart.
- And a practice run can now rehearse the whole thing. It used to stop just before the most useful part, so the one section you would most want to read in advance could only ever be seen during the real thing.
- Nothing to do at your end.
Version 2.195.0
August 21, 2026Addresses that pointed at things which no longer existed
- Nothing you can see changed. The part of the system that turns recordings into text has moved, and this is the tidy-up that goes with it.
- Several settings named destinations that had been gone for a long time. One pointed at something retired long ago and still asked, in its own error message, whether that thing was running. It never caused a problem because another setting quietly overrode it every time — which is exactly how it survived so long. Nothing ever had to resolve it, so nothing ever noticed.
- One of them would have broken something the moment we moved, and the change that looked like the fix would not have helped. We had two settings for the same thing. We checked which one actually reaches the running system rather than assuming, and it turned out to be the opposite one from the one we were about to edit. Same file, two settings, opposite answers — and only measuring told them apart.
- We also retired a piece of speech software nothing had used for months. The interesting part is the order: one of our own post-deploy checks secretly depended on it, so removing it first would have quietly gutted that check while leaving it looking perfectly healthy. We replaced what the check relied on first, confirmed the check could still catch a real fault, and only then removed the thing.
- Nothing to do at your end.
Version 2.194.0
August 21, 2026A setting that promised something the software underneath it could not do
- Nothing you can see changed. This is groundwork for the tools that turn a recording into text and line the words up with the audio so captions land in the right place.
- One of them had a setting for using a graphics card, and could never have used one. The option was there, and had been for a long time — but the software it was built on had no support for it included at all. So the setting was a promise nothing underneath could keep, and the honest original reason for it — not enough room on the hardware it was sharing at the time — had quietly expired long before.
- A second setting has been written down as “required” for years and was never actually passed through. Everything kept working, because it only matters the very first time a component starts up somewhere new — which is exactly the moment nobody was watching.
- And one of the two fixes built perfectly and then could not run. The build reported success; the component failed the moment anything asked it to do its job, because it quietly needed a piece that nothing had listed as a requirement. We only found it because we insisted on running the thing rather than trusting that it compiled — and there is now a check inside the build itself that refuses to finish if it ever happens again.
- The part we care about is the check we added, not the things we fixed. Both faults were invisible: everything reported healthy, the work got done, and the slow path was taken quietly. Our post-deploy check now compares what was asked for against what actually happened and fails when they disagree — and we proved it fails, in four different ways, before trusting it.
- Nothing to do at your end.
Version 2.193.0
August 21, 2026A number we had written down instead of counting
- Nothing you can see changed. One of our release tools printed a total that had been typed in by hand rather than counted at the time. It went out of date twice in a single day this week, and was accidentally correct again by the evening.
- It mattered because of where it appeared — on screen, during a release, immediately above a list it was supposed to agree with. A small number that disagrees with the list next to it is exactly what makes someone stop trusting the whole screen, at the worst possible moment.
- It is counted now, and it refuses to guess. If it ever cannot count, it says “every” rather than reporting zero — still true, and it does not invent a measurement it failed to take.
- Nothing to do at your end.
Version 2.192.0
August 21, 2026These release notes were about to outgrow their page
- Older entries have moved to their own page. This page now carries only the newest releases; everything before them sits in the release archive, linked at the bottom. Any link you have already shared still works — it forwards to the right place automatically, and lands on the entry itself rather than the top of the page.
- We do this on a measurement rather than a hunch. The page has a size limit our build checks on every single release, and it prints how much room is left each time it passes. When that gets close, we close the current stretch and start a fresh one. This time we were three days of releases away from the limit.
- We broke our own rule to do it, deliberately, and would rather say so. We normally only archive entries that have actually appeared here first. A lot of behind-the-scenes work is moving at once just now, and publishing a release purely to satisfy that ordering would have been the tail wagging the dog. The reason is written into the new page itself, where someone puzzled by it will actually be looking.
- The written instructions for doing this contained a check that could not pass. It compared two lists that were never meant to match, so it reported a problem on a perfectly good result. It had been correct years ago when there was almost nothing to compare against, and quietly stopped being runnable as the archive grew — which is our favourite kind of mistake to find, because nothing was wrong except the thing telling us something was wrong.
- Nothing to do at your end.
Version 2.191.0
August 21, 2026One part of the site had no way back
- Nothing you can see changed. The part of our system that writes and drafts text was set up on its own some time ago — its own project, its own build process, its own release schedule. It worked perfectly well, so nobody revisited it.
- The cost of that only shows up on the worst possible day. Everything else we publish gets stamped with a version, so “put back the one from last week” is a single instruction. This part never got a stamp. Had it gone wrong, there was no numbered version to return to — and that is precisely when you need one.
- It now lives alongside everything else and is stamped like everything else. We also found that bringing it across unchanged would have broken a rule we added only days ago, about never assembling software on the machine that runs it. The rule caught it, which is the first time it has earned its keep.
- Separately: a check we rely on was asking the wrong question. It decided what to inspect by starting from “which software do we build ourselves” — so anything running software built by someone else was invisible to it, no matter how much of our own configuration it was carrying.
- One thing it had never looked at was eight months out of date. Nothing was broken, because the part that mattered had not changed in the meantime. But nothing was watching either, and that is the half worth fixing.
- Nothing to do at your end.
Version 2.190.0
August 21, 2026We were still building software for something that no longer exists
- Nothing you can see changed. One of our internal tools was retired a few days ago. Every time we published since, our build system dutifully produced a fresh copy of it — for nothing to run.
- A check we added last week found it, which is the whole point of having added it. It works out where each piece of our software is meant to run and then goes and asks. On its first real run it reported that one of them could not be reached at all. A list nobody ever consults cannot be wrong in a way anyone notices; giving it a reader is what made it checkable.
- We asked two questions before removing anything, because they are not the same question. Could anything still be pointed at the retired tool, and had anything actually used it recently? Both needed answering, and doing so corrected a note of our own that claimed a piece of follow-up work was still outstanding when it had in fact been finished.
- Several references to the retired tool were left exactly where they are. For some of them being unreachable is the entire point — one is a test proving our software notices when it cannot contact something. Removing them would have quietly deleted a working safeguard while looking like tidying up.
- A temporary exemption deleted itself. When we added that check we allowed exactly one exception and wrote its expiry condition into it. Fixing the problem made the exception the thing failing the check. That is the only kind of to-do note that cannot be forgotten.
- Nothing to do at your end.
Version 2.189.0
August 21, 2026A house rule that now checks itself
- Nothing you can see changed. We have a standing rule that every part of the site is assembled centrally and then copied to the machines that run it — never assembled on the machine itself. That matters because a machine that builds its own copy has something nobody else has, which makes “go back to how it was yesterday” impossible.
- Until today that rule was written down and nothing enforced it. Now it is checked automatically every time the site is built.
- It has no exceptions, and that took some doing. There was exactly one thing breaking it, so we cleared that out first rather than adding it to a list of things to fix later. A rule with no exceptions is much harder to quietly erode than one with a to-do list attached.
- The check was wrong twice before it was right. Two obvious ways of spotting the problem each accused something innocent — in opposite directions. Neither signal was reliable alone; only both together. We wrote down what each got wrong, because the next person will reach for the same shortcuts.
- We also wrote down what it cannot see. There is one way of making the check pass without actually fixing anything, and rather than hope nobody finds it, we noted it and pointed at the separate check that does catch it.
- Nothing to do at your end.
Version 2.188.0
August 21, 2026Two retired tools finally filed away, four months late
- Nothing you can see changed. Two pieces of our own tooling were switched off a while ago — one of them back in April — and their setup files were left sitting alongside the ones still in use.
- The problem with that is how convincing they looked. Both still carried instructions written in the present tense, so anyone reading them would reasonably assume they described something running. That is the most expensive kind of leftover: it does not break anything, it just sends the next person down a dead end.
- One of them would also have rebuilt itself on whichever machine ran it, rather than collecting a pre-made copy as everything else does. Clearing it out first means the check we are adding next can be written as a flat rule with no exceptions.
- The name lives on, and that is deliberate. Three separate parts of the site still refer to the retired tool by name while actually pointing at its replacement. Renaming them would be tidier and would risk breaking working things, so the old name stays with a note explaining why.
- Moving the files revealed two sentences that had quietly stopped being true — one describing a retired machine as still in production, another as still needing an operator. Our link checker caught them, and its advice was the useful part: check whether the surrounding sentence is still true before simply repointing a link.
- Nothing to do at your end.
Version 2.187.0
August 21, 2026A checklist that runs itself, before we publish anything
- Nothing you can see changed today. This is about how we get a new version of the site onto the machines that serve it — a job that has always been done by following written steps carefully, one at a time.
- We have built the first part of a tool that checks those machines are ready before we start. It looks at each one and reports whether it is prepared, or whether something needs sorting out first. It only ever reads; it changes nothing, and it deliberately cannot fix anything by itself.
- It found real work waiting on the very first run, on most of the machines it checked. None of it was affecting the site — it is the kind of thing that stays invisible until the day it matters, which is exactly the day you least want to discover it.
- It also caught a mistake in our own notes. Our record of which machine does what still described one that had been switched off and taken apart five days earlier. The tool noticed because it tried to talk to it. A note nobody reads cannot be wrong in a way anyone spots — giving it something that actually depends on it is what made the error surface.
- And it caught a bug in itself, which is the part we are most pleased about. Its first report confidently flagged a problem with the one machine that was already perfectly fine. We chased the accusation rather than accepting it, and found the fault was in the tool. A checking tool that is trusted while quietly wrong is worse than no tool at all.
- Nothing to do at your end.
Version 2.186.0
August 21, 2026The main picture on a page was queuing behind everything else
- Every page has one image that decides how quickly it feels loaded — the big picture at the top. A browser will fetch it sooner if you tell it that image matters more than the small logos and icons around it. We were never telling it, so the picture waited its turn like everything else.
- We now say so, on exactly one image per page — the event artwork on the home page and on each event page, and the artwork on a Reflection or Vignette. Marking more than one would put us straight back where we started, since a queue in which everything is urgent is just a queue.
- The reason we had missed it is the interesting part. Two of those pictures were already marked with a setting called “priority”, and it does not do this. It makes the picture load straight away rather than waiting until you scroll to it, which is most of what you would want the word to mean — but not the part about jumping the queue. A name that is two thirds right is one nobody checks.
- We can prove the browser now asks for it first; we cannot yet prove it arrives sooner. The measurement we can take today runs against our test copy of the site, which loads far more supporting files than the real one does, so the picture is competing with traffic that does not exist for you. We would rather say that than quote an improvement we have not seen.
- Separately, the still frame behind the Reflection video was about a third larger than any screen needs. It was sized for the widest window anyone might have; it is now sized for the window most people actually have, which takes a noticeable weight off the home page on a phone.
- That change also came with a correction to ourselves. We first concluded the old size had been left behind by a later change, wrote up why, and then measured properly and found the original reasoning had been right all along. The note explaining the old choice has been kept, along with the record of us getting it wrong, because a tidy story that fits is exactly the kind that gets believed twice.
- Nothing to do at your end.