Changelog — 2.93–2.102

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

Loading audio...

Version 2.102.0

August 9, 2026

Before deciding whether the last change was an improvement, we built the thing that could tell us — and it caught itself being wrong three times

  • The previous release changed what our writing tools read, every single time they write. Whether that is actually better is a question worth answering rather than assuming. So this release is the apparatus for answering it: the same story idea written twice, once with the new context and once without, put side by side with nothing indicating which is which.
  • The two sides come from one search, presented two ways — never two searches. If each side went and looked things up separately they would differ by chance as well as by the change, and no result could be attributed to anything. Both sides now see identical material in identical order. They differ in one place and nowhere else.
  • Some of the comparisons have the same thing on both sides, and whoever is judging is not told which. Writing is not repeatable — ask for the same story twice and you get two different stories. So preferring one side proves nothing until we know whether people also prefer one of two attempts that differ only by chance. If they do, the whole comparison is measuring noise and no conclusion from it holds, however clear it looks.
  • Building it, we found that half of what we were about to compare was the same handful of ideas repeated. The same story idea gets written more than once, and each attempt is stored separately — so a list of the most recent ones is not a list of distinct ideas. A comparison claiming twenty-five would really have covered about eighteen, and two of the checks described above would have been the same idea as each other.
  • And those checks had all landed on one kind of story. Taken from the end of a list ordered by date, every one of them happened to be a children’s story — much shorter than the rest. They would have been measuring how much writing varies for a kind of story they were not there to check. They are now spread evenly through.
  • The third mistake was the one we would never have found by looking. Two decisions that had to be independent of each other were worked out from the same small calculation, with a different label attached — which sounds independent and is not. Checked properly, the two came out identical every single time across a thousand cases. It would have quietly disabled the one safeguard that makes the whole comparison readable, and nothing would have looked wrong.
  • It also caught something in the release it was built to judge. A limit meant to cap how much extra context gets included was only counting part of what it was including — so the real amount was roughly twice the stated limit, and on the worst case it went past it. That has been fixed in the previous release rather than left as a number quietly meaning something other than what it said.
  • Nothing to do at your end. This is entirely behind the scenes. Nothing about it changes what you read.

Version 2.101.0

August 9, 2026

Long passages get divided up so they can be searched — and the writer was only ever shown the piece that matched

  • To search a long passage properly it has to be divided into pieces. That works well for finding things. What it meant in practice is that when a piece was found, that piece alone was handed to the writer — a quarter of a paragraph, sometimes starting mid-sentence, with no way to see what came before or after it.
  • We measured how often that happens, on real material rather than examples we made up. Across two dozen genuine story ideas, more than a third of everything found was a piece of something longer — and every single one of them included at least one. So this was not an occasional thing; it was happening every time.
  • The surrounding text is now supplied alongside, clearly marked as context rather than as something that was found. The writer is told plainly: use it where it helps you understand the passage, and do not quote it on its own, because the search did not choose it.
  • And it is told something more important than that. If the fuller text shows a passage does not really say what it appeared to say on its own, it should leave that passage out altogether. Seeing the whole is what makes it possible to notice a piece was misleading — and leaving something out is better than quoting it out of context.
  • None of this comes at the cost of what was found. The context has its own separate allowance. Had we simply added it to the existing one, passages would have been quietly pushed out to make room — fewer real results, while everything appeared to be working normally. There is now a test that fails if that ever happens.
  • Where there is too much surrounding text to include, we say so. A passage might be one part of thirty-nine. We show what fits, take the parts nearest to the match first, and state how many are not shown — because a partial view that does not admit it is partial reads as the whole thing.
  • The allowance itself turned out to be counting only part of what it was allowing. Some of the material included alongside was not being charged against the limit at all, so the amount actually added was roughly twice what the limit said — and on the worst case it went past it. We caught this while building the thing that will tell us whether any of this was an improvement, and fixed it before release rather than writing the limit down as though it had been right.
  • We also found, while doing this, that an example we invented to test it argued the opposite. It suggested the problem barely existed. Real material showed otherwise. We have written that down, because we had already learned the same lesson pointing the other way.
  • Nothing to do at your end. This is behind the scenes, in how we prepare material for the writing tools.

