Changelog — 2.211–2.218

Releases 2.211.0 through 2.218.1. Current releases are on the main changelog, and every band is listed in the release archive.

Loading audio...

Version 2.218.1

August 25, 2026

Our own safety check refused to let us publish, because of a machine we had switched off ourselves the day before

  • Nothing you can see has changed. This is a repair to one of our own tools, and it is here because the tool was right and the check on it was wrong — which is the more interesting way round.
  • We run a safety check before publishing anything. Its job is to refuse when something does not add up, and it refused. It said one of its own lookups had failed and told us not to publish.
  • The lookup had not failed. It had given the correct new answer. We had retired a machine the previous day and moved its work elsewhere, entirely deliberately. The lookup correctly reported the new home. The check was still comparing against the old one, so the right answer was scored as a failure.
  • It also blamed the wrong thing. The message pointed at the lookup, so anyone reading it would have gone off to investigate the one part that was working perfectly.
  • The repair is to stop checking against a fixed answer. The check now confirms the shape of the answer and that the parts agree with each other, rather than that it matches something written down months ago. That is a stricter test, not a looser one — it catches mistakes the old version could not — and it will not go wrong again the next time we move something, which we will be doing twice more this week.
  • And we deliberately broke it, to watch it fail. A check nobody has seen refuse is not yet a check. Our first attempt at breaking it produced far more failures than it should have, which told us our test of the test was faulty rather than the check — so we fixed that first.
  • Then we corrected nine notes that still described the retired machine, two of which had gone from merely out of date to actively backwards: they named the switched-off machine as the place to deploy to, and specifically ruled out the one that now does the work.
  • Nothing to do at your end.

Version 2.218.0

August 25, 2026

We told you there were forty-five results and then gave you no way to see thirty-seven of them

  • You can now see all of your search results. Search groups what it finds by kind — reflections, articles, events, sessions and help — and it was showing the first eight of each group and stopping there. If your search matched forty-five articles, the other thirty-seven were simply out of reach. Every group that has more now carries a Show all link, and the expanded page has its own address, so you can bookmark it or send it to somebody.
  • Each group expands on its own, deliberately. We do not merge the groups into one long ranked list, because the parts of the site are searched separately and their scores are not comparable — a single combined list would look like an order of relevance without being one. So you open the group you care about, and the others stay as they were.
  • The page had been telling you all along, which is the only reason this was easy to find. Underneath every trimmed group it said “showing 8 of 45”. That was honest, and it was useless: a true number with nothing attached to it. A version that had quietly shown eight and said nothing would have hidden this for far longer. The label was doing its job; what was missing was the link beside it.
  • And where there are more than we will show at once, it says so. A very broad search can match more results than it is sensible to put on one page. Rather than cutting the list off and looking complete, the page tells you how many it is showing and suggests narrowing the search.
  • A new piece in Technical Writings: The server was fine. Rebuilding one machine produced nine of our own checks reporting problems that did not exist — and not one of them was broken. What caught them was never looking harder at the thing complaining; it was a second source disagreeing, and three of the most useful second sources were accidents nobody had arranged. It is written for anyone who administers systems, and as always it describes no part of our own setup.
  • We also removed a setting that pointed at a machine we had already switched off. It configured speaker identification in transcripts, which we retired in July. Nothing had used it since, but it was still being handed to the site on every start, looking for all the world like something that mattered. Removing it needed a change in two places rather than one — deleting it from the settings file alone would have left it present and empty rather than absent, which is a distinction that has bitten us before.
  • Nothing to do at your end — the search change is simply there the next time you use it.

Version 2.217.0

August 25, 2026

