Changelog — 2.282–2.306

Two build machines were missing from our own status page — and now the page cannot forget one

• What was wrong. When we added two more machines to the pool that builds and tests this site, every record we keep of the estate was updated except one: the status page our team watches. It kept reporting a smaller pool, perfectly green, for four days. Nothing was broken for visitors; the map was simply out of date, and a map that is out of date and confident is worse than no map.
• What changed. The two machines are on the page. More usefully, the list of machines is no longer something a person types into the page — it is derived from the same inventory everything else reads, and a check now fails the build if any machine in that inventory has neither a place on the page nor a written, dated reason for its absence. The same fix reached two other tools that had their own private copies of the list.
• One check got smarter rather than stricter. The health tile for those build machines used to insist they all be interchangeable. One of the new ones is deliberately reserved for building this site, so under the old test it would have shown as a problem forever — the kind of warning people learn to ignore. It now asks the only question that matters: is every kind of job we run served by at least one machine that is online?
• Nothing to do at your end. This is all behind the scenes.

Finding the right passage across the whole library at once

• Search by meaning, not by book. When one of us is quoting scripture in a dispatch, an event or a session, we can now describe what we are looking for — a theme, a phrase, a question — and every book in the site’s library is searched together. The results come back grouped by book, with the strongest passages first, and no single book is allowed to crowd the others out.
• Several passages at once. Tick as many as fit the piece, read the plain-English rendering drafted for each, and insert them together. Browsing a single book by chapter and verse is still there for a passage already known by its reference.
• A quiet warning when the Arabic and the English disagree. While drafting the plain-English rendering, the editor now flags a passage whose Arabic and English do not appear to be the same text, so it can be checked before it is published. Doing this showed that one of the library’s collections has its Arabic and English out of step in places; we are correcting it at the source.
• Nothing to do at your end.

Quoting scripture in a dispatch or an event, from the library

• Verses are picked, not typed. When one of us quotes the Qur’an or another text in a dispatch, an event or a session, the Arabic and the word-for-word English now come straight from the site’s own scripture library, and a plain-English rendering of the same meaning is drafted alongside — read and, where needed, corrected by a person before it is published. All three parts stay visibly separate on the page, as they always have.
• Nothing to do at your end.

A new page can no longer go missing from search engines by accident

• Nothing changes on the site. Twice, a page we published was left out of the list search engines use to find our pages — once for a fortnight, once for a whole release — and nothing told us. Now our own checks refuse to build the site if a public page is in neither that list nor a written-down list of deliberate exceptions, each with a date and a reason.
• The machine-readable versions are checked the same way. Every reflection, vignette, event, article, help page and dispatch has a plain-text version for AI assistants (add .md to the address); a check now walks the live site and proves they are actually being served, rather than assuming.
• Nothing to do at your end.

Events and sessions can be listened to as well

• A spoken version of every event and session. Each event page, and each session under it, now carries a listen button once its spoken version exists — the event’s description, and for a session its description and the verse it closes with. It is made when the page goes public and remade only when the words change, the same way dispatches work since the last release.
• Existing events catch up gradually. Older events and sessions get their spoken versions in batches over the coming days; a page without one simply shows no button yet.
• Nothing to do at your end.

Every dispatch gets its spoken version, without anyone remembering to make one

• A dispatch is read aloud the moment it is published. Until now the spoken version of a dispatch was something somebody had to remember to generate afterwards — and when the words were edited, to generate again. It now happens as part of publishing, and again only when the words actually change, so an edited typo does not cost a fresh recording.
• Older dispatches catch up. The ones written before this can have their spoken versions made in one go, and the listen button appears on each dispatch’s own page as before.
• The dispatches list page no longer has its own recording. It read out each dispatch’s summary and went stale every time a new one was sent; each piece carries its own now.
• Nothing to do at your end.

Dispatches show up in search

• Search finds dispatches now. Type a word from one — a phrase, a name, even a verse it quotes, in Arabic or in translation — and it appears in its own group alongside reflections, events and the rest. Drafts stay out of it until they are published.
• Nothing to do at your end.