Version 2.100.0

August 9, 2026

When we correct something in the material we hold, the correction now stays attached to it — and only the software can write one

  • The texts we hold were gathered at different times and by different methods, so some of them arrived with faults. A label saying the wrong language, a chapter that came through empty, a file arranged unlike the rest of its collection. When our tools spot one and correct it, that correction used to be mentioned once, in the record of that day’s work, and then effectively disappear.
  • Those findings now stay attached to the collection they are about. Open a collection and you can see what was wrong with it, how many of each kind, and several real examples — not just a number, because a number is not something you can form a judgement about.
  • Nobody can type one of these notes, and there is deliberately no way to. A note a person writes is an opinion about the material; a note the software writes as it makes a correction is a record of what it actually did. The two can never disagree, because the same pass produced both. That is the whole reason it is built this way, and it is why there is no form to fill in.
  • They also expire honestly. If we re-gather a collection and the fault has been fixed at source, the old notes go with the old material. A note that outlived the thing it described would be worse than no note at all — it would be a confident statement about something that is now fine.
  • “We have not looked” and “we looked and found nothing” are shown as different things. They are easy to collapse into one, and collapsing them would show a collection where most of the text is missing as though it were in perfect order. The screen says which it means.
  • We also found that a fix from earlier the same day was only half done. We had moved the list of language names into one place so nothing could fall behind — and two screens turned out to be quietly using their own older copy, showing raw codes where the third screen showed proper names. Both now use the shared one, and a new check fails if a private copy ever creeps back.
  • Nothing to do at your end. All of this is behind the scenes, in the tools we use to prepare what you read.

Version 2.99.0

August 9, 2026

A label saying which language a text is written in turned out to be wrong, and the text itself is what caught it

  • We are working through a large collection of classical Quran commentaries, teaching our system to read one arrangement at a time. This release adds the reading for a set of twenty-seven commentaries, each one written out verse by verse. Nothing has been added to the library yet — this is the part where we look at what would go in, and check it before anything does.
  • Each file states which language it is in, and for five of the twenty-seven that statement is false. Commentaries in Urdu, Kurdish and Russian all describe themselves as Bengali. Had we taken them at their word, they would have gone into the library under the wrong language, and nothing anywhere would have complained.
  • What settled it was reading the writing rather than the label. A Russian commentary is written in the Russian alphabet, and a Bengali one is not — so the text disagrees with its own description in a way that cannot be argued with. We now record what each one actually is, and keep a written note of every place the original said otherwise, because a correction nobody can see is indistinguishable from a text that never needed one.
  • We were also careful about what that check can and cannot prove. Several of these languages share an alphabet, so looking at the writing can show a label is wrong but can never confirm one is right. That limit is written into the check itself, so nobody later mistakes “we found nothing wrong” for “we confirmed it is right”.
  • The collection is named after one school of thought, and four of its works belong to another. We had been treating the name as a description of everything inside it. It is not, and it now says so — each work carries its own description rather than inheriting one from the box it arrived in. None of this material is quotable in anything we publish, either before or after the correction; the point is that what we record about it should be true.
  • Two things on the review screen were quietly showing less than the whole picture. It described the material with a single label where there were two, and it listed files it could not read but stopped after ten without saying there were more. Both were correct until this collection arrived and neither would have announced itself.
  • Nothing to do at your end. All of this is behind the scenes, in the tools we use to prepare what you read.

Version 2.98.0

August 9, 2026