A health check that was really counting how many times we had looked at it

  • Nothing you can see has changed, and that was the goal. We moved the part of our system that cleans up audio before transcribing it onto different hardware. It kept working throughout — transcription, translation and article generation were all available the entire time, and we checked each of them on the far side.
  • The way we proved it is the part worth describing. Before testing whether the new hardware was doing the work, we switched the old hardware off and confirmed it was refusing to answer. Otherwise a successful test proves only that something worked, not which thing. We did that at both ends of the move.
  • A health check turned out to be measuring how often we had inspected it. Drives keep an internal error log, and we treat a non-zero count as a warning sign — it is one of the things that flagged a drive which later failed. One drive reported a worrying number. Reading the entries showed they were all the same harmless message, and that the act of reading them added another one. The tool asks the drive a question it does not understand, the drive says so, and the refusal is recorded as an error. So a perfectly healthy component would have been condemned for having been examined too often. We now read the entries rather than counting them.
  • And one of our own tests could not fail. While fixing the above we added a test, and it passed. It would have passed whatever we did, because of a subtle mistake in how it was written. We only noticed because a second test failed when it should have passed — and chasing that revealed the first one had never been checking anything. A test suite whose job is proving that checks can fail is a bad place for a check that cannot.
  • A machine refused to start, and the fix was two settings — neither of which worked on its own. We spent a while on this. Each setting controls one half of the same handover between the start-up software and the operating system, and leaving either half switched on was enough to jam it. Individually they looked like failed ideas; together they worked first time.
  • Then we put our other changes back, to find out which one had actually mattered. Along the way we had altered several unrelated settings while hunting. Once it worked, the temptation is to stop touching it. Instead we restored them one by one and confirmed it still started — which proved they were never the cause, and meant the machine did not silently keep a handful of unnecessary deviations forever, introduced by debugging rather than by design.
  • A set of instructions was correct, and stopped being correct the moment you typed it by hand. One of our procedures works perfectly when run remotely and fails when you log in and type the same characters, because of a quirk in how command shells treat one punctuation mark. The instructions were not wrong; they were only ever tested one way.
  • Why we keep writing these up. Four separate measurements misled us this time, and every one of them pointed at something being worse than it was. That direction is not an accident: a broken instrument usually returns nothing, and nothing looks like failure. The habit that saves the time is cheap — before believing a bad result, check that the thing doing the measuring still works.
  • Nothing to do at your end.

Version 2.216.0

August 25, 2026

Two of our own notes disagreed with each other, and that disagreement was the only reason we found out either was wrong

  • Nothing you can see has changed. This was behind-the-scenes work: moving one part of the machinery that draws our illustrations, and retiring what it used to run on. The illustrations themselves are unaffected, and we checked all three kinds before and after.
  • The interesting part was not the move — it was what we found in our own notes while doing it. Two internal documents described the same piece of finished work in incompatible ways: one said a job was still under way, the other said it had been completed a week earlier. Neither looked wrong on its own. The disagreement was the entire signal — and when we went and checked against the real thing, both were out of date, in different directions.
  • We also found a table in those notes that had quietly stopped showing two of its rows. Someone had added a paragraph of explanation into the middle of it, and in the format we write these notes in, that silently ends the table — everything below it becomes ordinary text. The file reads perfectly if you look at the raw version; only the formatted version is wrong, which is why nobody had spotted it. The two rows it had stopped showing were the two that mattered most.
  • And a setting on our development machine pointed at something we had just switched off. We knew about it — we had written it down in the previous release as a thing that would break. It broke. Writing a problem down is not the same as fixing it, and this one is a good argument for doing the fixing at the time.
  • Then we ran a recovery tool for real for the first time, and it had two faults. We keep a carefully-written script for rebuilding a machine from its backup. It had been reviewed, and it had never actually been used. The first real run found one fault immediately — and a second, quieter one that would only have appeared during an actual recovery, which is the worst possible moment to discover anything.
  • One of its own self-checks had been passing on data that cannot exist. The check compared the script’s output against a sample we had written by hand, and our hand-written sample was slightly tidier than anything the real system ever produces. So the check went green whether the script was right or wrong. A test can only tell you about the data you give it, and we had been giving it something too clean to be true.
  • Why any of this is worth telling you. Notes that are wrong are more expensive than notes that are missing, because a missing note sends you to go and look, while a wrong one sends you off confidently in the wrong direction. We have got into the habit of writing down how to re-check a fact rather than the fact itself — and of treating “we wrote it down” and “we tried it” as two different things. Every mistake above was a sentence that had been perfectly true on the day it was written.
  • Nothing to do at your end.