Dispatches are written the way everything else is now

• Nothing moves for you. The two dispatches you may have been sent are at the same addresses, the links in those messages still land where they did, and their machine-readable versions are unchanged to the byte — we checked, rather than assumed.
• What changed is behind the scenes. Until now a dispatch was written into the site’s own code and shipped with a release. It is now written in the same place our events and reflections are, with the same formatting tools, and published when it is ready — so the next one does not have to wait for a release, and the home page always shows the latest.
• Verses keep their three parts. Where a dispatch quotes the Qur’an, you still see the Arabic, the word-for-word rendering and the contextual one, kept separate on purpose — that distinction is the point of the first dispatch, and the new tools were built around keeping it.
• Nothing to do at your end.

Event and session descriptions can carry formatting now

• Bold, lists, headings and links in event descriptions. The people who write up our events and sessions can now format the description — a bulleted programme, a heading for each part of the evening, a link to the place — and see exactly how it will look while they type. Existing descriptions look the same as before.
• Nothing heavier for you. The formatting is turned into the page on our side before it reaches you, so the event pages carry no extra code for it.
• A small tidy-up on the help pages. Every paragraph on those pages had been carrying a stray, meaningless attribute in its markup for months. Harmless, invisible, and now gone.
• Nothing to do at your end.

Fresh eyes on our code, every month

• Nothing changes on the site. From now on an independent reviewer — one that has never worked on this code — reads it once a month looking for security mistakes, and we answer every finding with evidence. The first pass found two things the people closest to the code had walked past for months. Both are being fixed.
• This release is the guide that reviewer reads first. Most of what it got wrong the first time was not knowing how a request reaches a page; now that is written down. It describes how things are arranged, and deliberately never says anything is safe — the whole point of an outside reader is that they do not share our assumptions.
• Nothing to do at your end.

Writing down what three green checks taught us

• Nothing changes on the site. This release is a page in our own working notes, recording a lesson from the daftar work: a check, the test that proves the check works, and a second check in a real browser all said a page was fine when it plainly was not — because all three were looking for the mistake we had imagined, and the real one was a different shape. We write these down so the next one costs less.
• Nothing to do at your end.

A second dispatch, and an honest IlmFlow page

• Dispatch Two is out. In Your Language, From the Start — the workshop where IlmFlow’s teaching material is written now speaks Farsi and Arabic, why that mattered, and what we got wrong on the way. It is on the home page and at /dispatches.
• The IlmFlow page tells the truth now. It used to describe a study workspace and offer a sign-in that led nowhere useful. It now says plainly what is coming and that there is nothing to sign up for yet — with a picture of where the student is.
• Small things. The dispatch on the home page shows its artwork. A dispatch can link to another. If you found the old IlmFlow sign-in and wondered why nothing happened — that was us, and it is gone.
• Nothing to do at your end.

Our own status page said the front door was down. It was not.

• A false alarm, for a day. The page we use to watch our own services showed the machine that routes every visitor to this site as offline. It was working perfectly — a change we made yesterday means it now politely refuses requests that do not say which site they want, and our check was one of those requests. It was being told no, correctly, and reading that as broken.
• The first fix would have changed nothing, and we caught that before shipping it. The obvious one-line change looked right, passed every check, and turned out to be silently ignored by the tool underneath. We only know because we tried it for real rather than trusting that it read correctly. The check now asks the same question a real visitor asks.
• Nothing to do at your end.

The website now has its own lane

• Nothing changes for you, but changes should reach you sooner. Yesterday we added machines to build the site. Today the site’s own work moved onto one of them exclusively, so it no longer waits behind much larger jobs that have nothing to do with it.
• We did this part last, on purpose. Done in the wrong order those jobs would not have failed — they would have waited forever, which is harder to notice than a failure. So the machine was built, checked, and watched under real load first.
• Nothing to do at your end.

Updates to the site should not wait behind unrelated work

• Nothing changes for you, but changes should reach you sooner. The machines that build and publish the site are shared with a lot of other work, some of it very large.
• A one-line fix to the website could end up queued behind it — not broken, just waiting, with nothing to say why. We have added two more build machines and given the website its own lane.
• Nothing to do at your end.