Two of our own files had become unsearchable, and the only reason we found out was luck

  • A single invisible character can make a file vanish from our search tools. The file still works perfectly. It still passes every check we run. It simply stops appearing when anyone searches the project for a word that is plainly inside it. Two of our files had been in that state, one of them for months.
  • What makes it nasty is that everything else looks completely normal. When we compare a file against its previous version, that comparison usually flags the problem — but only if the stray character happens to sit near the top of the file. Further down, the comparison shows nothing at all. One of our two was the loud kind and was noticed the day it happened; the other was the quiet kind and was not.
  • So the honest conclusion was that our usual way of checking could never have found it. Almost everything we use to police our own standards works by searching the project — and a file that hides from search hides from all of them at once. That is the argument for a machine check rather than a note asking people to be careful.
  • There is now an automatic check that refuses the whole build if one appears. Both existing files are cleaned up, written a different way that behaves identically — and we confirmed it behaves identically rather than assuming it, by comparing the results before and after.
  • We made a point of proving the new check can actually fail. Including the difficult case: one planted deep inside a large file, where the usual comparison stays silent. A check that has only ever been seen to pass is not evidence of anything.
  • It slipped in four more times while we were fixing it. Twice into code, once into the notes describing the problem, and once into the check itself. Three of those were caught by chance. We have written that down, because it is the real measure of how easily this happens.
  • Nothing to do at your end. This is entirely in the tools we use to build the site.

Version 2.96.1

August 9, 2026

A settings page gave two different names to the same thing, because it was remembering an answer instead of working it out

  • One of our internal pages lists which AI model handles each kind of job. It shows four kinds of job, and every one of them is handled by the same model. Three of them named it correctly. The fourth named it differently — on the one page whose entire purpose is to tell you which model is in force.
  • The cause is a habit we keep catching ourselves in: storing something that ought to be worked out. Each entry kept its own written copy of the name, next to the reference that actually does the work. The reference stayed right. The copy had been saved before we changed how these names are formed, and nothing ever went back to correct it — because nobody edits an entry that already looks fine.
  • The name is now worked out from the reference every time it is shown, and never stored. Four entries cannot disagree about one model when none of them is quoting something it remembered. If we change the model tomorrow, all four follow on their own, with nobody having to remember anything.
  • The page had a note in it claiming this could not happen. It said all four entries always carry the same answer. That was true the day it was written and guaranteed by nothing at all, which is the more useful half of the lesson — so the note has been rewritten to say what now makes it true, rather than simply asserting it again.
  • We checked that the new test can actually fail. We deliberately broke the fix in two different ways and confirmed the tests went red both times. A test that has never been seen to fail is not evidence of anything.
  • Nothing to do at your end. This one is entirely behind the scenes, on the tools used to make what you read.

Version 2.96.0

August 8, 2026

