The Cornishman magazine is a magazine sent to members of the Gloucestershire Warwickshire Steam Railway (GWSR), a heritage railway in the Cotswolds. My granddad used to volunteer with the railway and still gives me a copy after he’s read it; these are my favourite parts from a recent issue.

This passage about Toddington, by Rose Phillips (page 22) reminded me of a similar incident described in False Starts, Near Misses and Dangerous Goods:

One autumn day, luckily not a running day, a call was received to help round up some sheep which had found their way into the station. No grass-cutting needed that week! But after the sheep had been safely removed, the incident prompt`ed a careful check of the fences.

Chris Bambridge’s account of “Construction & Maintenance” (page 23) caught my eye, because it names a railway feature that I often see, but didn’t know the name of.

We are also becoming proficient in making dagger boards for station canopies where these have rotted away. Painting the individual components takes several weeks and will when installed be food for a significant period of time. Several station canopies are to be addressed.

On page 29, I was fascinated by Pete Mason’s explanation of how locomotive 35006 was transported to another railway for a gala event:

One of the main risks of transporting a steam locomotive by road is the process of loading the loco onto the road transporter. As the loco rises up the ramp, the weight is transferred off some wheelsets and onto others, greatly exceeding the loads that the springs are designed for. To avoid damage, we insist that stop blocks are placed to limit the movement of the axleboxes so that the weight of the loco doesn’t cause the springs to move beyond their limit. This transfers the weight of the loco directly to the wheels, without the springs exceeding their design load. These blocks have to ben removed again as soon as the loco is unloaded so that the loco is once again sitting on its own suspension.

At Kidderminster, access to the site is very restricted and the loco was delivered the opposite way round to what was required. Once the loco and tender had been coupled together, the loco was shunted onto the turntable. The crew then used the manual handles to crank the loco round so that it faced the desired direction – the first time the loco had been on a turntable since the 1960s.

The news was not so good for locomotive 7903, which John Cruxon explained on page 30:

I am sure most volunteers and shareholders will have heard that 7903 has been withdrawn for overhaul following an unsuccessful boiler extension extension examination. [...]

To obtain that extension, the boiler had to undergo non-destructive testing of the firebox stays. These are the copper and steel rods, known as stays, that hold the inner copper firebox apart from the outer steel firebox. In normal service, when we wash out a boiler and test for broken stays, we tap them with a small hammer and listen for a clear ringing of "pinging" sound.

This test had been carried out and all stays appeared to be satisfactory. However, when the BES engineer carried out testing using electronic equipment, which sends a signal down each stay to confirm it is intact, five copper stays failed to register any indication, suggesting that they are broken.

This reminded me of the film Oh, Mr Porter! in which Will Hay plays a wheeltapper – using a hammer to test stays feels very similar.

[If the formatting of this post looks odd in your feed reader, visit the original article]

I use GitUp as my Git interface, and I was wondering why some of my text files were no longer showing a graphical diff in the interface.

I tried bisecting the files, thinking it might be some special characters that cause the file to be registering as a binary file, and discovered that 8,388,608 bytes is the magic number – it doesn’t produce diffs for files larger than that. Note that $\mathrm{8,388,608}=8\times 2^{20}$ – that is, 8MB.

A quick search shows other tools having bugs or edge cases at 8,388,608 bytes.

I’m not going to dive into the GitUp source code to work out what the issue is here; for now it’s enough to know I can fix my diffs by reducing the size of my source files.

[If the formatting of this post looks odd in your feed reader, visit the original article]

Here’s an interesting project that balances compact and human-readable JSON, automatically applying certain sensibilities that somebody might add if they were writing JSON by hand:

FracturedJson is a family of utilities that format JSON data in a way that’s easy for humans to read, but fairly compact. Arrays and objects are written on single lines, as long as they’re neither too long nor too complex. When several such lines are similar in structure, they’re written with fields aligned like a table. Long arrays are written with multiple items per line across multiple lines.

Here’s an example of the output it produces:

{
    "BasicObject"   : {
        "ModuleId"   : "armor",
        "Name"       : "",
        "Locations"  : [
            [11,  2], [11,  3], [11,  4], [11,  5], [11,  6], [11,  7], [11,  8], [11,  9],
            [11, 10], [11, 11], [11, 12], [11, 13], [11, 14], [ 1, 14], [ 1, 13], [ 1, 12],
            [ 1, 11], [ 1, 10], [ 1,  9], [ 1,  8], [ 1,  7], [ 1,  6], [ 1,  5], [ 1,  4],
            [ 1,  3], [ 1,  2], [ 4,  2], [ 5,  2], [ 6,  2], [ 7,  2], [ 8,  2], [ 8,  3],
            [ 7,  3], [ 6,  3], [ 5,  3], [ 4,  3], [ 0,  4], [ 0,  5], [ 0,  6], [ 0,  7],
            [ 0,  8], [12,  8], [12,  7], [12,  6], [12,  5], [12,  4]
        ],
        "Orientation": "Fore",
        "Seed"       : 272691529
    },
    "SimilarArrays" : {
        "Katherine": ["blue",       "lightblue", "black"       ],
        "Logan"    : ["yellow",     "blue",      "black", "red"],
        "Erik"     : ["red",        "purple"                   ],
        "Jean"     : ["lightgreen", "yellow",    "black"       ]
    },
    "SimilarObjects": [
        { "type": "turret",    "hp": 400, "loc": {"x": 47, "y":  -4}, "flags": "S"   },
        { "type": "assassin",  "hp":  80, "loc": {"x": 12, "y":   6}, "flags": "Q"   },
        { "type": "berserker", "hp": 150, "loc": {"x":  0, "y":   0}                 },
        { "type": "pittrap",              "loc": {"x": 10, "y": -14}, "flags": "S,I" }
    ]
}

I haven’t tried the code at all, but noting so I can find the project again.

There are implementations in several languages, including .NET, JavaScript, Rust, and Python. The Python libraries are thin wrappers around the .NET and Rust versions, or there’s a deprecated compact-json project that’s written in pure Python. It also reminds me of Tailscale’s HuJSON library, which lines up object keys in a similar way when you format your JSON.

For a while I’ve wanted something like this for javascript-data-files, and I had a brief attempt at it – but this is a much harder problem than I initially realised. I don’t want this behaviour enough to add a dependency, and it’s more complicated than I want to implement or maintain on my own (even if I vendor an existing project).

[If the formatting of this post looks odd in your feed reader, visit the original article]

One perennial source of bugs on this site is incorrect page widths on mobile devices: something isn’t wrapping or cropping properly, and it forces the whole page to be too wide.

For a long time I’ve been playing whack-a-mole with these bugs, but after writing about using Playwright, I realised I could write a regression test.

Here’s the approximate test I came up with. It creates a new browser context with a mobile screen size, opens the page I’m interested in, then runs some JavaScript on the page to measure the scroll width:

def test_page_is_right_size_on_narrow_screens(browser: Browser, base_url: str) -> None:
    """
    Check that on narrow screens, pages size to fit the screen.

    This is a regression test for issues I've had in the past where
    some wide element breaks the page when the window is narrower than it.
    """
    width = 350
    height = 650

    context = browser.new_context(viewport={"width": width, "height": height})

    page = context.new_page()
    page.goto(base_url + "/computers-and-code/")

    scroll_width = page.evaluate("document.body.scrollWidth")

    assert scroll_width == width

I don’t think I’d want to write a regression test for every CSS change, but it’s cool I can do it for this class of especially annoying bugs.

[If the formatting of this post looks odd in your feed reader, visit the original article]

Every morning, I wake up to a notification on my iPhone:

Alex’s AirPods Pro 2 are fully charged.

This is not a surprise. This is not news. This is something iOS could have worked out will always be the case, because I have a charging stand where I put my AirPods overnight. My AirPods are always fully charged when I wake up.

I have, on multiple occasions, searched the “Notifications” area of the iPhone Settings app to find where I can disable this notification, to no avail.

Today, I got a respite: I found an Apple Support document that explains where to configure charging notifications:

You can use your iPhone or iPad to […] notify you when charging is complete.

1. Put your AirPods in your ears, and make sure they’re connected to your iPhone or iPad.
2. On your iPhone or iPad, go to Settings, select your AirPods, then tap Battery.
3. Turn on Charging Notifications.

I have no idea why these aren’t also available in the Notifications settings, but I can finally stop these pointless messages.

[If the formatting of this post looks odd in your feed reader, visit the original article]

For local developemnt and testing of this site, I’ve started to run a Caddy server with my real config to be a better replica of my real setup. I wanted to start a Caddy server in my automated tests, and shut it down when I’m done.

Here’s the fixture I came up with:

from collections.abc import Iterator
import subprocess
from subprocess import PIPE
import time
import urllib.error
import urllib.request

import pytest


@pytest.fixture(scope="session")
def caddy_server_url() -> Iterator[str]:
    """
    Start an instance of Caddy running in the current directory, and
    return the base URL.
    """
    port = 5858
    cmd = ["caddy", "file-server", "--listen", f":{port}"]

    with subprocess.Popen(cmd, stdout=PIPE, stderr=PIPE) as proc:
        url = f"http://localhost:{port}/"

        # Wait for up to a second waiting for the server to start.
        #
        # If we get a ConnectionRefusedError, the server hasn't started yet.
        # If we get an HTTPError or a 200 OK, we've connected to the server
        # and it's serving HTTP traffic, so it's started.
        t0 = time.time()
        while time.time() - t0 < 1:
            try:
                urllib.request.urlopen(url)
            except urllib.error.HTTPError:
                break
            except urllib.error.URLError as exc:
                if exc.args and isinstance(exc.args[0], ConnectionRefusedError):
                    pass
                else:
                    raise
            else:
                break

        assert not proc.poll()

        yield url

        proc.terminate()
        proc.wait(timeout=1)

And here’s what a test looks like:

def test_can_start_web_server(caddy_server_url: str) -> None:
    """
    Fetch a page from the running web server.
    """
    resp = urllib.request.urlopen(caddy_server_url + "example.py")
    assert b"test_can_start_web_server" in resp.read()

The fixture starts a file server with subprocess, then polls until the server is available. On my Mac mini, Caddy takes ~0.01s to start – long enough I can’t start running tests immediately, fast enough that any fixed sleep would be inefficient (especially as it’ll be slower in CI).

At the end of the fixture, I call proc.terminate() and proc.wait() to clean everything up. The terminate() sends a SIGTERM; the wait() blocks until the child process terminates. The process shuts down quickly, but I do need to wait or I get warnings from pytest that I have an unterminated process.

The fixture is session-scoped so I only have to start/stop the server once across my test suite.

In my real codebase, this code is split across two functions – a function that starts the server, and a function that wraps it in a pytest fixture. I reuse the server function in my serve_site.py script, which runs a local development server for the site. I’m also pointing it at a Caddyfile with my site config, rather than running a bare file_server.

This is similar to Simon Willison’s recipe.

[If the formatting of this post looks odd in your feed reader, visit the original article]

Here’s a problem I’ve had several times recently: I have an array of JSON objects which have an array of string tags, and I want to filter for objects with matching tags. Sometimes the array of tags is null rather than an empty list.

Here’s an example:

[
  {"id": "square",    "tags": ["quadrilateral", "2d"]},
  {"id": "rectangle", "tags": ["quadrilateral", "2d"]},
  {"id": "triangle",  "tags": ["2d"]},
  {"id": "blob",      "tags": null},
  {"id": "tagless"}
]

(The field isn’t always called tags, but this general pattern is common.)

Here’s the jq filter I need:

jq '[ .[] | select(.tags | arrays and any(. == "quadrilateral")) ]'

whcih returns the following output:

[
  {
    "id": "square",
    "tags": [
      "quadrilateral",
      "2d"
    ]
  },
  {
    "id": "rectangle",
    "tags": [
      "quadrilateral",
      "2d"
    ]
  }
]

How it works

• .[] is the array value iterator, which iterates over the objects in the array.

• the select(…) function filters the array for matching objects.

• .tags is an object identifier-index; it looks up the "tags" key in the object.

• arrays is a built-in filter that filters for objects where .tags is an array, so it discards objects where tags is missing or null.

• the any(…) filter filters for tag arrays where one of the items is equal to "quadrilateral".

• the […] around the whole expression wraps the result in a new array. Skip them if you want one object per line.

Notably, I’m not using the contains(…) filter. Although it sounds useful, it can only test items of the same type – it can test if a string contains a substring, or if an array is a superset of another array, but it can’t test if an array contains a string.

[If the formatting of this post looks odd in your feed reader, visit the original article]

The other day, I pulled up Spotlight on my iPhone, and I saw a Siri Suggestion I didn’t recognise – it suggested HOME_GET_ME_HOME with Citymapper, which looks like a programmer’s variable name:

Maybe this is a variable name which has leaked, and there’s meant to be some more user-friendly text here – but the meaning is also pretty obvious to a non-programmer.

I did a bit of digging, and I found HOME_GET_ME_HOME as one of two Citymapper actions in the Shortcuts app, and it’s an action to “Get directions to your saved home in Citymapper”. You can use it in a shortcut – I imagine it might be useful for, say, a “leaving the office” shortcut which starts a playlist, texts your partner, and starts getting directions home.

More confusing is HOME_GET_ME_TO_WORK, an action to “Get directions to your saved work in Citymapper”.

(I’m running Citymapper 11.40.1; who knows if this will change in a future version.)

[If the formatting of this post looks odd in your feed reader, visit the original article]

Here’s a simple snippet that shows it returning a string attribute:

try:
    with open("greeting.txt", "x") as out_file:
        out_file.write("hello world!")
except FileExistsError as err:
    print(repr(err.filename))  # 'greeting.txt'

It’s not especially useful in this example because you already know the name of the file you’re writing – but I’ve found it useful with the download_image() function I wrote for chives.fetch.

The download_image() function takes a URL and an out prefix, looks at the Content-Type header of the response to decide the file extension, and returns the downloaded path. I don’t know what path it will use until I’ve got the server response.

The function won’t overwrite existing images, so it throws a FileExistsError exception if the image already exists. If I want to carry on anyway with the already-downloaded image, I can get the filename from the exception rather than re-calculating the filename or changing the API.

Here’s another example:

from chives.fetch import download_image
from pathlib import Path

try:
    out_path = download_image(
        url="https://alexwlchan.net/images/2026/470906.png",
        out_prefix=Path("example")
    )
    print(out_path)  # Path("example.png")
except FileExistsError as err:
    print(repr(err.filename))  # 'example.png'

The filename attribute comes from OSError, of which FileExistsError is a subclass.

[If the formatting of this post looks odd in your feed reader, visit the original article]

I saw some pictures of the red-lined bubble snail on Tumblr and I thought it might have been AI – but no, it’s a real thing! Here’s a photo from the Wikipedia article:

I’m fascinated by the iridescent blue, which looks like something out of sci-fi, and lets at least some light through. It’s blurry, but you can definitely see the shape and colour of the rocks beneath it.

For references, the Wikipedia article includes a link to an entry in the World Register of Marine Species (WoRMS), which includes the history of the taxonomic description, a map showing where it’s found, and a couple of photos of the shells.

The WoRMS entry also links to a digitised copy of an 1825 article in Annals of Philosophy. Here’s the relevant passage, a Latin description of the snail:

Bulla lineata. Testa ovato-oblonga, pellucida, densè spiraliter striata, alba; fasciis duabus spiralibus, et lineolis coccineis concentricis ornata; spira conic; apertura elongata, integer. β spira depressa, long, 2-3 unc.

A list and description of some species of Shells not taken notice of by Lamarck, Page 408, by John Edward Gray. Digitised by the Biodiversity Heritage Library.

The Google Translate translation is a pretty good match for the snail in the original picture:

Bulla lineata. Shell ovate-oblong, pellucid, densely spirally striated, white; adorned with two spiral bands and concentric scarlet lines; spiral conical; aperture elongate, entire. β spiral depressed, long, 2-3 in.

The word “pellucid” is new to me, the dictionary tells me it means “transparent” or “clear”. The etymology makes sense too; it comes from “per” (through) and “lucid” (light).

Given this was being described in 1825, these snails can’t live that deep in the ocean. I’ve heard of creatures with transparent skin which live in total darkness, where skin pigmentation is unnecessary because there’s no light to see by – this is the first I’ve heard of transparent skin on a creature which might experience sunlight.

Once again, nature is weirder than anything humans can imagine.

[If the formatting of this post looks odd in your feed reader, visit the original article]

I’ve been experimenting with Python HTTP libraries, and I ran into an unexpected error connecting to example.com:

>>> import certifi, ssl, urllib.request
>>> ssl_context = ssl.create_default_context(cafile=certifi.where())
>>> urllib.request.urlopen("https://example.com", context=ssl_context)
Traceback (most recent call last):
  […]
ssl.SSLCertVerificationError: [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: unable to get local issuer certificate (_ssl.c:1081)

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  […]
urllib.error.URLError: <urlopen error [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: unable to get local issuer certificate (_ssl.c:1081)>

I get similar errors if I use httpx or requests.

If you look up this error, the usual advice is to make sure you’re using certifi, you have the latest version installed, run Install Certificates.command, and so on. Everything looks fine on my system, and I can connect to other websites just fine:

>>> certifi.__version__
'2026.02.25'
>>> certifi.where()
'/tmp/tmp.ZzvjQtkeZT/.venv/lib/python3.14/site-packages/certifi/cacert.pem'
>>> urllib.request.urlopen("https://alexwlchan.net", context=ssl_context)
<http.client.HTTPResponse object at 0x1056722f0>

I can also open example.com in my web browser, but not in Python – what’s up?

A mistrusted certificate and Authority Information Access

I found a certifi issue filed by Clément Beaujoin which describes this exact issue:

As of February 14, 2026, many automated tests and features relying on example.com began failing with ssl.SSLCertVerificationError: [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: unable to get local issuer certificate (_ssl.c:1016).

This is caused by example.com (Cloudflare) transitioning to a new certificate chain that roots into AAA Certificate Services, which was officially distrusted by major certificate stores (including certifi) in early February 2026. Because Python’s requests/urllib3 does not support AIA (Authority Information Access) to fetch missing intermediates, the verification fails in environments with updated root stores, even though browsers (which support AIA) show the site as secure.

Alex Gaynor, one of the maintainers, explained this isn’t something certifi is going to change:

If example.com is not shipping the necessary intermediates, that’s a bug in their TLS serving configuration impacting all non-browser clients, not something we’re going to work around.

This explanation sounds right to me, but I wanted to understand more. Is there a way to print the certificate chain sent by the server, so I can see the missing intermediate and the AIA that tells my client where to fetch the missing intermediates? How could I have worked this out myself?

I tried running various openssl commands and Python scripts that were supposedly printing the certificate chain, but I don’t understand TLS well enough to really know what’s going on.

I was able to see that certifi no longer trusts AAA Certificate Services, and when. I tried older versions of certifi, and example.com loads with 2025.1.31 but not with 2025.4.26. Then I looked at the diff for 2025.4.26, and I can see a certificate with the same name being removed:

128-# Issuer: CN=AAA Certificate Services O=Comodo CA Limited
129-# Subject: CN=AAA Certificate Services O=Comodo CA Limited
130-# Label: "Comodo AAA Services root"
131-# Serial: 1

I also found a CPython issue where Authority Information Access is mentioned where the topic is discussed, and Alex explained that it’s unlikely to be added to Python:

No, and at this point [the issue] should probably be wontfix’d (IMO), as AIA chasing is relatively out of favor compared to intermediate preloading.

I still don’t really understand HTTPS or TLS certificates and I’m not sure how to fix this if I encounter another misconfigured website – but I only use example.com for testing, so for now I can just pick another website to test instead.

Why wasn’t this caught by my tests?

I use vcrpy to test my HTTP code, but it doesn’t do anything with TLS certificates, just unencrypted HTTP responses. I didn’t catch this until I tried regenerating my recorded cassettes, and discovered that the HTTPS certificate issues meant I could no longer do so.

Perhaps I need a procedure for regenerating vcrpy cassettes when I upgrade my dependencies, or on a fixed schedule?

[If the formatting of this post looks odd in your feed reader, visit the original article]

I type check most of my Python code with mypy --strict. This note describes some of the non-obvious type hints that I couldn’t easily find in documentation or Google searches.

pytest parameterised tests

import pytest
from _pytest.mark.structures import ParameterSet

params: list[ParameterSet] = [
    pytest.param("1", id="one"),
    pytest.param("2", id="two"),
    pytest.param("3", id="three"),
]

[If the formatting of this post looks odd in your feed reader, visit the original article]

If I’m running a command with lots of output, I can use head(1) to get the first few lines, or tail(1) to get the last few lines. What if I want to get some lines from the beginning and from the end, but truncate the middle?

In bash, I can use command grouping, which runs all the commands inside curly braces as a single unit. Here’s an example:

$ tailscale exit-node list | { head -n 3; echo ' […]'; tail -n 5; }

 IP                  HOSTNAME                         COUNTRY            CITY                   STATUS
 100.111.189.27      al-tia-wg-003.mullvad.ts.net     Albania            Tirana                 -
 […]
 100.93.242.75       ua-iev-wg-001.mullvad.ts.net     Ukraine            Kyiv                   -

# To view the complete list of exit nodes for a country, use `tailscale exit-node list --filter=` followed by the country name.
# To use an exit node, use `tailscale set --exit-node=` followed by the hostname or IP.
# To have Tailscale suggest an exit node, use `tailscale exit-node suggest`.

[If the formatting of this post looks odd in your feed reader, visit the original article]

One persistent issue I have when developing apps with Flask is that I’ll go through several rounds of iteration, run the app with the debug server, and at some point Safari will stop loading the app. If I try to load the app in Safari, I just get blank pages. Other browsers are fine, but Safari is broken until I restart it.

I hadn’t spotted the pattern, but today Brian explained what’s going on: the default port for the Flask dev server is port 5000, and my Mac is listening on port 5000 for AirPlay. If I run the dev server with the default port, at some point Safari connects to the AirPlay Server instead of my app, and then it starts receiving blank pages.

There are three workarounds:

1. Use a different port to run my Flask apps.

2. Set the FLASK_RUN_PORT in my shell config to override the default Flask port (h/t James).

3. Disable AirPlay Receiver in Settings: General > AirDrop & Handoff > AirPlay Receiver.

I’ve done (3), because I never need to AirPlay to my Macs.

This isn’t the first time I’ve had to disable a setting in the “AirDrop & Handoff” screen.

[If the formatting of this post looks odd in your feed reader, visit the original article]

I was reading the SQLite database queries in the Tailscale source code today, and tables are referred to inconsistently: the schema creates tables like CREATE TABLE main.TKAChonk, but then queries may use TKAChonk or main.TKAChonk. What’s the difference?

I asked about it in Slack, and Michael and Brad explained what’s going on: it’s possible to attach multiple databases in SQLite, and the main prefix tells SQLite to look in the main database. We only attach one database so the two references are equivalent, but in the past there used to be separate databases and it was useful to disambiguate.

Here’s the relevant part of the SQLite docs:

In SQLite, a database object (a table, index, trigger or view) is identified by the name of the object and the name of the database that it resides in. […]

If no database is specified as part of the object reference, then SQLite searches the main, temp and all attached databases for an object with a matching name. The temp database is searched first, followed by the main database, followed by all attached databases in the order that they were attached. […]

If a schema name is specified as part of an object reference, it must be either “main”, or “temp” or the schema-name of an attached database.

The temp database referred to here is a set of tables created using CREATE TEMP TABLE which are only visible to the database connection that created them.

Example

1. Create two databases which both have an IntID table, and store a different value in each:

   $ sqlite3 db1.sqlite 'CREATE TABLE IntID (id INTEGER);
                         INSERT INTO IntID (id) VALUES (100);'
   
   $ sqlite3 db2.sqlite 'CREATE TABLE IntID (id INTEGER);
                         INSERT INTO IntID (id) VALUES (200);'

2. Open one of the databases, attach the other, and then look up the identically-named tables:

   sqlite> ATTACH DATABASE 'db2.sqlite' as db2;
   sqlite> SELECT id FROM IntID;
   100
   sqlite> SELECT id FROM main.IntID;
   100
   sqlite> SELECT id FROM db2.IntID;
   200

   Observe that when I query a bare IntID, SQLite chooses the table from the main database.

3. Create a temporary table, insert a value, and query IntID again:

   sqlite> CREATE TEMP TABLE IntID (id INTEGER);
   sqlite> INSERT INTO temp.IntID VALUES (300);
   sqlite> SELECT id FROM IntID;
   300
   sqlite> SELECT id FROM main.IntID;
   100
   sqlite> SELECT id FROM temp.IntID;
   300

4. Try to read the temporary table from a different database connection, and observe that it fails:

   $ sqlite3 db1.sqlite 'SELECT id FROM temp.IntID;'
   Error: in prepare, no such table: temp.IntID

5. Create a table in the attached database, and observe it can be queried by the bare name, but doesn’t exist in the main database:

   sqlite> CREATE TABLE db2.NewID (id INTEGER);
   sqlite> INSERT INTO db2.NewID (id) VALUES (500);
   sqlite> SELECT id FROM NewID;
   500
   sqlite> SELECT id FROM main.NewID;
   Parse error: no such table: main.NewID
   sqlite> SELECT id FROM db2.NewID;
   500

[If the formatting of this post looks odd in your feed reader, visit the original article]

Here’s a neat trick that Percy showed me today: the file(1) command is able to recognise SQLite databases, and print some information about the structure of the database.

Here’s an example from my Mac:

$ file example.db
example.db: SQLite 3.x database, last written using SQLite version 3050004, file counter 89, database pages 4, cookie 0x2, schema 4, UTF-8, version-valid-for 89

These values are read from the database header, the first 100 bytes of the file which include information about the database. A couple of fields stood out to me:

• The SQLite version. This is an integer, specifically SQLITE_VERSION_NUMBER, which is a representation of the version number. In this example, 3050004 means the database was last written by SQLite 3.50.4.

• The file (change) counter counts changes to the database. If multiple processes are working in the same database, they can detect when another process made a change, and invalidate their page cache.

  I was surprised that this value was so low for our production databases at work (just 1196), but the SQLite docs explain that if you run your database in WAL mode – which we do – changes are tracked through the wal-index, and so the change counter might not be incremented. That must be happening in our databases.

• The (schema) cookie gets incremented whenever the database schema changes. I ran a quick example and I can see it increasing from 0x2 to 0x3 in my example database:

  $ file example.db
  example.db: SQLite 3.x database, last written using SQLite version 3050004, file counter 90, database pages 4, cookie 0x2, schema 4, UTF-8, version-valid-for 90
  
  $ sqlite3 example.db 'CREATE TABLE NewTable(x);'
  
  $ file example.db
  example.db: SQLite 3.x database, last written using SQLite version 3050004, file counter 91, database pages 5, cookie 0x3, schema 4, UTF-8, version-valid-for 91

  The field that file(1) labels as “schema” is the schema format number, and tracks the version of SQL formatting used in the database. As of 13 March 2026, schema format 4 is the highest possible value, and it has been since January 2006.

• The user version field is an integer for “applications to use however they want” which SQLite doesn’t read. I imagine this might be quite useful for storing, say, a schema version in an easily accessible location.

  You can set it using the user_version pragma, and then it appears in the file(1) output:

  $ sqlite3 example.db 'PRAGMA user_version = 42;'
  
  $ file example.db
  example.db: SQLite 3.x database, user version 42, last written using SQLite version 3050001, file counter 92, database pages 5, cookie 0x3, schema 4, UTF-8, version-valid-for 92

• The application ID is a field to identify the application that “owns” the database. Lots of applications use SQLite as their storage format, and they can record their ID in this field.

  There are well-known values in magic.txt in the SQLite repository. If you use one of these, file(1) adds the human-readable name to its output:

  $ sqlite3 example.db 'PRAGMA application_id = 0x0f055112;'
  
  $ file example.db
  example.db: SQLite 3.x database (Fossil checkout), last written using SQLite version 3050001, file counter 94, database pages 5, cookie 0x3, schema 4, UTF-8, version-valid-for 94

  If you use a different value, file(1) prints the literal value:

  $ sqlite3 example.db 'PRAGMA application_id = 0x42424242;'
  
  $ file example.db
  example.db: SQLite 3.x database, application id 1111638594, last written using SQLite version 3050001, file counter 95, database pages 5, cookie 0x3, schema 4, UTF-8, version-valid-for 95

  This lookup comes from a sql “magic” file which ships with file(1), embedding all the values from SQLite’s magic.txt and many more besides.

[If the formatting of this post looks odd in your feed reader, visit the original article]

One of the tools used by the Rust development team is Crater, a tool which can compile and test Rust crates en masse. It’s used to detect breaking changes in the compiler, by testing unreleased versions of the compiler with large amounts of Rust code written by lots of different people. That includes every crate published on crates.io, and at least some Rust projects on GitHub.

The existence of Crater speaks to the level of standardisation in Rust build tooling – most projects will use cargo build and cargo test. It would be impossible to do this for a language like Python, where there are lots of popular approaches and every project runs tests in a different way.

Earlier this week, Ed Page (who’s on the Cargo team) opened an issue in my randline project:

Test binary is looked up in unit tests which relies on internals of Cargo and will break with existing / upcoming features […]

This problem was identified by the following crater run: rust-lang/rust#149852

This issue almost certainly comes from my version of the assert_cmd crate – I’m several versions behind the latest.

I’m not rushing to fix this because I’m not working on randline right now, but I’m quite excited to realise some of my Rust is prominent enough to be featured in Crater runs.

[If the formatting of this post looks odd in your feed reader, visit the original article]

Earlier this week Apple announced a “new” Studio Display which is almost the same as the previous Studio Display, only gaining a better camera and Thunderbolt 5.

Jack Wellborn posted an image on Mastodon joking about the lack of new features – one of Apple’s marketing images overlaid with a blue “new” banner in the corner, which is how Apple’s online store used to highlight new products. The Accidental Tech Podcast used a similar image as their artwork and favicon for years, joking about the lack of updates to the Mac Pro.

I wanted to create a similar image with a “new” banner in the style of Liquid Glass, to make fun of the design problems in macOS Tahoe. Initially I tried creating it in Acorn, but I lack the graphical design skills to replicate the effect – I realised it would be easier to create the effect in code.

I opened Xcode on a Mac running macOS Tahoe and created a new Mac app. I added one of Apple’s marketing images to the Asset catalogue, then I modified the default SwiftUI view ContentView:

import SwiftUI

struct ContentView: View {
    var body: some View {
        VStack {
            Image("center_stage_hw_studio_display__f0h1yn012iie_large_2x")
                .imageScale(.small)
                .foregroundStyle(.tint)
                .overlay(alignment: .topTrailing) {
                    Text("NEW")
                        .font(.title)
                        .foregroundColor(.white)
                        .padding()
                        .frame(width:400, height:5)
                        .glassEffect(.clear, in: Rectangle())
                        .offset(x:150,y:-150)
                        .rotationEffect(.degrees(45))
                        .overlay(alignment: .bottom) {
                            Text("NEW")
                                .font(.system(size: 120))
                                .foregroundColor(.white)
                                .rotationEffect(.degrees(45))
                                .offset(x:-25, y:300)
                                .blur(radius: 1.5)
                                .opacity(0.7)
                        }
                }
                .clipped()
        }
        .padding()
    }
}

#Preview {
    ContentView()
}

I ran Xcode with two panes: my source code on the left, my preview on the right. That worked well for iterating the design, because I could tweak the source code and immediately see the effect.

Even with my limited SwiftUI experience, I know this isn’t very good – for example, I have two Text views, because I couldn’t make the first one work. (Specifically, I couldn’t make it work with glassEffect and rotationEffect – the text was rotated within a horizontal glass container.)

I also couldn’t get the banner to be a thin rectangle; I ended up drawing a large rectangle that clips out of the view (clipped()) and overlaps the entire corner. Let’s retcon that as an homage to the way Tahoe’s UI supposedly “gets out of your way”, but actually takes over even more of your screen.

Rubbish as this code is, it does the trick! And I discovered that Xcode has a menu item to export the SwiftUI Preview as an image: Editor > Canvas > Export Preview Screenshot. I was using Xcode 26; I imagine that menu item might move around in different versions.

Here’s what the output looks like:

I don’t expect to create more images like this, but it’s cool to know I could use Xcode to mock up UI or Liquid Glass quickly, and export my work as images.

[If the formatting of this post looks odd in your feed reader, visit the original article]

Earlier this week, I saw a photo of a road sign that caught my eye. The original image is a stock photo that I can’t reproduce without a license, but here’s a freely available alternative that shows the same sign:

I understood the sign immediately. The details differ from the signs I’m used to, but it’s recognisably a “men at work” sign meant to warn you about ongoing roadworks.

The man’s head is an oval or egg shape, which is a style I’d not seen before. I’m used to signs where the head is a perfect circle, or signs where the head is very distinct and stylised, like the Ampelmännchen seen at pedestrian crossings in Germany.

Writing this note, I realise there are road signs I’m familiar with that don’t have rounded heads, but I’d never noticed. For example, the UK’s “children crossing” sign is meant to depict a girl with a non-circular haircut, but I’d never noticed it before. (Although Margaret Calvert, the original designer, refreshed the design in 2016 to make the haircut more prominent. Perhaps that’s why I never noticed it.)

It took me a bit of searching, but I eventually learnt that the egg-shaped head in the original image is a design choice that goes back at least as far as the Soviet Union. Soviet road signs were specified by the GOST 10807-78 standard, released in 1980, and copies are available online.

This sign is entry 1.23 Дорожные работы (“men at work”). The same head shape appears in signs like 1.20 Пешеходный переход (“pedestrian crossing”) and 1.21 Дети (“children”).

I looked through the rest of the standard, and there are some other signs I enjoyed and would like to see when I’m driving: the adorable cow in 1.24 Перегон скота (“cattle drive”), the bugle in 3.26 Подача звукового сигнала запрещена (“sounding the horn is prohibited”), and the gently swaying tree in 6.11 Место отдыха (“resting place”).

These signs all look familiar even to non-Soviet drivers because of the Vienna Convention on Road Signs and Signals, which established international standards for road signs and images. The full text is available online, and Annex 3 includes symbols to be used on road signs. The detail was left to individual countries, but the broad shapes are meant to be consistent.

After the dissolution of the Soviet Union, road signs gradually diverged in the new countries. I found a cool website by Bartolomeo Mecánico, which collects photos of different road signs around the world, and there’s a page with examples of the men at work sign in former Soviet countries.

[If the formatting of this post looks odd in your feed reader, visit the original article]

We use golink a lot at work, and I wanted to add it to my personal tailnet.

I decided to run it from my home Mac mini, because it’s always running and golink is a very lightweight service. Writing this, it occurs to me I could have also run it on my Linux web server, which doesn’t have to restart for macOS updates, but it’s set up now.

These are some notes on how I set it up:

1. Clone the [golink repo] to my Mac.

   $ git clone git@github.com:tailscale/golink.git ~/repos/golink

2. Authenticate golink with my tailnet. I created an auth key for my tailnet which is tagged with tag:golink, then passed it as the TS_AUTH_KEY environment variable to start golink:

   $ TS_AUTHKEY="tskey-auth-<key>" go run ./cmd/golink -sqlitedb "/Volumes/Media (Speedwell)/golink.db"

   That starts an instance of golink that I could see at http://go/, but it would only last as long as my terminal session – I want it to be an always-running service.

3. Configure golink to start automatically. I created a macOS LaunchAgent by creating a file at ~/Library/LaunchAgents/net.alexwlchan.golinks.plist with the following contents:

   <?xml version="1.0" encoding="UTF-8"?>
   <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
   <plist version="1.0">
       <dict>
           <key>Label</key>
           <string>net.alexwlchan.golinks</string>
           <key>ProgramArguments</key>
           <array>
               <string>/usr/local/go/bin/go</string>
               <string>run</string>
               <string>./cmd/golink</string>
               <string>-sqlitedb</string>
               <string>/Volumes/Media (Speedwell)/golink.db</string>
           </array>
           <key>WorkingDirectory</key>
           <string>/Users/alexwlchan/repos/golink</string>
           <key>RunAtLoad</key>
           <true/>
           <key>StandardOutPath</key>
           <string>/Users/alexwlchan/Library/Logs/golinks.log</string>
           <key>StandardErrorPath</key>
           <string>/Users/alexwlchan/Library/Logs/golinks.log</string>
       </dict>
   </plist>

   I start the service by running:

   $ launchctl load ~/Library/LaunchAgents/net.alexwlchan.golinks.plist

   Now my golink service is running, and will be automatically started whenever I restart or log into my Mac.

   If I need to stop it, I run:

   $ launchctl unload ~/Library/LaunchAgents/net.alexwlchan.golinks.plist

   I can restart the service by running unload/load, for example if I’ve made changes to the LaunchAgent plist.

4. Allow my devices to see golink. I added a grant to my policy file which allows every device in my tailnet to look up http://go/ URLs:

   "grants": [
     …
     {
       "src": ["autogroup:member"],
       "dst": ["tag:golink"],
       "ip":  ["*"],
     },
   ]

   It’s also possible for me to control who’s allowed to edit links, but I’m the only user in my personal tailnet, so that’s a non-issue.

5. Add a policy file test to ensure I can reach golinks from my devices.

   "hosts": {
     "phaenna-mac-mini":     "100.76.19.1",
     "go":                   "100.107.83.99",
     …
   },
   
   "tests": [
     {
       "src":    "phaenna-mac-mini",
       "accept": ["go:80"],
     },
     …
   ],

   I populated the hosts field using the output of tailscale status.

(Disclaimer: At time of writing, I’m employed by Tailscale.)

[If the formatting of this post looks odd in your feed reader, visit the original article]

Here’s an interesting function from the Tailscale repos that Anton told me about in a code review last week: a function to write to a file atomically. This ensures you don’t get partially written data in the final file.

10import (
11	"fmt"
12	"os"
13	"path/filepath"
14	"runtime"
15)
16
17// WriteFile writes data to filename+some suffix, then renames it into filename.
18// The perm argument is ignored on Windows, but if the target filename already
19// exists then the target file's attributes and ACLs are preserved. If the target
20// filename already exists but is not a regular file, WriteFile returns an error.
21func WriteFile(filename string, data []byte, perm os.FileMode) (err error) {
22	fi, err := os.Stat(filename)
23	if err == nil && !fi.Mode().IsRegular() {
24		return fmt.Errorf("%s already exists and is not a regular file", filename)
25	}
26	f, err := os.CreateTemp(filepath.Dir(filename), filepath.Base(filename)+".tmp")
27	if err != nil {
28		return err
29	}
30	tmpName := f.Name()
31	defer func() {
32		if err != nil {
33			f.Close()
34			os.Remove(tmpName)
35		}
36	}()
37	if _, err := f.Write(data); err != nil {
38		return err
39	}
40	if runtime.GOOS != "windows" {
41		if err := f.Chmod(perm); err != nil {
42			return err
43		}
44	}
45	if err := f.Sync(); err != nil {
46		return err
47	}
48	if err := f.Close(); err != nil {
49		return err
50	}
51	return Rename(tmpName, filename)
52}

This is similar to code I’ve produced in other projects to do atomic file writes – write to a temporary file first, then do an atomic rename to the final destination.

The temporary file is created in the same directory as the target, to give the best chance of being able to do an atomic rename. You can’t do an atomic rename across filesystem boundaries; using the same directory ensures both files are on the same filesystem.

To handle concurrent writes, I normally insert a random UUID into the temporary filename, so different processes write to different tempfiles. This is handled automatically by Go’s os.CreateTemp function, which adds a random string to the end of the filename.

The Rename() function has different logic for Windows and non-Windows systems:

• On non-Windows, it uses os.Rename(). The Go documentation notes that “even within the same directory, on non-Unix platforms Rename is not an atomic operation”.
• On Windows, it makes a syscall to the ReplaceFileW function. A cursory Internet search is conflicted on whether this is a truly atomic rename, although concurs that it’s the best option on Windows.

[If the formatting of this post looks odd in your feed reader, visit the original article]

Here’s a jq snippet that prints the hostname and IP addresses of every device in my tailnet (or at least, every device my current machine can see):

$ tailscale status --json \
    | jq '[.Self] + [.Peer[]]
          | sort_by(.DNSName)
          | map({(.DNSName): (.TailscaleIPs)}) 
          | add'
{
  "phaenna-mac-mini.tailfa84dd.ts.net.": [
    "100.76.19.1",
    "fd7a:115c:a1e0::fb01:1301"
  ],
  …
}

How it works:

• [.Self] + [.Peer[]] combines the .Self object and .Peer array into a single array.
• sort_by(.DNSName) sorts the array based on the DNSName field.
• map({(.DNSName): (.TailscaleIPs)}) converts each entry in that array into a map where the DNSName is the key, and the TailscaleIPs array is the value. Now the output is an array of objects, each with a single key-value pair.
• add combines all those objects into a single object.

Here’s a variant that keys the map by MagicDNS name:

$ tailscale status --json \
    | jq '[.Self] + [.Peer[]]
          | sort_by(.DNSName)
          | map({(.DNSName | split(".")[0]): (.TailscaleIPs)}) 
          | add'
{
  "phaenna-mac-mini": [
    "100.76.19.1",
    "fd7a:115c:a1e0::fb01:1301"
  ],
  …
}

Another variant that just extracts the IPv4 address:

$ tailscale status --json \
    | jq '[.Self] + [.Peer[]]
          | sort_by(.DNSName)
          | map({(.DNSName | split(".")[0]): (.TailscaleIPs[0])}) 
          | add'
{
  "linode-vps": "100.98.193.6",
  "palaemon-macbook-air": "100.120.194.127",
  "phaenna-mac-mini": "100.76.19.1",
  …
}

I paste this directly into the hosts section of my policy file.

If you have Mullvad nodes in your Tailnet, you can filter them out of this map with:

$ tailscale status --json \
    | jq '[.Self] + [.Peer[]]
          | map(select(.Tags == null or (.Tags | contains(["tag:mullvad-exit-node"]) | not)))
          | sort_by(.DNSName)
          | map({(.DNSName | split(".")[0]): (.TailscaleIPs[0])}) 
          | add'
{
  "linode-vps": "100.98.193.6",
  "palaemon-macbook-air": "100.120.194.127",
  "phaenna-mac-mini": "100.76.19.1",
  …
}

Tested with Tailscale 1.95.104. Disclaimer: At time of writing, I’m employed by Tailscale.

[If the formatting of this post looks odd in your feed reader, visit the original article]

While writing my previous note, I noticed an unexpected prefix in the SQLite shell:

sqlite> CREATE TABLE KeyValuePairs (
(x1...>     Key   TEXT NOT NULL PRIMARY KEY,
(x1...>     Value TEXT NOT NULL
(x1...> );

What does that (x1 prefix mean? I couldn’t find any reference to it online, so I had to read the SQLite source code.

The relevant code is in shell.c.in. First I found the default prompts, and two variables where the main and continuation prompts are stored:

406/*
407** Prompt strings. Initialized in main. Settable with
408**   .prompt main continue
409*/
410#define PROMPT_LEN_MAX 128
411/* First line prompt.   default: "sqlite> " */
412static char mainPrompt[PROMPT_LEN_MAX];
413/* Continuation prompt. default: "   ...> " */
414static char continuePrompt[PROMPT_LEN_MAX];

Looking at where those variables get used leads to another interesting snippet, which names this feature as “dynamic continuation prompt”:

444/*
445** Optionally disable dynamic continuation prompt.
446** Unless disabled, the continuation prompt shows open SQL lexemes if any,
447** or open parentheses level if non-zero, or continuation prompt as set.
448** This facility interacts with the scanner and process_input() where the
449** below 5 macros are used.
450*/
451#ifdef SQLITE_OMIT_DYNAPROMPT
452# define CONTINUATION_PROMPT continuePrompt
⋮…
460#else
461# define CONTINUATION_PROMPT dynamicContinuePrompt()

And looking for the definition of that dynamicContinuePrompt function, I can see it updating a dynPrompt.dynamicPrompt variable with expressions like the (x1 I saw in my SQLite shell:

499/* Upon demand, derive the continuation prompt to display. */
500static char *dynamicContinuePrompt(void){
501  if( continuePrompt[0]==0
502      || (dynPrompt.zScannerAwaits==0 && dynPrompt.inParenLevel == 0) ){
503    return continuePrompt;
504  }else{
505    if( dynPrompt.zScannerAwaits ){
506      size_t ncp = strlen(continuePrompt);
507      size_t ndp = strlen(dynPrompt.zScannerAwaits);
508      if( ndp > ncp-3 ) return continuePrompt;
509      shell_strcpy(dynPrompt.dynamicPrompt, dynPrompt.zScannerAwaits);
510      while( ndp<3 ) dynPrompt.dynamicPrompt[ndp++] = ' ';
511      shell_strncpy(dynPrompt.dynamicPrompt+3, continuePrompt+3,
512              PROMPT_LEN_MAX-4);
513    }else{
514      if( dynPrompt.inParenLevel>9 ){
515        shell_strncpy(dynPrompt.dynamicPrompt, "(..", 4);
516      }else if( dynPrompt.inParenLevel<0 ){
517        shell_strncpy(dynPrompt.dynamicPrompt, ")x!", 4);
518      }else{
519        shell_strncpy(dynPrompt.dynamicPrompt, "(x.", 4);
520        dynPrompt.dynamicPrompt[2] = (char)('0'+dynPrompt.inParenLevel);
521      }
522      shell_strncpy(dynPrompt.dynamicPrompt+3, continuePrompt+3,
523                    PROMPT_LEN_MAX-4);
524    }
525  }
526  return dynPrompt.dynamicPrompt;
527}
528#endif /* !defined(SQLITE_OMIT_DYNAPROMPT) */

I don’t completely understand this function, but I think I get the general gist. The first branch is looking for “open SQL lexemes”, or unterminated strings, while the second branch is counting open parentheses. I can compare this to what I see in the SQLite shell:

• If you have between 1 to 9 unclosed parentheses, the prompt starts with (x and the number of unclosed parens:

  sqlite> (
  (x1...>
  sqlite> (((((((((
  (x9...>

• If you have 10 or more unclosed parentheses, the prompt starts with prints (..:

  sqlite> ((((((((((
  (x.....>

• If you have more closed parentheses than you've opened, the prompt starts with prints )x!:

  sqlite> )))
  )x!...>

If you’re in this state, I’m not sure if it's ever possible to get back to a valid SQL expression?

• If you have an unfinished string, square bracket, or multi-line comment, the prompt starts with the quote character you need to close the string:

  sqlite> SELECT '
  '  ...> hello world
  '  ...> '
  
  hello world
  
  sqlite> SELECT "
  "  ...> hello world
  "  ...> "
  
  hello world
  
  sqlite> [
  [  ...> 
  
  sqlite> /*
  /* ...> 
  

I wonder where this behaviour came from? It feels like the sort of thing that might have come from Lisp, which is famous for having lots of brackets and exactly where this sort of indicator might be useful, whereas I imagine writing a heavily nested expression in the SQLite shell interface is comparatively rare.

[If the formatting of this post looks odd in your feed reader, visit the original article]

Today I wanted to write a value to a SQLite database, and error if the database already had a conflicting value.

There are a variety of ways you could do this – I decided to read the current stored value and check it in Go – but I also discovered there’s a way you could do it in SQL alone using CREATE TRIGGER. I did this with SQLite, but it looks like this is supported by other SQL dialects, including PostgreSQL and MySQL.

Setup

Let’s create a table which we’ll use to store write-once values:

sqlite> CREATE TABLE KeyValuePairs (
   ...>     Key   TEXT NOT NULL PRIMARY KEY,
   ...>     Value TEXT NOT NULL
   ...> );

If I try to INSERT a duplicate key into this table, it fails:

sqlite> INSERT INTO KeyValuePairs (Key, Value)
   ...> VALUES ('Colour', 'Red');
sqlite> INSERT INTO KeyValuePairs (Key, Value)
   ...> VALUES ('Colour', 'Green');
Runtime error: UNIQUE constraint failed: WriteOnce.Key (19)

But I can overwrite an existing key with an INSERT OR REPLACE or UPDATE:

sqlite> INSERT OR REPLACE INTO KeyValuePairs (Key, Value)
   ...> VALUES ('Colour', 'Green');
sqlite> SELECT * FROM WriteOnce;
Parse error: no such table: WriteOnce
sqlite> SELECT * FROM KeyValuePairs;
Colour|Green

sqlite> UPDATE KeyValuePairs
   ...> SET Value = 'Blue'
   ...> WHERE Key = 'Colour';
sqlite> SELECT * FROM KeyValuePairs;
Colour|Blue

Adding triggers

Let’s suppose I want to prevent somebody from overwriting the Colour key with a different value.

I can use CREATE TRIGGER to create a trigger on my table – that is, an action that runs whenever I perform an INSERT, UPDATE or DELETE.

For the INSERT case, I look for an existing key-value pair, and check if the existing value matches the inserted value. If not, I call a special RAISE() function which aborts the transaction, and nothing is written:

sqlite> CREATE TRIGGER IF NOT EXISTS prevent_insert_overwrite_colour
   ...> BEFORE INSERT ON KeyValuePairs
   ...> FOR EACH ROW
   ...> WHEN NEW.Key = 'Colour'
   ...> AND EXISTS (SELECT 1 FROM KeyValuePairs WHERE Key = 'Colour')
   ...> BEGIN
   ...>     SELECT CASE
   ...>         WHEN (
   ...>             SELECT Value
   ...>             FROM KeyValuePairs
   ...>             WHERE Key = 'Colour'
   ...>         ) != New.Value
   ...>         THEN RAISE(ABORT, 'Error: Colour already exists with a different value.')
   ...>     END;
   ...> END;

For the UPDATE case, I can use the OLD reference to inspect the existing value in the table:

sqlite> CREATE TRIGGER IF NOT EXISTS prevent_update_overwrite_colour
   ...> BEFORE UPDATE ON KeyValuePairs
   ...> FOR EACH ROW
   ...> WHEN NEW.Key = 'Colour'
   ...> AND EXISTS (SELECT 1 FROM KeyValuePairs WHERE Key = 'Colour')
   ...> BEGIN
   ...>     SELECT CASE
   ...>         WHEN OLD.Value != New.Value
   ...>         THEN RAISE(ABORT, 'Error: Colour already exists with a different value.')
   ...>     END;
   ...> END;

With these two triggers in place, running an INSERT or UPDATE that matches the existing value is a no-op:

sqlite> INSERT OR REPLACE INTO KeyValuePairs (Key, Value)
   ...> VALUES ('Colour', 'Blue');
sqlite> UPDATE KeyValuePairs
   ...> SET Value = 'Blue'
   ...> WHERE Key = 'Colour';
sqlite> SELECT * FROM KeyValuePairs;

But trying to INSERT or UPDATE a conflicting value throws my custom error, and leaves the value as-is:

sqlite> INSERT OR REPLACE INTO KeyValuePairs (Key, Value)
   ...> VALUES ('Colour', 'Orange');
Runtime error: Error: Colour already exists with a different value. (19)
sqlite> UPDATE KeyValuePairs
   ...> SET Value = 'Purple'
   ...> WHERE Key = 'Colour';
Runtime error: Error: Colour already exists with a different value. (19)
sqlite> SELECT * FROM KeyValuePairs;
Colour|Blue

The projects I work on usually put this sort of logic in the application code, but it’s neat to see how this could be implemented in the database layer.

[If the formatting of this post looks odd in your feed reader, visit the original article]

I was reading some code which formatted dates using the format function from the date-fns-tz library. Here’s an example:

import { format } from "date-fns-tz"

/* formatDate returns the given date as a date string, with a 12-hour
 * timestamp and the timezone. Example: Jan 2, 2006 - 10:04 PM GMT. */
export function formatDate(date: Date): string {
  return format(date, "MMM d, y - p z")
}

If I tested the code in Chrome by changing the browser timezone, I could see it behaving correctly – the displayed time would change to match my current timezone.

I wanted to write an automated test to check this behaviour.

Option 1: Pass the timezone to format() in OptionsWithTZ

The format() function accepts an optional third argument options: OptionsWithTZ, which can include a timezone. If I allowed passing a timezone to formatDate(), I could pass it to format().

However, that would mean changing the function. This code didn’t have any existing tests, and I don’t like changing code at the same time I add tests – it’s too easy to introduce a change unexpectedly, and codify the wrong behaviour in your new tests.

I prefer to add tests that check the existing behaviour, merge them to main, and only then start changing the implementation.

Option 2: Mock the TZ environment variable

If you don’t give format() an explicit timezone, it guesses one based on your environment. In my Node tests, it was enough to mock the value of the TZ environment variable with different timezones, and watch the value change.

Here’s an example using vitest:

import { afterEach, describe, expect, it, vi } from "vitest"
import { formatDate } from "./dates"

describe("formatDate", () => {
  const d = new Date("2006-01-02T15:04:05-0700")
   
  const testCases: { tz: string, expected: string | Regexp }[] = [
    { tz: "America/Los_Angeles", expected: /Jan 2, 2006 - 2:04 PM (GMT-8|PST)/ },
    { tz: "Europe/London",       expected: "Jan 2, 2006 - 10:04 PM GMT"        },
    { tz: "Asia/Kolkata",        expected: "Jan 3, 2006 - 3:34 AM GMT+5:30"    },
    { tz: "Pacific/Auckland",    expected: "Jan 3, 2006 - 11:04 AM GMT+13"     },
  ]

  afterEach(() => vi.unstubAllEnvs())

  it.each(testCases)("formats date for $tz as $expected", ({ tz, expected }) => {
    vi.stubEnv("TZ", tz)
    expect(formatDate(d)).toMatch(expected)
  })
})

Notes:

• My example date is the reference time used for formatting dates in Go.
• The way timezones are displayed can vary across platforms, hence the Regexp. On my Mac, Los Angeles time is GMT-8, but in the Linux CI worker, it’s PST.
• I wonder if this test will break when the clocks change in one of the locations, but I think it will be fine. The UTC offset in those locations on that day isn’t going to change. I’ll update this note if the code breaks.

[If the formatting of this post looks odd in your feed reader, visit the original article]