Watching the right thing, a month earlier

• Nothing changes for you. This is a screen only our team sees, and a warning light that goes with it.
• The obvious way to do this would have been wrong. The certificates that keep our sites secure renew themselves, automatically, about two-thirds of the way through their life. So watching the expiry date is far too late — by the time it looks close, the renewal has already been quietly failing for a month.
• So we watch the renewal instead. The certificate authority tells us when a renewal is due; if that moment passes and nothing happened, we hear about it straight away rather than four weeks later.
• And “we have no information” now shows as a problem, not a pass. If the thing that reports this stops running, the screen turns red and says so. A blank page used to look identical to a healthy one, and that is the failure we keep finding in our own tools.
• Nothing to do at your end.

Making yesterday’s fix hard to undo by accident

• Nothing changes for you. Yesterday we closed a gap where one leg of the journey to our sites wasn’t encrypted. Today we added a check that shouts if it ever quietly comes undone.
• The risk was a routine software update putting things back. Part of the fix relies on a piece of software we build ourselves. A normal update could replace it with the standard version, which looks perfectly healthy and only fails months later, when a certificate needs renewing. That is exactly the kind of fault nobody finds until it bites.
• One of our existing checks quietly became far more important. It watches whether our certificates are being renewed. Until yesterday, a missed renewal would have been hidden. Now it would take a site offline — so we have written that down beside the check, because the code didn’t change but the stakes did.
• Nothing to do at your end.

One leg of the journey wasn’t encrypted, and now it is

• Your connection to us was always encrypted. The next step wasn’t. Traffic reached the service that sits in front of our sites safely — and then travelled the last stretch to our own machines in the clear. Anything carried in a web address went with it, including the one-time sign-in links we email out.
• It is closed now, on every site we run. Each one presents its own certificate, and the whole path is encrypted end to end. Certificates renew themselves; we checked that the renewal is genuinely running rather than merely switched on.
• Our own checks had told us this was fine. Three separate ones, and all three were wrong in the same way — they read our configuration instead of making a real request and looking at what came back. A single real request found the problem immediately. We have written that lesson down where the next person will trip over it.
• We also fixed a smaller thing we found on the way. An address that doesn’t belong to any of our sites used to send browsers round in an endless loop instead of simply saying “not found”.
• Nothing to do at your end.

A note to ourselves, after looking in the wrong drawer

• Nothing changes for you at all. We keep a list of outstanding work for each project. One of our projects keeps its list somewhere else, and today somebody checked the empty drawer, found it empty, and concluded there was no list.
• There were a dozen items in it — including the two things that same person was about to propose building from scratch. We have written down where the list actually lives.
• Nothing to do at your end.

Our audio tools had been telling us the wrong thing about themselves

• Nothing changes for you, and nothing was broken. Before we transcribe a recording, one step cleans up background noise. It has been doing that perfectly well — but everything around it, including its own startup message, named the wrong version of the tool doing the work. It had been saying so for months.
• The awkward part is that the tool itself agreed with the mistake. We had written the wrong version down in three places; when we went to check, the underlying software printed the same wrong answer about itself. Four things agreed and not one of them had actually looked.
• So it now reports something it cannot get wrong. Instead of a name anybody could mistype, it reports a measurement taken from what is actually loaded in memory, and one of our checks now fails if that measurement changes without somebody saying so.
• Why we are telling you about a bug with no symptoms. We are about to build on this part of the system, and we would rather start from something we can prove than something everyone agreed about.
• Nothing to do at your end.

A security update to the software the site runs on

• Nothing you can see changes, and there is nothing you need to do.A serious flaw was published against the framework this site is built on, in the part that resizes images. We have updated to the version where it is fixed.
• We use that part, so updating was the only option here. On our other site we were able to switch the feature off entirely, because nothing there used it — two different answers to the same problem, and the difference is simply whether the thing was needed.
• The uncomfortable part is how we found it. We were installing something unrelated, and the tool that does the installing happened to print a security summary on its way past. Nothing we run asks that question on a schedule — so this was not missed through carelessness; it simply was never checked.
• That is the actual fix. A one-off update closes one hole. Asking the question regularly is what stops the next one sitting there unnoticed, and it is what we are putting in place now.
• Nothing to do at your end.