Eight things that were quietly wrong with picture-making, and the four we broke while fixing them

  • Making the illustrations for a reflection or a story takes real time — minutes, sometimes half an hour. Until now, if you started one and then closed the tab, or your connection hiccuped, you were left with a greyed-out button and no explanation. Not an error. Just nothing.
  • There is now a panel that says what is being made, how far along it is, and roughly how long is left. Almost every piece of that already existed and simply was not shown anywhere — the tools had been quietly keeping notes that nothing ever read back.
  • Starting a second one while the first is still going used to be refused outright. The answer was to keep clicking. Now it waits its turn, tells you how many are ahead of it, and there is a page showing the whole queue with your own place marked.
  • “Cancel” did not cancel. There were two different cancel buttons and each did half the job — one told our records the work had stopped while the machine carried on making the picture, the other stopped the machine and left the records saying it was still running. They are now one thing, and cancelling tells you honestly what it managed to stop.
  • The estimate of how long a picture takes was wrong by up to eight times. It had been a guess from an older setup that nobody re-checked. We measured sixty-six real ones. This matters because that guess is what the new panel counts down, and a countdown that reaches zero eight times too early is worse than no countdown.
  • Story writing was giving up on our own equipment and quietly handing the work to an outside service. The time limit had been set at almost exactly how long the job normally takes, so roughly one story in eight ran a little long and got abandoned for no reason. Measured properly and given room.
  • A message in our logs had been confidently blaming the wrong thing. It said stories were failing because they had run out of room to write — while the numbers printed alongside it showed barely half the room used. Worse, the automatic retry believed it and asked for a shorter story, which is treatment for a condition it did not have.
  • Error notes stored alongside our records could contain internal details about our own setup. They are now cleaned before being saved rather than only when displayed — cleaning them on the way out leaves the original sitting there for whoever looks next.
  • Some work simply left no trace. Making a comic does several separate pieces of picture-making in one go, and only one of them was ever recorded — so the log could not say what had actually been done. Each step now records itself, linked to the run it belongs to.
  • Four of the problems in this release were ones we introduced while fixing the others. Every automatic check passed — the type checker, eighteen hundred tests, our own house rules — and all four were found by actually using the thing. One was a fix that could never once have worked: closing a record destroyed the very information needed to decide what to do about it.
  • And one of the original reports turned out to describe the wrong cause. It said a dropped connection killed the work. We tested it: cut the connection after one second, and the picture finished five minutes later regardless. The real problem was duller — the work simply never wrote down how far along it was, which is why it looked like nothing was happening.
  • Nothing to do at your end. This is all behind the scenes, on the tools used to make what you read.

Version 2.95.0

August 8, 2026

A field labelled “Arabic” turned out to hold Hebrew and Sanskrit, and we found it before anything was filed

  • We hold a large library of source texts that the site has never been able to read. They were gathered over years, from many places, and each collection is laid out differently — so “add them to the library” is not one job but a dozen, each needing someone to decide how the material should be described and cited. This release is the first of those, and it covers Jewish, Hindu and Sufi texts.
  • The thing that nearly went wrong is a good illustration of why these take a while. Every one of these files has a field named for Arabic. In the Jewish texts that field holds Hebrew. In the Hindu texts it holds Sanskrit. Filing them by the label would have recorded tens of thousands of passages as being in a language they are not — and nothing, anywhere, would have complained.
  • A name on a container is not a description of what is inside it. That is the third time this year the same lesson has arrived wearing different clothes, and we have written it down again in the place people actually read.
  • Our checking tool was wrong and the real code was right, which is not the usual order. A quick script reported two passages as being in the wrong language. They were not — they are English with a few Arabic words left in the middle, and the script had asked “does this contain any Arabic?” instead of “is this mostly Arabic?”. The proper code disagreed with it and was correct. Both of those real passages are now permanent test cases, so the sloppier reading cannot come back.
  • Writing the tests found a fault before the code had ever run. A piece of shared machinery was safe only because every previous user of it happened to pass it two different languages — a condition nobody had ever written down, because while it held there was nothing to say. Our new reader is the first that could break it. It now refuses loudly instead, naming the exact file and passage.
  • We chose not to invent a rule for a problem we have never seen. There is an obvious “just merge them” fix, and it needs a decision about which text wins. We measured every one of the hundred thousand passages: the situation does not occur. Guessing a rule for it would have shipped an untested policy protected by a test that agrees with it.
  • Where we do correct the source material, the correction records itself. These texts were gathered by us, so mistakes in them are ours to fix — but a silent fix is indistinguishable from nothing having been wrong. Corrections are now made and written down by the same step, so there is no way to have one without the other, and they are shown before anything is filed rather than after.
  • Then we opened the screen, and it told us four things that were wrong — none of which any automatic check had noticed. Everything had passed: the type checker, seventeen hundred tests, our own house-rules checker. All four were visible within seconds of looking.
  • The worst of them was a reassurance that was true only by luck. The screen promised that anything added this way could not be quoted in our published writing. For these three collections that happens to be right — but it was stated as a blanket fact rather than worked out, and the very next collection we plan to add is one that can be quoted. It would have told someone the opposite of the truth, calmly, with nothing going wrong anywhere. It now works the answer out from the same rule the rest of the system uses, and warns rather than reassures when the answer is yes.
  • Our own record of what language these texts are in was wrong for all three. The screen printed it, which is how we noticed. Fixed in the record itself, not just on the page.
  • Nothing has actually been added to the library yet, on purpose. Reading the material and filing it are deliberately separate, and the second one waits for a person to look at what the first one found.
  • Nothing to do at your end. This is groundwork for a much larger library behind the things we publish; nothing you can see has changed yet.