Version 2.215.1

August 25, 2026

We deleted a setting and it did not go away — it went blank, which is a different thing entirely

  • Nothing you can see has changed. This is a small piece of housekeeping behind the scenes, kept because of what it nearly did rather than what it did.
  • We removed an old, unused setting from the configuration of the live site. When the site restarted, that setting was still there — not with its old value, but blank. Somewhere else, a second file was still asking for it by name, so removing it from one place produced an empty one rather than none at all.
  • It caused no harm, and the reason it caused no harm was luck rather than design. The code that reads it happens to treat “blank” and “missing” as the same thing. There is a very similar and slightly more modern way of writing that same line which treats them as different — and under that version, a blank setting would have been used as though it were a real one, and every illustration would have failed to generate.
  • That is the part worth writing down. A future tidy-up that swapped one for the other would look like an improvement, would pass every check we have, and would break something that had been working for years. The change would be correct in isolation and wrong in combination, which is the hardest kind to catch.
  • So we removed the setting properly rather than relying on the luck. It is gone from the configuration, gone from the code, and gone from the two example files that still carried it — one of which was still naming a machine retired in April.
  • The general lesson, if you keep configuration of your own: deleting a value is not the same as deleting the setting. Check what the running system actually received, not what the file you edited now says.
  • Nothing to do at your end.

Version 2.215.0

August 25, 2026

We have stopped writing machine addresses into our code, starting with the part that draws pictures

  • Nothing you can see has changed, and that is deliberate — this change was designed to do nothing at all on the day it went out.
  • Our code used to refer to the machine that generates illustrations by its numeric address. That works right up until the machine is replaced, at which point the number is simply wrong, and every place it was written down has to be found and corrected. We keep discovering old numbers in our own notes for machines that stopped existing months ago.
  • It now refers to that part of the system by name instead. A name can be pointed at a different machine in one place; a number has to be corrected everywhere it appears. Ours appeared in twenty-one places.
  • We split it into two steps on purpose, and the first one changes nothing. The name currently points at exactly where the number did, so this release is provably a no-op — if anything about picture generation had changed today, we would know the change itself was at fault rather than wondering. Moving one thing at a time is slower and tells you far more when something goes wrong.
  • The obvious objection turned out to be smaller than it looks. If a name cannot be looked up, the request fails — but that is the same failure as the machine not answering, which the system has always had to cope with. It adds a new reason for a familiar problem, not a new kind of problem.
  • One small thing that made us smile: a setup script prints its instructions inside a drawn box, and the new name is more than twice as long as the old number, so it burst the border. Fixed by using a shorter form that is also more correct in that context, and re-measuring the padding.
  • Nothing to do at your end.

Version 2.214.1

August 25, 2026

The one step in our build instructions that had no steps turned out to be the one that had gone wrong

  • Nothing you can see has changed. This is about the written instructions we follow when we set up a new machine.
  • One item on that list was an instruction with no procedure attached — it named a piece of software and said it should be installed, and left how to do it in somebody’s head. Everything else on the list had actual steps.
  • That was the item that had drifted. When we finally compared the machines the instructions had produced, they were not the same as each other: one had a component the other did not, and one carried a leftover from something unrelated. Neither machine looked wrong on its own. It was only visible by putting them side by side, which nobody had ever had reason to do.
  • We have written the steps down, along with a check that proves the right version was installed — because the command in question quietly succeeds whether it did the intended thing or not, which is the kind of success we have learned to distrust.
  • Writing it down also disproved something we had recorded about our own machines. A note explained why a particular shortcut was dangerous, and gave a reason that turned out not to be true. The decision it justified was still the right one — but we had been about to reuse that false reason to justify a second, unrelated decision, which is how a wrong sentence gets tenure. Corrected, with the measurement that disproved it recorded beside it.
  • The transferable bit, if you keep instructions of your own: the entry that says what without saying how is not a small gap in a checklist. It is the one that will be performed differently every time, and the difference will not show up until someone compares two results.
  • Nothing to do at your end.