We wrote a safety check that could not have caught anything

• Nothing you can see has changed. This is about our own tooling, and we are writing it up because the lesson is a good one.
• We keep a list of the safety checks we run, and the list said it was complete. It was not. Several checks were missing from it — each one written, at some point, because something had gone wrong. A list that says it is complete and is not is worse than no list at all, because people trust it and stop looking.
• So we added an automatic check that the list is complete — and the first version of it could not fail. It looked for each check’s name anywhere in the document, and the very paragraph we had just written explaining what was missing happened to mention every one of them by name. It reported that everything was accounted for, over a list we already knew was wrong.
• What caught it was breaking it on purpose. We deleted an entry and ran the check again, expecting it to complain. It did not. That is the only reason we know it works now: a check you have only ever seen pass is not a check you have seen working. Fixing it immediately turned up one more thing missing from the list that the broken version had been hiding.
• Nothing to do at your end.

We now watch the part of our systems that sends you email

• Nothing you can see has changed. This is an internal monitoring page, added because of something that went wrong yesterday.
• The part of our systems that sends email stopped working for an evening, and nothing told us. The first we knew was an error in somebody’s browser. Every check we had was passing the whole time.
• The hard part was not adding a green light. It was deciding what “working” even means for something that sends mail — because the obvious answers were all true and all useless that evening. It now watches the things that actually determine whether a message arrives, and it can tell the difference between a real problem and one worth only a glance.
• And it goes amber on silence. A machine that has stopped working cannot tell you it has stopped working, so no news is treated as bad news rather than as good.

Nothing to do at your end.

Older release notes have moved to their own page

• This page was getting too long to load comfortably. Release notes from 2.265 to 2.281 now live on their own page, listed in the release archive alongside every earlier band.
• Every link to an older entry still works. If you have bookmarked or shared a link to a specific version, it will take you to the right entry on the right page — we checked every one of them, not a sample.
• We did this while it was still comfortable rather than after it hurt. Last time we let it run, the page grew to nearly twice the size it should have been and had to be split into two at once. There is now a check that tells us how much room is left every single time we build the site.

Nothing to do at your end.

A new technical write-up: when every check is green and nothing works

• “Every Check Was Green”. Over two days we found five separate faults in one small part of our systems. Not one of them showed up as a failure — every check we had was passing the entire time, because each was measuring something next to the problem rather than the problem itself.
• Why we publish these. They are notes for people who work with the same tools, written in the hope of saving somebody a difficult evening. You do not need to share our beliefs to find them useful, and we would rather you took what helps and left the rest.
• The part we found hardest to admit. When the first fault happened, the system wrote a full description of it and tried to send it to us. That message could not be delivered either. We found it two days later while fixing something else — a perfect account of the problem, written as it happened, that nobody could read.

Nothing to do at your end.

Each dispatch now has its own page, with artwork

• Dispatches has become a proper index. Announcements were all on one long page. Each now has its own page with its own artwork, so you can read one without scrolling past the others — and share a link that opens the piece you meant rather than the top of a list.
• Every link we have already sent still works. That mattered more than the tidiness. The link in the announcement email and the one on the home page were both sent before this change, so the old address still takes you to the right place — we chose not to use a redirect, because browsers remember those permanently and they are painful to undo.
• Each dispatch can be read aloud on its own. Previously the whole page was one recording. Now each piece has its own, and they are registered automatically — the old arrangement relied on somebody remembering, which is the sort of thing that quietly stops happening.
• A plain-text version for AI systems. Adding .md to a dispatch’s address gives a clean copy, as reflections and vignettes already do. The Qur’anic verses keep all three parts — the Arabic, the word-for-word rendering and the explanatory one — because collapsing them would hand a machine the very confusion the piece was written to undo.

Nothing to do at your end.