Version 2.94.3

August 8, 2026

We went looking for a missing piece of our own build process, and it was not missing — it was never needed

  • Some parts of this system we build ourselves. Others we take as they come from the people who make them, and simply configure. One of the second kind had every appearance of being the first, and we spent a session establishing that it was not.
  • Three leftovers each implied we build it, and every one of them was individually correct. A record of a job that used to run and no longer does, still sitting in a list. An old copy of the thing we used to build, kept on purpose in case we need to go back to it. And a note telling us how to delete that copy, which reads as though something still makes it. Together they are convincing, and expecting anyone to see through all three is not reasonable.
  • Nothing was broken. Our own notes were. They now say plainly that there is nothing to build here and why, in the place someone looking for the missing piece would actually land — along with the one-line check that answers the question in a second.
  • We got it wrong twice while checking, and both are worth admitting. Once by reading the first thirty lines of a much longer file and drawing a correct conclusion from insufficient evidence — right answer, wrong reason, which is the kind that collapses the moment anyone pushes. And once by misreading one of our own headings the wrong way round, which sent us down a false trail for a while.
  • That second one earned a fix of its own. The heading could honestly be read two ways and one of those ways is wrong, so it now says which it means. A label that only makes sense to whoever wrote it is a trap for everyone after them.
  • And the search turned up something genuinely worth having found. That part of the system has no automatic check that it is configured correctly — and last week it came up quietly doing the wrong job, caught only because we had deliberately built a check that can fail. We have written down what the missing safeguard should be, rather than leaving the gap to be rediscovered.
  • Nothing to do at your end. This is entirely our own record-keeping; nothing about the site changed.

Version 2.94.2

August 8, 2026

Our own release tool sat there saying nothing for forty minutes, and we could not tell waiting from stuck

  • Publishing an update to this site is a scripted process, and one of its steps waits for the new version to finish being prepared. Last week that wait ran out and gave up. Nothing was broken and the site was never touched — but the release stopped halfway and had to be restarted.
  • The interesting part is that it had not given up on something slow. It had given up on something that had not begun. Several pieces get prepared at once, and the one this step was waiting for was last in the line. So our time limit was not wrong about how long the work takes; it was wrong about when the work starts.
  • All we could see while it waited was a number counting up. That is indistinguishable from the tool having hung, which is the worst thing a long wait can look like.
  • It now tells you what it is waiting for — how many pieces are finished, how many are still going, and crucially the state of the particular one that has to finish before anything can be published. It also says all of that in the give-up message, which is exactly the moment somebody needs it.
  • Naming that one piece is the whole point, and this is the bit we would have got wrong. “Most of it is done” reads as nearly finished. “Most of it is done, and the one thing we are actually waiting for has not started” is the real situation — and both sentences are built from the same numbers.
  • Only then did we allow ourselves to extend the time limit. Raising it on its own would have traded a quick honest failure for a longer confusing wait, which is worse. We have written down that if the explanation is ever removed, the limit goes back.
  • We made sure the explanation cannot break the release. If it fails to fetch, the wait carries on with just the counter. Something whose job is to inform must never be able to stop the thing it is describing.
  • And we deliberately broke it to check it says anything at all. A progress message that prints something plausible no matter what is worse than none, because you would trust it. So we tested that two genuinely different situations produce two different messages — and that a piece which has failed is never quietly counted as finished.
  • Separately, we found a plan of ours resting on a problem we had already solved another way. A piece of infrastructure we had agreed to build was justified by a difficulty that no longer exists. There is still a good reason to build it — a different one — so we wrote the old reasoning down as history and the real reason beside it. A decision left standing on a reason that has expired looks sound right up until someone checks.
  • Nothing to do at your end. This is entirely in the tooling we use to publish; nothing about the site itself changed.