Version 2.214.0

August 25, 2026

Our systems were calling each other by names that had quietly stopped being true

  • Nothing you can see has changed. This is entirely about the machinery behind the site — but it is the kind of tidying that prevents the sort of outage you would see.
  • One of our own admin pages was listing names that pointed at a place which had never existed. It broke nothing, because nothing used those names except a person reading them — and that is precisely why it went unnoticed for so long. A name shown to a person is used: to decide what to look at, what to search for, what to tell a colleague. We had even written a note beside it saying the names were only for display, which turned out to be the reason nobody checked them.
  • We found entries still naming machines we had retired, some of them long ago. One named a machine that was never built at all — and that kind is the worst, because nothing anywhere contradicts it. A retired machine leaves a trail you can follow; something that never existed leaves nothing to be inconsistent with, so it can sit there looking perfectly reasonable forever.
  • Two entries were not merely stale but actively wrong. One had a hyphen where a full stop belonged, so it led nowhere at all. Another still listed a machine we had removed, so a share of requests were being sent somewhere that could not answer. Both had been that way for some time and neither produced an error anywhere.
  • We built the clean-up as a tool rather than doing it by hand, and taught it the two mistakes we had just found. It now refuses to create either of them. It also refuses to trust a success message: after every change it asks again, independently, whether the change is really there — because the system it talks to will happily reply success while reporting a failure in the same breath.
  • The tool caught two of our own errors while we were using it, which is rather the point of building it that way. It also found one thing we had been recording as working that was advertised but not actually running — invisible for as long as nobody asked it anything.
  • The find we liked most: one entry described a piece of equipment as something it simply was not. The name read perfectly sensibly, which is why it had survived. What exposed it was that a written description and the live system disagreed — neither of them looked wrong on its own.
  • Nothing to do at your end.

Version 2.213.0

August 24, 2026

We have started writing up what we learn from running this site, and there is now a place to read it

  • There is a new section in the Help Centre called Technical Writings. It is where we write up things we have learned while building and running the machinery behind this site, for the benefit of anyone working with the same tools.
  • We are not a technology organisation, and the section says so on its first line. We are an Islamic community, and our work is religious content and education. The technology exists to serve that. These pages are a by-product of doing that work carefully — not a change of direction.
  • You do not need to share our beliefs to find them useful, and you do not need any technical background to read the introduction. Each piece starts in plain English and gets more specialised as it goes, so you can stop wherever it stops being interesting.
  • The first one is about backups. We had backups of every machine behind this site and had never actually restored one — two different claims we had been writing down as though they were the same. So we erased a machine that was doing no work and put it back from the backup alone. It worked; six of our own tools told us the wrong thing along the way, and that turned out to be the interesting part.
  • These will not appear on a schedule. They appear when we have learned something worth another person’s time, which might be twice in a month or not at all in a year. We would rather the section were occasionally quiet than regularly padded.
  • Older entries on this page have moved to an archive, and any link you saved still works. This page keeps the newest releases; everything before 2.211 now lives on its own page, linked at the bottom. If you had bookmarked a particular entry, opening it sends you to wherever it now lives rather than leaving you at the top wondering.
  • If you listen to pages rather than read them, these work too. Where a page shows a block of commands, the narration tells you it is there and where to find it, rather than reading it out character by character — which would be several minutes of letters and numbers. It says so rather than skipping silently, because you cannot tell the difference between nothing being there and something going missing.
  • Nothing you read there describes our own systems, deliberately. No addresses, no machine names, no diagrams of what sits behind what — every example is written generically. The interesting part of what we learn is almost never specific to us anyway.
  • Nothing to do at your end.

Version 2.212.0

August 24, 2026