Version 2.94.1

August 8, 2026

The menu at the top of the page was written out twice, so adding something to it only ever reached half of you

  • The list of links at the top of this site existed in two separate places — one for wide screens and one for the menu you get on a phone. They happened to match, but nothing kept them matching.
  • So adding a new section reached the desktop menu and quietly missed the phone one. Nothing would have looked broken. The new item would simply not have been there for anyone on a phone, and the person who added it had no reason to look in the second place.
  • There is now one list that both read from. Adding something reaches both, or neither — which is the only arrangement that cannot go half-right.
  • One detail we were careful to keep. Some of those links go to pages on this site and some go to our other sites, and the two need to behave differently — the second kind opens in a new tab, and has to be told not to hand our page over to the site it opens. It would have been tidier to treat all of them the same way. It would also have been wrong, and wrong in a way that looks completely normal on screen, so we have written down why they are kept apart.
  • Checked on a real phone-sized screen rather than a shrunken window, which are not the same thing and have misled us before. All eleven items present, in the right order, nothing spilling off the side, and the new-tab behaviour confirmed on every outside link.
  • Separately, a settings file we deliberately keep as a fallback was at risk of being swept up as rubbish. It is the configuration for undoing a recent change to how our search works, kept in case we need to go back. Our tidy-up tools had no way of knowing it was wanted.
  • We marked it as wanted — and then established that this only half solves it, which is the part worth saying. The marking stops it being listed as clutter, but the most thorough of our clean-up commands would still delete it, because “marked as ignorable” is exactly what that command takes as permission. We proved that rather than assumed it. So the comfortable-looking signal is produced by the same thing that authorises the deletion — and we have written that on the file itself, because the next person to read it would reasonably assume otherwise.
  • Nothing to do at your end. The menu contains exactly what it did before; it is now impossible for the two versions of it to disagree.

Version 2.94.0

August 8, 2026

This page had not just filled up — we had already written past the end of it

  • These release notes get divided into separate pages periodically, because there is a size beyond which one page becomes slow to load. We have done it three times before, and each time we did it while there was still room to spare.
  • This time we had gone past the limit before noticing. The previous set of notes was written into a page that no longer had space for it. Nothing broke — but the check that tells us how full the page is only tells us when we run it, and we had not run it before writing.
  • Releases 2.84 to 2.92 have moved to a page of their own. This page keeps the newest ones, and every older page is listed in the release archive, linked at the foot.
  • Where we divided is worth a word, because two separate reasons happened to agree. We cut below the version currently published to the live site, so that nothing gets filed into the archive before it has had its turn on the front page. Cutting one higher would also have left this page completely empty, which breaks the marker showing which release is the newest. Those two reasons point the same way today and will not always — so we have written down which of them is the binding one.
  • Any link you have saved still works. A link to an older release is forwarded automatically to whichever page now holds it, and lands on the release itself rather than the top of that page. We check both in a real browser every time, because this particular failure is completely silent: nothing errors, you simply end up somewhere other than what you clicked for.
  • We also re-proved which of our two safety checks catches which mistake, rather than trusting what we had written down about it. Our own notes claim that one specific slip is caught by one check and invisible to the other. So we deliberately made that slip and watched: the first went red, the second passed happily. The note was right — but it is only worth something because we confirmed it rather than quoting it.
  • The reason one check cannot see it is that the same fact is worked out twice, from two different places. One derives it from the names of the pages, the other from the list the pages are built from. Make them disagree and each half still looks entirely correct on its own. Working the same fact out twice from two different starting points, so that each is blind to the other’s mistakes, is a pattern we are starting to reach for deliberately.
  • Nothing to do at your end. Older releases are one click away in the archive, and your saved links are unaffected.