We found machines with no backups and a note saying they were covered — so we wiped one and put it back

  • Nothing you can see changed. This is entirely about the machines that run things behind the scenes, and it is not a comfortable entry to write.
  • Some of them turned out to have no backups at all, while a note of ours described them as covered and used the words confirmed working. What had happened is ordinary and worth naming: a plan was written down in the past tense before it was carried out, and then the plan itself changed for good reasons. An intention recorded in the past tense is indistinguishable from something that was actually done — so nobody went back and checked. One is now backed up and checked; the other was still working through its first backup as this went out, and we have written that down as it is rather than rounding it up. That distinction is the entire point of the entry.
  • The act of writing the setup procedure down found instructions that would have produced an unusable backup. It would have run to completion, reported success, and quietly omitted the parts a machine needs in order to start up again. Nothing anywhere would have told us, until the day we needed it and it did not work.
  • We have separated two things we had been treating as one: having a backup, and having proved you can restore from it. They are now recorded as separate claims — because the only honest way to test the second is to erase a machine where failing costs nothing.
  • So we did that. An earlier draft of this very entry said the restore was still untested and that we had not yet wiped anything. We erased a machine that was doing no work, put it back from the backup alone, and it started up first time with nothing needing repair. It came back as the same machine rather than a fresh one that resembles it, and the first thing it did was take a backup of itself. A backup you have never restored is a promise, not a protection.
  • Five of our own tools told us something had failed when it had actually worked, and a sixth told us a job had run when it never had. None of them were broken; each was answering a slightly different question from the one being asked. In every case the check that told the truth was already available and cost nothing. When a result is bad news, check the instrument before you believe it.
  • The one that would have cost us dearly was an error message that is word-for-word what our own notes describe as the sign of everything working. Two situations, opposite meanings, and a single word apart. Someone meeting it in the middle of the night would have read our instructions, seen the message they were told to expect, and concluded all was well while being entirely locked out. A failure that looks exactly like a documented success is worse than one nobody has written about.
  • Doing it by hand once was enough to show it should never be done by hand again. Putting a machine back involves copying long strings of characters exactly, from a screen, under pressure, where a single wrong character produces something that looks fine and will not start. That is now a program that reads them itself. It found two faults in its own checks before it was ever used for real — both of which would have produced a confidently wrong result.
  • Two of our own time estimates were wrong in the same way, and our notes warned against exactly that mistake a few lines above where we made it. We had timed a slow moment in a long job and assumed the rest would go at the same rate. One job we predicted would take most of a day finished in about two hours. Measuring one part of something and calling it the whole is not a measurement.
  • A set of instructions for connecting to our own machines was wrong, and wrong in the worst way: it produced a confident-looking error that blamed the wrong thing entirely, sending whoever followed it off to investigate a machine that was working perfectly well.
  • And a measurement we had explicitly recorded as “not yet taken” has now been taken. A note of ours had been careful to say that a particular conclusion was unproven and should not be repeated without evidence. That caution turned out to be exactly right, and it took two commands to settle. Writing down what you have not checked is worth as much as writing down what you have.
  • Nothing to do at your end.

Version 2.211.0

August 24, 2026

We wrote down a procedure we had been carrying in our heads, and writing it down found four things wrong with it

  • Nothing you can see changed. This is about how we set up the machines behind the site, and what happened when we moved that knowledge out of one person’s notes.
  • Some of our setup steps lived in a personal notes document rather than alongside the code. That works right up until someone else has to follow them, or until the world moves on underneath them. They now live with everything else, where they can be reviewed, corrected, and argued with.
  • The act of writing it down found an instruction that would have quietly produced the wrong result. It was correct when it was written. The situation it was written for had since changed, and the instruction outlived the reason behind it — which is the hardest kind of error to spot, because the words still read as sensible.
  • It also offered two ways of doing something that turned out to be exactly the same thing, one of them labelled as the better option. A choice that is not really a choice is worse than no choice at all: you spend effort deciding, and afterwards you cannot tell which one you took.
  • And a note of ours described something as impossible when it simply had not been tried. We checked, and it took two lines to disprove. Nobody re-checks a door that someone has already reported as locked, which is what makes that kind of note expensive rather than merely wrong.
  • We have also separated two things we had been treating as one: having a backup, and having proved you can restore from it. They are different claims and they now get recorded differently — because the only way to test the second one properly is on a machine where failing costs nothing.
  • Nothing to do at your end.