Version 2.93.0

August 7, 2026

We can now see the whole library of source texts we hold — including the large part of it we cannot read yet, which is the honest bit

  • Until now, adding source material meant preparing a file by hand. Most of what we want is already in storage and has been for a while. The tools now list all of it, and say plainly what state each collection is in: ready, waiting for work, already added, or nothing there to add.
  • Most of it is waiting for work, and we decided to show that rather than hide it. Every collection was published by someone else, arranged their own way, so each one needs its own piece of reading written before it can be added — and that reading involves judgements about what the material is that a program cannot make. It would have been easy to ship a screen listing only the handful we can handle. A screen that shows the whole job, with the unfinished part marked, is what makes the rest of it plannable.
  • Nothing can be chosen yet, and there is deliberately no button pretending otherwise. A button that is always greyed out reads as something broken. It appears when there is something for it to do.
  • Two of the collections turn out to contain no writing at all. They are lists of web addresses and reference numbers pointing at material we do not hold a copy of. They are now marked as such permanently, so nobody spends a day writing the reading for them. We checked rather than assumed — and it mattered, because two other collections have a file with the same name that does contain real material.
  • Before deciding how a category of books is classified, you can now see which books are in it. Some of those decisions cover more than two thousand files, and there was no way to look at what you were deciding about at the moment of deciding.
  • One group of files is deliberately left off that list, and this is the interesting one. A few hundred of them arrived from the source damaged — their titles have every character in reverse order. Counting them the ordinary way would have produced a long, tidy-looking list of nearly two hundred “books” that are all the same fault repeated. The screen now says so, and will show you three of them so you can see the damage yourself instead of taking our word for it.
  • There is a new control for saying what a whole collection is — which is what decides whether our published writing may quote from it. It asks you to read five real passages from the collection first, chosen from throughout it rather than the opening pages, and to write down why. A count is the thing people agree to without reading; five actual excerpts is not.
  • We also corrected a note in our own records that this release proved wrong. We had written down that a particular set of damaged files was unreachable, and used that as the reason for postponing a repair. They were reachable all along. The postponement still stands for a different and better reason — but a decision resting on a false reason survives only until somebody checks it, and then the whole decision looks unsound.
  • We moved a piece of our own machinery to where it belongs, and it came back up doing the wrong job. A settings file left behind by the version we retired months ago was still sitting in the folder, and it quietly overrode the correct settings. Everything we checked beforehand passed — we had compared the instructions the machinery runs on and confirmed they were identical, which was true, and missed that the folder around them was not. The place that worked was the one with less configuration in it, which is the opposite of what instinct suggests; the first thing we nearly did was copy the leftover file across, which would have made it worse.
  • What caught it was a check we had already written to be able to fail. It tests itself first — deliberately feeding itself wrong answers to prove it notices — and only then tests the real thing. It reported that the machinery was serving something other than what it should. Without that, everything would have looked fine: it was running, it was responding, and it was answering the wrong questions.
  • And two parts of the same system had been tripping over each other every time they started. They begin together, and each was measuring how much room it had while the other was still taking room up. Both would fail, both would restart, and both would then succeed — so the end result looked like a normal start-up and only the logs disagreed. It has been doing that since it was built. They now start one after the other. An error you learn to ignore is one you will ignore on the night it matters.
  • One thing you will actually see: the two menus at the top of the page are now one. “Our Apps” and “Our Services” have become a single Apps and Services menu, with apps at the top and our other sites below a dividing line. It was two buttons for six destinations, and the top of the page is the most crowded part of it. Asked for by the team for a while; our fault it took this long.
  • Nothing to do at your end. Everything else here is in the editing tools.
← Back to Home