A picture is worth a thousand words, so here is the finished product:

This is an e-paper display, made by RevK, and sold on Tindie, which I have set up to show some useful stuff in my kitchen. To the extent that this post is a review, it’s a positive one: the display itself is of great quality, and the software running on the controller, while a little tricky to get to grips with, is flexible enough to serve all of my needs, with a fun side project to build along the way.

This project started when my partner asked whether I could put something together that would use the UK grid operator’s Carbon Intensity API to notify us (or her) when the grid was operating at its cleanest so we know when to run the washing machine or dishwasher. I spent a bit of time trying to figure out the Web Push API but never really got anywhere with it, and it got shelved until I saw various posts from RevK’s Mastodon about the e-paper devices he’d been working on and I decided that would be a fun way to show the data. I also thought it’d be useful to show the upcoming bin collections on it too, especially as I saw there was a built-in module to do that in the controller (but more on that later).

So $160 and 1 working day’s delivery later, I had the screen in my hands. The set-up experience was pretty smooth: once power is supplied by USB-C, the device hosts a WiFi network for you to connect to and then all configuration is done via a web interface it provides.

The web interface takes a bit of getting used to, and a lot of reference to the docs to figure out which substitution variables and size parameters go where, but eventually I had things laid out and looking like I wanted them to.

The next step was putting together a service¹ to bridge between the display and the Carbon Intensity API and council bin services so that it could display them. This amounts to providing some JSON endpoints which provide the necessary data. For the bins display, there’s a schema in the docs, but the carbon intensity display uses the $API substitution variable so that is up to me.

I wrote this service using Elixir’s Phoenix framework, and the source is available here. It’s nothing too complicated, but it’s the first “production” service I’ve built in Elixir. I reimplemented the logic for scraping Lancaster City Council from the excellent UKBinCollectionData repo. There’s also some caching so it doesn’t re-fetch the same info on every call to the endpoint when the bin collection dates aren’t going to change very often.

And it all works beautifully! I included a NixOS module in the flake for the service, so it was easy to deploy it to the Raspberry Pi sitting next to my WiFi router, and it’s been sitting there doing the job for a couple of months now.

A long time ago, I wrote a couple of posts about a maximally slow (but still non-pathological) sorting algorithm which I’d tried to port to Rust. It compiled fine, until I tried to write a test for it and it suddenly blew up a recursion limit when trying to compile it. Eventually I realised this was due to Rust’s usage of monomorphisation meaning that it couldn’t statically compile infinitely many different instances of the function each time we wanted a version for a more nested list type. I was somewhat happy with that explanation, but I was left a little confused about why Brent Yorgey’s Haskell implementation worked fine. I concluded:

So, there are two key questions: why was this not a problem for Haskell, and is there a way to get round it in Rust? At the moment, I don’t know! I hope to get some free time to investigate this at some point, and I’ll definitely write up whatever I find on here.

That day has, apparently, and by complete chance, finally come, when I stumbled upon the key phrase: “polymorphic recursion”. Wikipedia defines it as “a recursive parametrically polymorphic function where the type parameter changes with each recursive invocation made, instead of staying constant”. In the case of Worstsort, the generic type is changing with each call from T or a (in the Rust and Haskell respectively) to &mut [T] or [a]. It’s actually mentioned in Brent Yorgey’s original post in an aside that I must have glossed over at the time, or not thought of it as a set term with a particular technical meaning. But the other day, somewhere, I encountered a link to a StackOverflow question (I forget where now) asking about polymorphic recursion in Rust and the penny dropped that this is the name of the property that’s missing from Rust. It seems to be an issue that a few people have run into: there’s an issue that’s been open for a while asking for better error messages (possibly even including the term!) when the compiler detects it, and there is a steady stream of other issues being marked as duplicates of it.

My initial thoughts now I revisit this 6 years later is that there’s nothing intrinsic to Rust’s type system that would prevent this from being compiled, and it’s more an implementation artifact. However, it definitely feels against the spirit of Rust to wrap all the type information up somewhere behind indirection and let functions work on pointers to things. I wonder if it’d be possible to work around it at the programmer level somehow, although since it’d all have to be at run-time you’d be working entirely round the type checker. Another side project to look into at some point I suppose.

I’ve (finally) finished writing my my notes from the remainder of KubeCon; see my previous post for some background and initial thoughts. This is a lot later than I’d like, I was pretty tired after each day in the end and then life and other work has taken over a little bit since then. Hopefully it’s not all too murky to make sense of my notes. At least by now, the videos are up, so I can jog my memory as I go. I’ll add links to the recording of each talk, and also go back and do the same for my previous post.

This’ll be a pretty long one, as a paragraph or two for all the sessions I attended adds up fast. My general summary is sadly a bit removed from my feelings at the time, but I’ll do my best to remember my feelings at the time.

This is a fairly non-structured log of my thoughts and notes from attending KubeCon Europe 2025¹. I was lucky to be sponsored by work, so I made at least some attempt to get to talks and sessions which seemed relevant to that. Unfortunately getting to the ExCeL venue from Lancaster on the Wednesday morning meant that I missed the morning keynotes.

I wasn’t sure what to expect from the event really: it was the same week that I returned from a month of leave (my attendance had been arranged while I was away by a “do you want to go” text), and it’s by far the largest tech conference I’ve been to. So my preparation (going through the schedule and saving all the talks with a vaguely interesting title and/or abstract) was a bit limited, and I didn’t have as long as I’d have liked to consider what I really wanted to get out of it. The rough list of things I was keen to learn more about was:

• GitOps tooling around Flux, including secret management and the best way of managing both a production and staging cluster in a reasonably harmonious way
• The experience of other scientific institutions in using Kubernetes (for example some of the many talks on using GPUs in a cluster)
• Any other useful tools and knowledge I can pick up
• Having a go at the CTF as I’ve never taken part in one before

I was less interested in some of the talks about scaling Kubernetes to huge deployments, as all the stuff we run is fairly small-scale, and didn’t really have much time for the LLM/AI stuff that filled up a huge portion of the schedule. It’s probably going to be pretty unavoidable throughout the event though.

The rest of this post consists of mildly edited thoughts from my handwritten notes taken during the sessions I was in.

This is the third post in an impromptu series:

1. Use a scratch branch in git
2. More on git scratch branches: using stgit

It seems the main topic of this blog is now git scratch branches and ways to manage them, although the main prompt for this one is discovering someone else had exactly the same idea, as I found from a blog post extolling Jujutsu.

I don’t have much to add to the posts from qword and Sandy, beyond the fact that Jujutsu really is the perfect tool to make this workflow straightforward. The default change selection logic in jj rebase means that 9 times out of 10 it’s enough just to run jj rebase -d master to get everything up to date with the master branch, and the Jujutsu workflow as a whole really is a great experience.

So go forth, use Jujutsu to manage your dev branch, and hopefully I’ll never have to write another post on this, and you can have the traditional “I rewrote my blogging engine from scratch again” post that I’ve been owing for a month or two now.

I wrote a short post last year about a useful workflow for preserving temporary changes in git by using a scratch branch. Since then, I’ve come across stgit, which can be used in much the same way, but with a few little bells and whistles on top.

Let’s run through a quick example to show how it works. Let’s say I want to play around with the cool new programming language Zig and I want to build the compiler myself. The first step is to grab a source code checkout:

$ git clone https://github.com/ziglang/zig
        Cloning into 'zig'...
        remote: Enumerating objects: 123298, done.
        remote: Counting objects: 100% (938/938), done.
        remote: Compressing objects: 100% (445/445), done.
        remote: Total 123298 (delta 594), reused 768 (delta 492), pack-reused 122360
        Receiving objects: 100% (123298/123298), 111.79 MiB | 6.10 MiB/s, done.
        Resolving deltas: 100% (91169/91169), done.
        $ cd zig
        

Now, according to the instructions we’ll need to have CMake, GCC or clang and the LLVM development libraries to build the Zig compiler. On NixOS it’s usual to avoid installing things like this system-wide but instead use a file called shell.nix to specify your project-specific dependencies. So here’s the one ready for Zig (don’t worry if you don’t understand the Nix code, it’s the stgit workflow I really want to show off):

$ cat > shell.nix << EOF
        { pkgs ? import <nixpkgs> {} }:
        pkgs.mkShell {
          buildInputs = [ pkgs.cmake ] ++ (with pkgs.llvmPackages_12; [ clang-unwrapped llvm lld ]);
        }
        EOF
        $ nix-shell
        

Now we’re in a shell with all the build dependencies, and we can go ahead with the mkdir build && cd build && cmake .. && make install steps from the Zig build instructions¹.

But now what do we do with that shell.nix file?

$ git status
        On branch master
        Your branch is up to date with 'origin/master'.
        
        Untracked files:
          (use "git add <file>..." to include in what will be committed)
                shell.nix
        
        nothing added to commit but untracked files present (use "git add" to track)
        

We don’t really want to add it to the permanent git history, since it’s just a temporary file that is only useful to us. But the other options of just leaving it there untracked or adding it to .git/info/exclude are unsatisfactory as well: before I started using scratch branches and stgit, I often accidentally deleted my shell.nix files which were sometimes quite annoying to have to recreate when I needed to pin specific dependency versions and so on.

But now we can use stgit to take care of it!

$ stg init # stgit needs to store some metadata about the branch
        $ stg new -m 'add nix config'
        Now at patch "add-nix-config"
        $ stg add shell.nix
        $ stg refresh
        Now at patch "add-nix-config"
        

This little dance creates a new commit adding our shell.nix managed by stgit. You can stg pop it to unapply, stg push² to reapply, and stg pull to do a git pull and reapply the patch back on top. The main stgit documentation is helpful to explain all the possible operations.

This solves all our problems! We have basically recreated the scratch branch from before, but now we have pre-made tools to apply, un-apply and generally play around with it. The only problem is that it’s really easy to accidentally push your changes back to the upstream branch.

Let’s have another example. Say I’m sold on the stgit workflow, I have a patch at the bottom of my stack adding some local build tweaks and, on top of that, a patch that I’ve just finished working on that I want to push upstream.

$ cd /some/other/project
        $ stg series # show all my patches
        + add-nix-config
        > fix-that-bug
        

Now I can use stg commit to turn my stgit patch into a real immutable git commit that stgit isn’t going to mess around with any more:

$ stg commit fix-that-bug
        Popped fix-that-bug -- add-nix-config
        Pushing patch "fix-that-bug" ... done
        Committed 1 patch
        Pushing patch "add-nix-config ... done
        Now at patch "add-nix-config"
        

And now what we should do before git pushing is stg pop -a to make sure that we don’t push add-nix-config or any other local stgit patches upstream. Sadly it’s all too easy to forget that, and since stgit updates the current branch to point at the current patch, just doing git push here will include the commit representing the add-nix-config patch.

The way to prevent this is through git’s hook system. Save this as pre-push³ (make sure it’s executable):

#!/bin/bash
        # An example hook script to verify what is about to be pushed.  Called by "git
        # push" after it has checked the remote status, but before anything has been
        # pushed.  If this script exits with a non-zero status nothing will be pushed.
        #
        # This hook is called with the following parameters:
        #
        # $1 -- Name of the remote to which the push is being done
        # $2 -- URL to which the push is being done
        #
        # If pushing without using a named remote those arguments will be equal.
        #
        # Information about the commits which are being pushed is supplied as lines to
        # the standard input in the form:
        #
        #   <local ref> <local sha1> <remote ref> <remote sha1>
        
        remote="$1"
        url="$2"
        
        z40=0000000000000000000000000000000000000000
        
        while read local_ref local_sha remote_ref remote_sha
        do
            if [ "$local_sha" = $z40 ]
            then
                # Handle delete
                :
            else
                # verify we are on a stgit-controlled branch
                git show-ref --verify --quiet "${local_ref}.stgit" || continue
                if [ $(stg series --count --applied) -gt 0 ]
                then
                    echo >&2 "Unapplied stgit patch found, not pushing"
                    exit 1
                fi
            fi
        done
        
        exit 0
        

Now we can’t accidentally⁴ shoot ourselves in the foot:

$ git push
        Unapplied stgit patch found, not pushing
        error: failed to push some refs to <remote>
        

Happy stacking!

I’ve been using NixOS for about a month now, and one of my favourite aspects is using lorri and direnv to avoid cluttering up my user or system environments with packages I only need for one specific project. However, they don’t work quite as well when you need access to a service like PostgreSQL, since all they can do is install packages to an isolated environment, not run a whole RDBMS in the background.

For that, I have found using nixos-container works very well. It’s documented in the NixOS manual. We’ll be using it in ‘imperative mode’, since editing the system configuration is the exact thing we don’t want to do. You will need sudo/root access to start containers, and I’ll assume you have lorri and direnv set up (e.g. via services.lorri.enable = true in your home-manager config).

We’ll make a directory to work in, and get started in the standard lorri way:

$ mkdir foo && cd foo
        $ lorri init
        Jul 11 21:23:48.117 INFO wrote file, path: ./shell.nix
        Jul 11 21:23:48.117 INFO wrote file, path: ./.envrc
        Jul 11 21:23:48.117 INFO done
        direnv: error /home/josh/c/foo/.envrc is blocked. Run `direnv allow` to approve its content
        $ direnv allow .
        Jul 11 21:24:10.826 INFO lorri has not completed an evaluation for this project yet, expr: /home/josh/c/foo/shell.nix
        direnv: export +IN_NIX_SHELL
        

Now we can edit our shell.nix to install PostgreSQL to access it as a client:

# shell.nix
        { pkgs ? import <nixpkgs> {} }:
        
        pkgs.mkShell {
          buildInputs = [
            pkgs.postgresql
          ];
        }
        

Save that and lorri will start installing it in the background.

Now, we can define our container, by providing its configuration in a file. I have called it container.nix, but I don’t think there’s a standard name for it like there is for shell.nix. Here it is:

# container.nix
        { pkgs, ... }:
        
        {
          system.stateVersion = "20.09";
        
          networking.firewall.allowedTCPPorts = [ 5432 ];
        
          services.postgresql = {
            enable = true;
            enableTCPIP = true;
            extraPlugins = with pkgs.postgresql.pkgs; [ postgis ];
            authentication = "host all all 10.233.0.0/16 trust";
        
            ensureDatabases = [ "foo" ];
            ensureUsers = [{
              name = "foo";
              ensurePermissions."DATABASE foo" = "ALL PRIVILEGES";
            }];
          };
        }
        

It’s important to make sure the firewall opens the port so that we can actually access PostgreSQL, and I’ve also installed the postgis extension for geospatial tools. The authentication line means that any user on any container can authenticate as any user with no checking: fine for development purposes, but obviously be careful not to expose this to the internet! Finally, we set up a user and a database to do our work in.

Now, we can actually create and start the container using the nixos-container tool itself. This is the only step that requires admin rights.

$ sudo nixos-container create foo --config-file container.nix
        $ sudo nixos-container start foo
        

By now, lorri should have finished installing PostgreSQL into your local environment, so once nixos-container has finished running, you should be able to access the new database inside the container:

$ psql -U foo -h $(nixos-container show-ip foo) foo
        psql (11.8)
        Type "help" for help.
        
        foo=> \l
                                          List of databases
           Name    |  Owner   | Encoding |   Collate   |    Ctype    |   Access privileges
        -----------+----------+----------+-------------+-------------+-----------------------
         foo       | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =Tc/postgres         +
                   |          |          |             |             | postgres=CTc/postgres+
                   |          |          |             |             | foo=CTc/postgres
         postgres  | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 |
         template0 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
                   |          |          |             |             | postgres=CTc/postgres
         template1 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
                   |          |          |             |             | postgres=CTc/postgres
        (4 rows)
        

And there we go! We have a container that we can access from the command line, or from an app, and we didn’t need to install PostgreSQL globally. We can even have multiple containers like this for different projects, and they’ll all use the same Nix store for binaries but have completely isolated working environments.

The nixos-container tool itself is a fairly thin wrapper around systemd (the containers themselves work via systemd-nspawn). The containers won’t auto-start, and you have to use systemctl to make that happen:

$ sudo systemctl enable container@foo.service
        

As a final flourish, we can save having to type in the user, host IP and database with very little effort, since we’re already using direnv and most tools can take their PostgreSQL configuration from some standard environment variables. We just have to add them to our .envrc file, and then re-allow it.

$ cat .envrc
        PGHOST=$(nixos-container show-ip foo)
        PGUSER=foo
        PGDATABASE=foo
        export PGHOST PGUSER PGDATABASE
        
        eval "$(lorri direnv)"
        $ direnv allow .
        $ psql
        psql (11.8)
        Type "help" for help.
        
        foo=>
        

git is the de facto standard for version control in 2020, and has held that position for some time. However, it holds a reputation of being difficult to use, and its toolkit-based design leaves a huge amount of room for different workflows. Here’s one that I’ve found useful recently:

git checkout -b scratch
        

That’s it! Well, to begin with at least. You’ll probably have to rebase it whenever you pull. But what is this branch for? It’s a general staging area, like a souped up git stash. Stashes are easy to create and apply, but they are also easy to lose and hard to share between computers. With a scratch branch, you can create as many staging commits as you want and push them to other computers if you need to. And once something’s been committed into git, it’s very very hard to lose it unless you are trying to.

What’s this useful for? I had to apply a few tweaks to a work project’s build system to get it to build on NixOS, and I’m not sure if they are more generally applicable. But I want to keep them around for my personal use, so into my scratch branch they go. If later on I want to share them with my co-workers, I can just git rebase -i to tidy them up a bit, merge them into the main branch and push. Or I can just leave them there forever. It doesn’t matter!

Stuff that’s only relevant to your own idiosyncratic setup shouldn’t be left sitting there uncommitted, at risk of causing merge conflicts or accidentally being squashed by a checkout: put it safely into your scratch branch and you can keep track of it with the full power of git as you need to. You can even have multiple scratch branches! Lightweight branches¹ are one of git’s most revolutionary features, and it’s easy to forget that you can use them in such a way.

This blog is now automatically deployed by pushing to its source repository at sourcehut! Here are the steps I took to convert it from a manual rsync to a job run by builds.sr.ht after each push to its git repository.

The first step is to create an SSH key so that the build service can access the filesystem on the VPS hosting my blog. Obviously we can’t use a passphrase since we need it to connect without any human intervention. Easy enough with the usual command:

desktop $ ssh-keygen -t ed25519 -f srht
        

Then to the secrets page on sourcehut and upload the content of the srht file (NOT srht.pub) as a new secret with the type ‘SSH Key’ and a reasonable description. We’ll need to make a note of the UUID that got assigned; for me, it was 2959238e-ea6f-4276-9441-cdc71b933f73.

The next step is to set up the user that we will connect as from the sourcehut builds service. We’ll also need to make sure the ownership and permissions on the webroot are properly set up.

server # WEBROOT=/srv/inv.alid.pw
        server # adduser --system srht
        server # chsh -s /bin/sh srht
        server # chown -R srht:adm "$WEBROOT"
        server # chmod -R ug=rwX,o=rX "$WEBROOT"
        server # find $WEBROOT -type d -exec g+s {} +
        

I like to have files like this writable by an admin group so that I can delete stuff without having to be root myself, and the last command sets the setgid bit on all the directories so that newly-created files continue to belong to that group. That’s personal preference though: in the end, as long as the srht user can write there (and nowhere else) then everything should work just fine.

We’ll also need to authorise the SSH key we generated to log in as the srht user, and we can restrict it to only run rsync at the same time. Take the content of the srht.pub file we generated earlier, and add it to ~srht/.ssh/authorized_keys, along with the options to lock it down to rsync:

restrict,command="rrsync /srv/inv.alid.pw" ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIH4E9kTv92l1NY1DgqXTnkHJWglVW+Laz6mQELviXzGI srht deployment
        

rrsync is not a typo: it’s a script that comes with the rsync package (in Ubuntu, it’s installed to /usr/share/doc/rsync/scripts/rrsync.gz, so you’ll have to decompress it and copy it somewhere that shows up in the srht user’s PATH) that means logging in with the given SSH key can only run rsync in the specified directory.

And that’s it for the server-side configuration! Now, we just have to fill in the .build.yml file to tell the sourcehut builders how to do all the deployment. Here it is, all in one go:

image: archlinux
        packages:
          - stack
          - rsync
        sources:
          - https://git.sr.ht/~jshholland/inv.alid.pw
        environment:
          user: srht
          webhost: procyon.chrys.alid.pw
          hostkey: ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIKemAh9xHg0lQBhwzVp9UemuSgaDqVC5Mwa+CmnXijP8
        secrets:
          - 2959238e-ea6f-4276-9441-cdc71b933f73
        tasks:
          - build: |
              cd inv.alid.pw
              stack install
              $HOME/.local/bin/site build
          - deploy: |
              mkdir -p $HOME/.ssh
              echo "$webhost $hostkey" > $HOME/.ssh/known_hosts
              cd inv.alid.pw
              rsync -rlptzz --delete _site/ ${user}@${webhost}:
        

This ties everything together in two steps: first we compile the site binary that generates the website structure in _site, then, in the deploy task, we set up SSH and rsync the files into place. That’s it! We just have to save this into our repo and everything will just happen automagically when we push new commits.

One issue I have at the moment (and probably the reason I’m only finishing this now, when I first started trying to set this up back in November) is that it takes a long time for the build server to download and compile all the Haskell dependencies, particularly Pandoc. In the long term, a half-hour delay to publishing isn’t that bad, but it’s a little annoying. Next on my list is to try building this with NixOS (instead of Stack) to see if the binary caching provided there speeds things up a bit.

I missed posting an October links post, so here is a ‘bumper’ edition, with lots of clickbait titles because I need that engagement.

‘Explorer takes 700 ms to put up a task-bar context menu.’ The reason is frankly terrifying, and makes me feel a lot better about all of the dumb code that I write.

A beautiful interactive graphical introduction to Fourier transforms. Now you too can make your own colossal mess of epicycles that draws a phallus!

How programming languages should report string length and the relative fairness of text encodings for different languages: much more than you wanted to know.

The expected time to check whether a list is sorted may not be what you expect.

It turns out that 1970s-era /etc/passwd files are no match for modern hardware, and it is therefore possible to crack Ken Thompson’s password.

Joanna Southcott was an 18th-century English woman who claimed to be the Woman of the Apocalypse and subsequently was allegedly pregnant with the Messiah (although the baby never actually appeared). She left a box of sealed prophecies and in the 1920s there was a major public campaign for it to be opened. The most interesting part is that she still has followers (despite her prophecy of the end of the world in 2004 manifestly not being fulfilled), although they have understandably downplayed the weird millenarianism.

‘Mordor’s dead cities, craggy mountains haunted by giant demon-spiders, black deserts, dark towers, and fiery chasms certainly intimidated foreign visitors, much like the National Mall in Washington, D.C.’

An analogy between the Trump administration and the reign of the Dark Lord Sauron.

Once again the House of Commons has infuriated me sufficiently that I felt the need to contact my MP. Once again, I am publishing my correspondence in the hope that it normalises people beyond the stereotypical ‘green ink brigade’ to write to them.

I am (for the moment) in Worcester, so it’s a different MP (and a different party) to last time, but that means little.

Dear Robin Walker,

I am writing this as I watch the debate on Oliver Letwin’s motion for Parliament to debate a bill preventing a no-deal Brexit. I voted to remain, but I am happy to acknowledge the result of the referendum, and would accept a soft Brexit, perhaps along the Norway model or some sort of customs union. No deal would be a disaster on many fronts: the unsolvability of the Irish border question, the possibility of food medicine shortages (pertinent to myself as an insulin-dependent diabetic) and the economic impact. It must be avoided.

The decision of your party’s Government to prorogue Parliament is a dangerous precedent to set, and hearing the Leader of the House of Commons discuss the mandate and sovereignty of the House he sits in is what spurs me to write this to you now. We live in a representative democracy, not a direct one, and I wish you, as my representative, to take my views into serious consideration. I urge you to do what you can to avert the worst-case scenario of a no-deal Brexit.

Yours sincerely,

Joshua Holland

Again I have forgotten to mention recent protests. Perhaps I will have the opportunity to vote against him soon anyway; who can possibly say in such times.

Mark Dominus points out that the Classical Princess Andromeda, rescued by Perseus from Cetus, was in fact an Aethiopian princess, and therefore extremely unlikely to be the white maiden often depicted in Western art. On the other hand, Wikipedia points out that Aethiopia (or more properly Αἰθιοπία, deriving from ‘sun-burnt’) is distinct from modern Ethiopia, and is a general designation for ‘the land of dark people’, which could be anything from modern Ethiopia to India or Indonesia.

Without further comment: Anime Girls Holding Programming Books.

Again I’m a few days late with these links. I hope nobody has been kept up all night worrying.

The Fediverse is a network of mostly-compatible software that got a big spike a couple of years ago as part of a Twitter backlash; the software that runs my instance, recently hit its 1.0 release.

GPG/PGP has long been derided for its complete failure to penetrate the mainstream. This is mostly due to its terrible UX, bending over backwards to support old crypto, and trying to be jack of all trades, master of none, as explained in this excellent blog post. Some of the recommended alternatives are better than others. Magic Wormhole, new to me, seems like an extremely useful tool to have in one’s back pocket.

‘Caution! Functor! Keep 2m back.’ A common response to category theory.

General Butt Naked sounds like he should come from a Far Cry game or something, but was actually a horrifying Liberian warlord who claimed to have killed over 20,000 people and fought nude because he believed it would protect him from bullets. However, in 1996 he converted to Christianity after a vision of Christ told him to repent and his since become a preacher, even at one point expressing his willingness to be tried at the Hague. While this might give hope that anyone can be reformed, he still claims that he was under Satanic influence during his rampages, which probably takes something away from it.

In 1809, a man made a bet that he could make any house in London into the most talked about address in a week. The result was the Berners Street hoax, in which he requested more or less every tradesman in London come to 57 Berners Street to provide their services to a Mrs Tottenham. Even the Lord Mayor of London turned up!

A slightly less famous English mayor is that of High Wycombe. This is a shame, because due to some historically corrupt, drunken and generally useless incumbents, each outgoing mayor is ‘tolled out’ by the ringing of the city bells, and subsequently weighed to ensure that they have not gained any weight at the taxpayers’ expense.

Today’s feel-good story to end: the world of competitive dog surfing.

If anyone has been wondering what Tom DeLonge has been up to since he left Blink-182 in 2014, it turns out he founded the To The Stars Academy of Arts and Science, which mostly seems to focus on collecting UFO videos and images. Unfortunately, a 2018 SEC report stated that it ‘has incurred losses from operations and has an accumulated deficit at June 30, 2018 of $37,432,000. These factors raise doubt about the Company’s ability to continue as a going concern’, so I guess someone else will have to save us from the alien menace or the secret US government spy planes or whatever these UFOs really are.

IRC/Slack/Discord replacement/competitor Matrix has released as 1.0. I think I want this to work, since IRC has problems, and have had a rambly draft on the matter for quite a while. But see also Drew DeVault on why the lack of features in IRC is a feature.

‘Sega Toylet’ is frankly an amazing brand name, although I’m not sure whether it should really exist as a commercial product. At least there is no Sonic tie-in (yet?).

A fascinating but sad feature on the likely fate of Malaysia Airlines Flight MH370 from pilot-turned-journalist William Langewiesche.

After many years of resistance, I recently started using an adblocker, due to articles like these two from an ex-adtech worker. Back in 2015, Idle Words predicted the bursting of the adtech bubble, and I’m now trying to avoid using services that rely on advertising for their business model. My preference for free software (self-hosted or otherwise) followed by an upfront paid service puts me in mind of David R Maciver’s excellent How to write good software, which I more-or-less entirely agree with.

In the frontier days of the Western US from the 1890s to 1930s, the unpredictability of mining towns springing up or going bust meant that it was hard for churches to be established. The solution that some came up with was the railroad chapel car: simply take a regular train carriage, add an altar and some pews, put it on a train to wherever the people are, then leave it in a siding until the mine runs dry and cart it off somewhere else.

Theorem 1: Determining the outcome of a game of Magic: The Gathering in which all remaining moves are forced is undecidable.

An example 60-card deck that is capable of executing this construction on the first turn of the game and which is legal in the competitive Legacy format can be seen in Table III.

Yet another fun Turing-completeness proof; the undecidability is of course via a reduction to the Halting Problem.

Since apparently these links posts are just ‘Things that shouldn’t be TC but are’, another Turing-complete game is Baba is You (which I haven’t played yet, but all reviews indicate that it is very good).

Things aren’t as bad as you think (at least in the UK).

Relatedly(?), an Essex man has set the record for the land speed record in a tuk-tuk.

The Voynich manuscript has (once again) allegedly been deciphered, although it seems unlikely to be correct. Ars Technica and Language Log analyse this most recent attempt.

The Persistence of Chaos is an art piece consisting of an airgapped 2008 laptop ‘running 6 pieces of malware that have caused financial damages totaling $95B’. It was auctioned off for $1.345M.

This YouTube channel uploads videos of dogs being groomed and it is the most relaxing thing I have found in the last few years.

I mostly learned to drive from my dad, but after I passed my test I did a Pass Plus course subsidised by the local council. It covered things like motorway driving and handling unusual weather, but it was also interesting to learn from another instructor.

One thing this new instructor told me was that there are three different types of drivers: children, parents and adults. Of course the names don’t relate to the actual age or familial situation of the drivers, but their approach to the road. Recently I’ve realised that it’s a useful mental taxonomy to have in other situations as well.

Children are in a rush to get wherever it is they are going, with no concern for those around them: the boy racers trying to impress the girl in the passenger seat, the elderly people who really shouldn’t still be driving, and all the people who have had one too many drink trying to get home from the pub. Obviously this is not something to emulate.

The parents focus above all on worrying about the children. They are most susceptible to road rage, and will often pay less attention to their own driving than tutting at the driver who just overtook on the inside at 85 mph. They know better than the children, but not better enough just to take care of themselves.

This leaves the adults as the model to strive for: safe and sensible drivers in their own right, who allow the children a wide enough berth to grow up without our oversight (and without crashing into us!).

This is something that a lot of philosophies over the ages have suggested: the Stoics of ancient Greece would see a lot in common, and Niebuhr’s famous Serenity Prayer also gestures in the same direction:

God, grant me the serenity to accept the things I cannot change,
Courage to change the things I can,
And wisdom to know the difference.

But this is a framing I’ve never heard from anywhere else, and it’s one that’s stuck in my mind for a long time. I hope it’s useful for someone else as well.

The New Yorker reports on the fascinating discovery of a site which may preserve the day of the Chixculub impact, often blamed for the K-T extinction. Of course there are criticisms and doubts, but I’m sure that this is an important site regardless.

What does that famous black hole picture actually represent? Matt Strassler explains.

This (non-video link) is one of the most perverse uses of a computer I have ever seen. The insane mind behind it, Tom 7, has also produced a number of other mind-melting projects, including a C compiler which produces executables consisting only of ASCII printable bytes.

Super Tux Kart, a totally original game that is in no way inspired by any other kart racing games, which I used to play when I first got into Linux about 10 years ago, is apparently still being developed and just had its 1.0 release which includes netplay.

Slate Star Codex recounts the theories of human population modeller Heinz von Foerster’s 1960 paper and postulates mechanisms around the interactions of population growth, technological progress and the economy. The real interplay is no doubt far too complicated for us to understand, but this seems like a reasonable approximation.

Lashon Hara is the proscribed Jewish concept of ‘Evil Tongue’ (link via David MacIver). Especially in the context of modern social media, mindfulness about what one is saying and, more importantly, what purpose saying it serves is vital, especially since we haven’t really internalised the dynamics of a massive public discourse arena.

Readers may have heard of the 3750-year-old Babylonian tablet complaining of a copper merchant’s inferior quality ingots and rude treatment of his messenger. What is less well-known is that (perhaps inevitably) this has led to a certain amount of slash fiction (NSFW text) being written about Ea-nasir and Nanni. AO3 has no fewer than 6 other stories inspired by this tablet. (This one via Mark Dominus.)

These links were collected over March, so I will presumably be a month late with the various internet tomfoolery associated with this post’s publication date.

Berkson’s paradox is a counterintuitive result which most often manifests as falsely observing a negative correlation between independent variables when one mistakenly only sees cases when at least one of them occurs. Wikipedia’s example: ‘For example, a person may observe from their experience that fast food restaurants in their area which serve good hamburgers tend to serve bad fries and vice versa; but because they would likely not eat anywhere where both were bad, they fail to allow for the large number of restaurants in this category which would weaken or even flip the correlation.’ Probably a useful concept to have a handle for.

Colin Wright is mostly famous for inventing the juggling notation known as ‘siteswap’, but was in fact a maths PhD supervised by Béla Bollabás at Cambridge. He has a blog full of interesting puzzles and others, including a series of twists on the classical ‘rope around the Earth’ problem. This one is my favourite.

During the Second World War, the US was developing a revolutionary new method of incendiary bomb delivery: hibernating bats. It was only cancelled because the Manhattan project was progressing more quickly. I can only wonder at the world in which incendiary bat bombs were the threat on which the Cold War was built instead of nuclear weapons.

Why can’t font size be set on a:visited? Surprising things that have to be done in the name of privacy.

OpenType font shaping is Turing complete, although this requires a custom HarfBuzz build to increase the recursion limit past 6.

Also Turing complete is the x86 instruction set, but using only mov. I am once again reminded that Turing-completeness is not a high bar.

Long post on Status as a Service, and how social capital is the real motive behind people’s behaviour on social networks.

NYT article on a carbon dioxide scrubbing startup. Encouraging ideas, but seems energetically implausible. John Baez writes about similar ideas.

‘Why are you reading about airships?’ ‘Because airships are cool.’ Back-of-the-envelope calculations (admittedly by an airship blog) suggest that giant cargo airships could be a trillion dollar industry (the calculations are rough enough that what we mean by that doesn’t matter: could be market cap, revenue, value of assets…). They offer a previously nonexistent low-cost, medium speed transport method that is agnostic of land or sea. From the point of view of carbon, they are encouraging in that they only require energy to go forwards, although drag is a big concern and hydrogen is fairly expensive to produce.

After the House of Commons voted last night for ‘indicative votes’, there has probably never been a better time to write to your MP, regardless of your opinions on Brexit or the Government’s handling of it. Representative democracy works best when the representatives know what their constituents want, and they can only do that if we tell them. Below is what I wrote: feel free to critique or use it as inspiration for your own correspondence.

Dear Dr Whitehead,

I am pleased to see that you voted in favour of both the Beckett and Letwin amendments last night, and am writing to you today with my views on how Parliament should take control of the Brexit process. I am also pleased to see the posts on your website which align largely with my views on a People’s Vote to break the parliamentary deadlock and, if that happens, campaigning to revoke Article 50 and remain in the EU.

People should be allowed, and even encouraged, to change their mind when presented with new evidence, and when the referendum nearly three years ago was so close, it seems perverse to call it undemocratic not to ask the people of this country what they think now that the difficulty of leaving the EU has been demonstrated (although the incompetence of the May Government has probably exaggerated it somewhat).

I remain in favour if not of outright revocation of retaining the closest ties with our European neighbours possible; whether that is means ‘Norway-plus’, customs union or something else I am not familiar enough with the options to say. I would also hope for some form of compromise solution, something that the Government has so far been unable to deliver with their entirely inflexible red lines.

Yours sincerely,

Joshua Holland

Having now sent and re-read it, I’m slightly annoyed that I forgot to mention the People’s March and the petition, but maybe it’s better to keep things short and to the point. I can only now hope that Parliament can finally get things unstuck and make some forward progress.

My recent post about worstsort has a problem: the code doesn’t actually work at all. I first had issues when I was rejigging it to fit the API of the sorting crate, and then when adding tests. The latest code on Pijul Nest has the tests, so you can download it and play along at home:

$ cargo build
           Compiling worstsort v0.1.0 (/home/josh/r/worstsort)
            Finished dev [unoptimized + debuginfo] target(s) in 0.21s
        $ cargo test
           Compiling worstsort v0.1.0 (/home/josh/r/worstsort)
        error: reached the recursion limit while instantiating `badsort::<s
        td::vec::Vec<std::vec::Vec<std::vec::Vec<std::vec::Vec<std::vec::Ve
        c<std::vec::Vec<std::vec::Vec<std::vec::Vec<std::vec::Vec<std::vec:
        :Vec<std::vec::Vec<std::vec::Vec<std::vec::Vec<std::vec::Vec<std::v
        ec::Vec<std::vec::Vec<std::vec::Vec<std::vec::Vec<std::vec::Vec<std
        ::vec::Vec<std::vec::Vec<std::vec::Vec<std::vec::Vec<std::vec::Vec<
        std::vec::Vec<std::vec::Vec<std::vec::Vec<std::vec::Vec<std::vec::V
        ec<std::vec::Vec<std::vec::Vec<std::vec::Vec<std::vec::Vec<std::vec
        ::Vec<std::vec::Vec<std::vec::Vec<std::vec::Vec<std::vec::Vec<std::
        vec::Vec<std::vec::Vec<std::vec::Vec<std::vec::Vec<std::vec::Vec<st
        d::vec::Vec<std::vec::Vec<std::vec::Vec<std::vec::Vec<std::vec::Vec
        <std::vec::Vec<std::vec::Vec<std::vec::Vec<std::vec::Vec<std::vec::
        Vec<std::vec::Vec<std::vec::Vec<std::vec::Vec<std::vec::Vec<std::ve
        c::Vec<std::vec::Vec<std::vec::Vec<std::vec::Vec<std::vec::Vec<std:
        :vec::Vec<std::vec::Vec<std::vec::Vec<i32>>>>>>>>>>>>>>>>>>>>>>>>>>
        >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>`
          --> src/lib.rs:30:1
           |
        30 | / pub fn badsort<T: Ord + Clone>(k: usize, l: &mut [T]) {
        31 | |     if k == 0 {
        32 | |         bubblesort(l);
        33 | |     } else {
        ...  |
        37 | |     }
        38 | | }
           | |_^
        
        error: aborting due to previous error
        
        error: Could not compile `worstsort`.
        
        To learn more, run the command again with --verbose.
        

That’s quite an error! I posted this problem on Stack Overflow and got some interesting replies.

To explain what’s going on, remember how Rust generics work. The key idea is monomorphisation: the compiler generates specialised code essentially by copy-and-pasting for every type a generic function is called with¹. Let’s do this by hand. If we aren’t compiling in testing mode, badsort is never called, so the compiler doesn’t have to generate any code for it. In tests::badsort_zero, the type T is instantiated as Vec<i32>, so the compiler has to produce code for badsort_veci32. As it does that, it encounters another call to badsort, but this time it’s on the permutations of the list, so T is now Vec<Vec<i32>>. This means it has to generate badsort_vecveci32, and then from there it will keep going forever.

So, there are two key questions: why was this not a problem for Haskell, and is there a way to get round it in Rust? At the moment, I don’t know! I hope to get some free time to investigate this at some point, and I’ll definitely write up whatever I find on here.

This is the first monthly-ish collection of interesting links I have read online, with some thoughts about each one. There aren’t as many as there might usually be in this one because I only started collecting them this week.

David R. MacIver writes about ‘the Core Problem with Democracy’. Under some (unrealistic?) independence assumptions, a vote on ‘A and B’ may fail, even if most of the population individually believe A and B. I wonder how related this is to Simpson’s paradox. The conclusion includes the interesting observation that democracy often conflates values (‘how should the world look?’) and judgement (‘how do we make the world look that way?’). Robin Hanson’s ‘futarchy’ responds to this distinction, and so does Scott Alexander’s fictional Shining Garden.

Today’s ‘don’t believe anything you read on the internet’ article: Gizmodo exposes ‘Dr.’ David Sendler, whose studies have led to articles in places from Forbes to Savage Lovecast, as a ‘serial fabulist’. I’m not sure whether the widespread media coverage he has attracted or the possibility that he is fraudulently seeing (potentially very vulnerable) patients is more concerning. The way he talks about his upcoming study on suicide, on subjects he found by searching social media(!), are particularly alarming.

Commento is a Disqus-like commenting platform which emphasises privacy and speed. A paid hosted version is available, but it’s open-source and so self-hosting is an option (and now operational on this site, after much faffing with probably pointless Content-Security-Policy options). I hadn’t enabled comments here before because I don’t particularly trust a service like Disqus, and other solutions are a pain with a statically generated site. The one hesitation I had before installing Commento is being slightly distrustful of requiring Javascript, which was previously only ‘necessary’ to view rendered MathJax, which somewhat gracefully degrades to the raw TeX code. Also, in 2019, it doesn’t seem too onerous to require JS for something non-essential like comments.

Brent Yorgey shares a fun 2012 paper by Miguel A. Lerma about the worst possible¹ sorting algorithm, along with a cute Haskell implementation. The algorithm depends on a function $f: \mathbb{N} \to \mathbb{N}$ and runs in $\Omega(f(n))$ time; in other words, we can take at least as long as any computable function (in fact, much much longer).

Naturally I felt compelled to write up an implementation in my new favourite language, Rust. It’s not quite as slick as the Haskell one, partly because I didn’t ‘cheat’ and use a standard library implementation of permutations and chose to follow the paper more closely in using Bubblesort rather than insertion sort, but mostly because Rust is more verbose with things like curly brackets than Haskell and doesn’t allow point-free style.

Here’s the business part of the code:

pub fn badsort<T: Ord + Clone>(k: usize, l: &mut [T]) {
            if k == 0 {
                bubblesort(l);
            } else {
                let mut p = permutations(l);
                badsort(k - 1, &mut p);
                l.clone_from_slice(&p[0]);
            }
        }
        
        pub fn worstsort<T, F>(l: &mut [T], f: F)
        where
            T: Ord + Clone,
            F: FnOnce(usize) -> usize,
        {
            badsort(f(l.len()), l);
        }

worstsort runs in $\Omega((n!^{(f(n))})^2)$ time, where $n!^{(k)}$ abbreviates taking the factorial $k$ times. Pretty impressive for just 15 lines, about half of which is boilerplate!

I should probably submit this as a PR to the sorting crate…

Pijul is a version control system. So what? Everyone just uses git nowadays, right? Well, I personally already use git, Mercurial (because its model of pull/update makes more sense to me) and svn (because sometimes it’s just not worth it). So a fourth VCS is hardly a major marginal cost.

Besides, Pijul is interesting in a lot of ways. Git and Mercurial work very hard to pretend that patches are the basic unit, but in reality they store snapshots of files. In Pijul, patches really are fundamental; it is based on ‘patch theory’, pioneered by Darcs, another obscure VCS I’ve flirted with in the past. As one may expect from a Haskell project, patch theory is an application of category theory to a software engineering problem. This isn’t just abstract nonsense for the sake of fulfilling Haskeller stereotypes: patch theory is more intuitive (which is why other systems fake it in the UI), and makes both cherry-picking and merges easier.

Pijul has not (at the time of writing) had a 1.0 release yet, but it’s self-hosting; impressively so, with its own ‘Nest’ GitHub-alike that’s remarkably feature complete for such a young project. The documentation, like that of many similar hobbyist FOSS projects, is a little bit lacking—parts are out of date and it’s spread across a manual, README files and replies on the Discourse forum—but I’ve seen worse and a little reference to the source combined with educated guesswork seems to have been sufficient so far.

The main use I have in mind in particular for Pijul is to control my various dotfiles: configuration for i3, emacs, zsh, etc. At the moment they use vcsh which is horrendous overkill to the point where I never remember to commit or push anything. The other problem I have is maintaining parallel configuration across various different computers. For example, I want wifi and battery status indicators on my laptop, but not on my desktop. I haven’t found a satisfactory way to keep these parts of the configuration separate while syncing unrelated changes between the computers. I believe that it should be a lot smoother with patch theory. A new feature of the latest 0.11 release, partial clones, may well also be useful.

There are a lot of features missing: ignore files come immediately to mind, as running pijul status in my home directory shows a lot of junk I don’t want in the VCS. As far as I can tell, it’s also impossible to see the contents of a patch, or show diffs in pijul log output. And the docs are quite unclear on a lot of important questions. How do branches work? There are some discussions in the forums, but I can’t tell what’s ideas to be implemented, what’s newcomers asking questions and what’s how it actually works. I’ll post my issues into the forum, and I hope that I’ll be able to help transfer the answers into the official docs.

I have a 5k line LaTeX file, and I wasn’t sure whether it contained any non-ASCII characters. I’m using LuaLaTeX to compile it, which supports UTF-8, so just running pdfLaTeX on it is not a solution, and it would be nice to have a method that works on any text file.

The first tool any seasoned Unix admin reaches for to answer the question ‘Does a particular character occur in a text file?’ is, of course, grep. The man pages don’t list a built-in character class right away for ASCII characters, so a tiny bit of ingenuity is required. This Stack Overflow answer gives a command which almost works (in my testing it found the ‘ï’ of ‘naïve’ but missed the ‘ń’ in a Polish name), but it’s easily modified into the following:

grep -P '[^\x00-\x7f]' myfile.tex
        

Having the full scope of Perl-compatible regexes available means we could use the (slightly more memorable) [^[:ascii:]].

The second is a less well-known part of the standard Unix toolbox, iconv. Its primary purpose is to convert between text encodings, but we can abuse it to detect non-ASCII characters by asking it to convert our file into ASCII and seeing if it gives any errors:

iconv -t ASCII myfile.tex > /dev/null
        

Finally, trusty old file will tell us the encoding used, and is probably the easiest one to remember:

file myfile.tex
        

Mathematical YouTube channel 3Blue1Brown recently released a video about quaternions, a 4-dimensional extension of the complex numbers now mostly used in 3d graphics and other areas. In the spirit of Edwin A. Abbott, the video builds up to explaining 4d rotations to a 3-dimensional audience by analogy to the step from one dimension to two.

I’d certainly recommend watching the video, as the visualisations are as excellent as they usually are. One of the first ones we see is to explain complex multiplication to a one-dimensional Linelander, starting at 5:12. Seeing it immediately made me think of how multiplication is performed on a slide rule.

Let’s start by going over in detail the process to multiply two numbers, say 2 and 4, with a slide rule. To begin with, here are the two scales that we care about:

They are graduated with exactly the same scale, and all of the values line up. This starting position can be thought of as the process ‘multiply by 1’. Since in this example we want to multiply by 2, we slide the movable middle section (scale C) until the 1 lines up with 2 on the lower section (scale D).

Now the rule represents the operation ‘multiply by 2’. We can already see everything lines up as you’d expect: already visible is $2 \times 1.5 = 3$, and it’s just a matter of looking further along to read off the answer $2 \times 4 = 8$.

Compare this to the animation in the video. Instead of two adjacent linear scales representing the real line, we have two overlapping coordinate systems for the complex plane. To multiply by $2 + 3i$, we move the point 1 on the first grid to the point $2 + 3i$ on the second by stetching and rotating it. Then we can read off the product $(2 + 3i)(1-i)$ by finding the point on the second grid where $1 - i$ ended up.

This process is so similar to how we do it on the slide rule that it really makes me wonder how to build a physical implementation: a complex-valued slide rule. I’m not very practically minded, but I wonder whether there’s something you can do with pantograph linkages like you get in a Hoberman sphere…

After a little bit of online searching, I found that of course complex-valued slide rules have been around for a while. The idea of stretching is avoided in a real-valued slide rule by logarithms, and it’s perfectly possible to replicate this in the complex case. All of the examples in the links use the full-blown complex logarithm function; they tend to be cylindrical to handle the rotations gracefully. I particularly recommend looking at the ray-traced image from the third above link. The gently but precisely curving lines and the way the transparent part overlaps the fixed cylinder are both fascinatingly beautiful to look at.

A couple of weeks ago, I was in Oxford for a wedding, and spent a hungover rainy Sunday visiting some of the city’s museums. I’ve been to the Natural History Museum and the Pitt Rivers a lot, although it would probably take decades to see everything in there. The Settlers exhibition was particularly interesting, as I’ve always found the story of the peopling of Britain over the millennia fascinating, and the presentation of archaeological, historical and genetic information was really well done.

One I hadn’t visited before is the Museum of the History of Science. It’s perhaps a little light on information you would call ‘the History of Science’, and I don’t think they ever went so far as to explain how to use any of the many astrolabes, but the collection on display is really astounding. Clocks, medical equipment, old electrical demonstrations and toys, surveying instruments, and more are all in there, along with slide rules.

I think I first encountered a slide rule at school while doing my A levels, as one of the collection of odds and ends the maths department kept lying around. It didn’t really make much of an impression then, but seeing them again in the museum in Oxford really sparked something in me, and I ended up ordering a couple from eBay when I got back home. After a week of delays due to courier bullshit, I was in possession of two Faber-Castell slide rules, models 2/82 and 2/83.

These slide rules can perform multiplication, division, exponentiation, logarithms, and trigonometric functions, with shortcuts for common operations like squaring, square roots and powers of ten. It’s also straightforward to multiply and divide lots of numbers without having to find intermediate results. Surprisingly, it’s not readily possible to do addition or subtraction: the only way is to use a formula like $x + y = x(1 + \frac{y}{x})$ to do it by multiplication and division.

The key mathematical fact exploited by slide rules is $\log (xy) = \log x + \log y$, converting multiplication into addition implemented by chaining log scales next to each other. The scales are graduated from 1 to 10, so the user has to keep track of the order of magnitude. It’s pretty easy to work to 3 or 4 significant figures. The model 2/83 also has what is effectively a double-length scale on the back, allowing more precise calculations to be done at the relatively low cost of having to keep track of which side the result should be read off.

In an age of ubiquitous electronic calculators in the form of mobile phones and computers, what is the point of a slide rule? Practically speaking, not really very much. If nothing else, I personally rarely have to do any calculations which would require one. One minor feature is shown in the second picture above, where the slide rule is set up to quickly convert between miles and kilometres on the pair of scales just above the red pair in the middle. The 1 on the lower (CF) scale is aligned with 1.609 on the upper (DF) scale, and so any kilometre value on DF can be read off in miles on CF, and vice versa. I’ve also used this to set up currency exchange rates, and it’s really handy to be able to convert any value at a glance without having to change any settings or input a new number.

But, more intriguingly, there is something very satisfying about the really visceral way you can see the numbers fit together on a slide rule. It’s something that has always really grabbed me about mathematics: everything is exactly in the place it has to be, breaks down precisely how it needs to, and we can prove it in black and white.

It’s one thing to know multiplication tables purely as figures. It’s quite another to see them all line up in front of you, and to see how changing the factor makes a different set of numbers line up. And then you can compare the half, double and triple length scales (corresponding to square roots, squares and cubes) with the base scales and the reversed scales (for multiplicative inverses). There’s something missed by knowing only algebraically that $\sin x = \cos (90^\circ - x)$ without seeing the trigonometric scales for sine and cosine condensed onto one scale read either way. I think my mathematical education was lesser for never having had a slide rule in my hands when I was first learning the concepts. The slide rule offers a physical intuition that is completely absent in other methods of teaching.

Another advantage of the slide rule is possibly also a disadvantage. With a slide rule like these ones, the user has to be familiar with what they are doing. There are (or were) slide rules specialised to work out things like gunnery angles and so on which didn’t need a mathematical background, but all-purpose slide rules are clearly a lot harder to use than an electronic calculator. I personally enjoy a little mental arithmetic and algebra practice, but for a normal person, it’s far more effort than modern technology requires.

So it’s not really much of a surprise that they more or less died out in the 1970s, with the rise of the microprocessor and electronic calculator for engineering and scientific calculation. Still, I’ll enjoy keeping them around and doing the odd calculation on them. And, when the upcoming nuclear apocalypse wipes out all electronic devices, I’ll have the last laugh still being able to multiply and divide to four significant figures.

I’ve started reading Jon Ronson’s So You’ve Been Publicly Shamed, which has been on my list for a while after I’ve enjoyed much of his other work. In the fourth chapter, he quotes Justine Sacco, whose somewhat racist tweet went viral while she was on an 11-hour flight, as saying ‘it’s not like I can date, because we google everyone we might date’. Now, I’m not particularly interested in the morals of what happened to Justine Sacco and her tweet (though I might have some thoughts for a later post after I finish the book), but this sentence caught my attention. The idea of looking online to see if some romantic interest had a shady past of off-colour jokes on social media would never occur to me.

I’m certainly not so naïve to be unaware that people do this. But what makes me different? The two things that first come to mind are nationality and gender. I am an English man, and Justine Sacco is a South African-American woman. It would be very surprising if we had an identical experience of dating. Still, gender perhaps is less likely: Sacco is talking about her potential partners, not herself, and if she is interested in men, then that includes me. So it is more likely down to culture or simply personality differences¹.

Bemoaning the Americani{s/z}ation of British culture is one of many celebrated national pastimes, and by no means is the world of romance exempt from trans-Atlantic influence, perhaps significantly due to American-based websites. Still, we are different {to/from/than} our cousins across the pond and obviously so will be our behavio{u}r with respect to relationships.

British people are stereotypically more reserved and respectful of status differences than Americans. We still enjoy gossip behind people’s backs, but social class is often given away through speech and mannerisms, obviating much of a need to research someone’s background. I don’t have much concrete to back this up, but it doesn’t feel too difficult to justify myself using national tendencies in this way.

On the other hand, my justification of the previous paragraph feels a little like a just-so story, and I suspect that I could come up with an equally convincing argument in the other direction had my initial intuition been different. What I am best qualified to talk about is of course my own experience. How much do I pry into people’s online presence before I go on a date with them?

Clearly if I already know a person then this whole discussion is academic, so we are probably talking about someone I’ve just met, most likely through online dating. The content of a profile description is a starting point (interestingly unique to online dating, absent if you meet in a pub, at a concert or somewhere similar). If I’m particularly interested, then I might look up their social media accounts, although in search of more posts, more pictures and more personality rather than a life history. I tend to hold off sending actual friend requests until we’ve met a few times and established some actual in-person chemistry.

But why do I take this approach, and why isn’t researching all this information appealing to me? Fundamentally, I think it comes down to three things. Firstly, it simply feels like an intrusion. This possibly comes from my British reservedness and natural introversion, but I don’t particularly like the idea of someone googling me, and therefore I reciprocally choose not to do it to others. Mostly it’s probably not a significant problem, since people can control to some extent what is publicly associated with them, but I prefer to err on the side of caution. Secondly, and somewhat relatedly, the simple act of finding out about each other is a major part of the point and fun of dating people. I could google someone and find their name on a list of graduates of some university, or I could listen to them talk about what they studied, hear why they find that interesting, where the best pubs are in that city and what memorable stories happened in them.

And finally, I think the most important part of a person is how they think and act now, not five years ago. I hold willingness to forgive as a cardinal virtue, and knowledge of some past crime only matters to me as a prior for that person doing it again. If they can convince me that they repent of whatever grevious sin is hiding in their past, then I will not hold it against them. I don’t mean to imply that someone’s past is completely insignificant: of course personal history has a huge effect on the present self. But we are not our mistakes. What matters is our ability to accept them and their consequences, to learn from them and to avoid making them all over again.

Reading Slate Star Codex today, a sentence in a quote jumped out at me:

The changes … shined a national spotlight

In particular, the usage of ‘shined’ over ‘shone’ seemed very unnatural to me. As a result of doing a little research on this, both words have now completely lost any meaning. I hope that someone reads this blog post so it was all worth it.

My first stop was the entry on Wiktionary, which lists both ‘shined’ and ‘shone’ as equally acceptable simple past or participle forms. I didn’t think that this was quite right, so I continued my digging. A search for ‘shined or shone’ revealed the usual mass of grammar blogs. The top result was Grammarist, which has a very short entry saying that historically, ‘shone’ was for something emitting light, and ‘shined’ was for polishing something, although in modern usage this is less strictly adhered to. Most other results had a similar, although not quite the same, transitive vs intransitive distinction. One even mentioned a mnemonic ‘rhyme’: ‘shone stands alone’.

I put ‘rhyme’ in scare quotes there because in my (British English RP) accent it doesn’t rhyme at all: ‘shone’ as in ‘gone’ and ‘alone’ as in ‘moan’. This reinforces my initial intuition that there is some British vs American difference here. Inspired by my favourite blog about such differences, Separated by a Common Language, whose post on this I only thought to search for after doing all this other research myself, I looked up the two words in a corpus:

And there we have it: ‘shone’ is proportionally much more common in British (and Commonwealth) English than it is in American. Now you should go read that SbaCL post because it’s written by someone who actually studies this stuff for a living.

Why, when I rebuilt this website, did I include a blog portion fairly front-and-centre? In 2018, it seems that everyone just shoots an unfiltered stream of consciousness onto the internet or maybe has a Medium account for slightly more fully-baked ideas. Sure, there are a few blogs still around, but they mostly seem to be historical artefacts left over from a bygone age.

I’ve never been a prolific blogger or writer of anything much in particular. At school, essay subjects were my least favourite, and after my English GCSE, the most words I put together in one go were in my UCAS personal statement. Over my undergraduate degree I ended up writing more, as higher level maths leads to more involved proofs needing more explanation, but it’s a very different style to general prose.

On the other hand, from a young age I was a prolific reader. I think I mostly inherited this from my mother, but it became an important part of my personality growing up. I wasn’t fussy: novels, short stories, popular science books, random magazines lying around the house. My reading habit has waxed and waned over the years, but I was always aware of the existence of people who put words together for a living.

Now I’m a PhD student, and for the first time I have to write journal papers and eventually (though a lot sooner than I like to think about) a full thesis. The most consistent piece of writing advice I’ve seen is simply to write as much as possible and not care that the first x thousand words will suck. So one reason is definitely to get to the the point of being able to explain complex topics clearly and engagingly, at least to expert audiences.

With that said, merely practising the art of writing isn’t the only motivating factor. I haven’t come up with a title or tagline for this website mostly to leave myself the freedom to write what I, and hopefully others, find interesting. Granted, so far that’s been weird parts of category theory and overcoming very specific technical issues in little-used software, but I have some thoughts about the broader world of modern society and technology that I want to get to very soon. In fact, this post is at least the start of unravelling all those issues.

Another aspect is to rubber-duck my life in some sense. It’s a common experience to start asking some question (technical or otherwise) and realise that the act of structuring it into words makes the solution clearer, and I hope to be able to apply this to real-life situations I find myself in, ideally where I can come up with some novel or useful observation. I don’t have anything particular in mind in this genre yet, but it’s something that I want to leave myself open to.

And finally, I may eventually have some political or philosophical opinions I want to clarify and share. This builds on my previous point, as the aim is to not only rubber-duck myself into some sort of coherent thinking, but also force myself to do the research. I’m a big believer in intellectual humility, and there’s a lot that I freely admit I don’t know enough about to have even a private opinion of.

So this post will stand, at least for now, as my justification for this exercise in putting words on the internet. As always, if you have any comments, feedback or anything else to say to me, I’d welcome it via email, Twitter, carrier pigeon or any other means of contact you have.

I’ve just finished adding Atom and RSS feeds to this website. While Hakyll provides (excellent) built-in support for feeds, the way I’ve set up clean URLs to avoid .html suffixes everywhere (inspired by/ripped off from Rohan Jain) initially didn’t quite work right with it, so I’ll document how I fixed this below.

In the original method, clean URLs are implemented in two parts: first cleanRoute routes foo.md to foo/index.html, and then cleanIndexUrls rewrites internal links to remove all the index.html suffixes; see the post for more details. Up to now, this worked well enough, but when the feeds are generated, index.html is left in the links, and on closer inspection, it’s missing the point somehow. Hakyll URLs are generated via the url field attached to defaultContext, which eventually comes from the following:

urlField :: String -> Context a
        urlField key = field key $
            fmap (maybe empty toUrl) . getRoute . itemIdentifier
        

So we can see that it all comes down to the Route of the item. In the case of cleanRoute, this is going to include the index.html. Rather than including this in the URLs and then stripping them out later with cleanIndexUrls, it seems much cleaner to redefine the url field in the context to something more canonically correct. Thus:

cleanUrlField :: String -> Context a
        cleanUrlField key = field key $
          fmap (maybe empty (cleanIndex . toUrl)) .
          getRoute .
          itemIdentifier
        
        myContext :: Context String
        myContext =
          cleanUrlField "url" <>
          defaultContext
        

With this change, we don’t need to run cleanIndexUrls any more, and the feed generator code picks up the correct URL to place in the Atom and RSS feeds. You can see the full site.hs file with these changes here.

It seems my first non-trivial post on my new website is going to be something fairly technical and likely not of any interest to anyone in particular. However, it’s related to something I’m working on at the moment, and a little perfunctory searching seems to indicate that there’s some sort of hole in the literature here, at least as far as my understanding goes. This is partly also a means to justify my faffing about to get MathJax working on this site. I assume familiarity with functors and natural transformations, but not much category theory beyond that.

A monad (on some category $\mathcal{C}$), historically also known as a triple, consists of three pieces of data:

1. a functor $T : \mathcal{C} \rightarrow \mathcal{C}$;
2. a natural transformation $\eta = \eta^T : 1 \rightarrow T$ called the unit; and
3. a natural transformation $\mu = \mu^T: TT \rightarrow T$ called multiplication

such that $\mu \circ T\mu = \mu \circ \mu T$ (associativity) and $\mu \circ T \eta = \mu \circ \eta T = 1$ (unit law), famously summarised as ‘a monad is a monoid in the category of endofunctors’¹. Given a monad $T$, we may form its Kleisli category $\mathbf{Kl}(T)$, which has the same objects as the underlying category and where an arrow $X \nrightarrow Y$ is a $\mathcal{C}$-arrow $X \rightarrow TY$. I’ll use this different notation for Kleisli arrows because it’s important to keep straight the distinction between them and arrows in the underlying category. The identities are given by the unit maps $\eta_X$ and composition of $f: X \nrightarrow Y$ and $g: Y \nrightarrow Z$ uses the multiplication:

$$X \xrightarrow{f} TY \xrightarrow{Tg} TTZ \xrightarrow{\mu_Z} TZ$$

This construction is well-known from its use in functional programming to model effects.

Distributive laws come up a lot in the world of string diagrams and SMTs, where we use them to combine two theories together subject to some laws governing their interaction. The most familiar example of a distributive law is multiplication over addition:

$$a(b + c) = ab + ac$$

Beck (p95) extended the notion to monads, defining a law distributing a monad $S$ over a monad $T$ to be a natural transformation $\lambda: ST \rightarrow TS$ satisfying certain coherence laws. In the paper, he in fact gives a way to recover the multiplication/addition law back from this construction, which is pretty cool.

The main theorem related to distributive laws of monads is the equivalence of

1. a distributive law of $S$ over $T$;
2. a coherent multiplication on $TS$;
3. a lifting of $T$ to the category of $S$-algebras (which I haven’t introduced, since it isn’t really relevant to this post); and
4. a lifting of $S$ to the Kleisli category of $T$.

Now, this certainly is true, but this is where the hole appears. Beck’s original paper omits this last condition (perhaps because Kleisli categories weren’t widespread back then?). On the other hand, Cheng implicitly assumes the result for Kleisli categories. I have a feeling that it possibly follows out of the treatment of adjoint functors in Section 3 in the Beck paper, but I can’t quite get my head around it, and in any case I needed to write the construction down from first principles for my application.

To warm up, let’s look at the most well-known use for a distributive law $\lambda : ST \to TS$: giving the composite functor $TS$ a monad structure. Simply composing the units $\eta^T \circ \eta^S$ gives a natural transformation which will be the unit of the composite monad, but the bit which actually requires a distributive law is defining a multiplication $\mu^{TS} : TSTS \rightarrow TS$. It’s one of those times when there’s essentially only one thing you can write down, and that is exactly what you need:

$$TSTS \xrightarrow{T \lambda S} TTSS \xrightarrow{\mu^T \mu^S} TS$$

and all the relevant coherence conditions match up to satisfy the monad laws.

For the Kleisli category, we need to define a monad $\tilde{S}$ on $\mathbf{Kl}(T)$. Even just to define the functor part we already need the distributive law: the objects are the same, but for a map $f: X \nrightarrow Y$, we need to define

$$\tilde{S}f: SX \rightarrow TSY = SX \xrightarrow{Sf} STY \xrightarrow{\lambda_Y} TSY$$

So handwaving over the proofs that this is a proper functor, we now just need a unit and multiplication. The unit is again just a composite of the constituent units:

$$\eta_X: X \nrightarrow \tilde{S}X = X \xrightarrow{\eta^S_X} SX \xrightarrow{\eta^T_{SX}} TSX$$

and the multiplication is a little more fiddly, but still straightforward:

$$\mu_X: \tilde{S}\tilde{S}X \nrightarrow \tilde{S}X = SSX \xrightarrow{\mu^S_X} SX \xrightarrow{S\eta^T_X} STX \xrightarrow{\lambda_X} TSX$$

And, again glossing over all the annoying coherence proofs, we’re done!

There are quite a few pieces I’ve left out of all of this, notably going back the other way, from a lifting of $S$ to $\mathbf{Kl}(T)$ to a distributive law $ST \rightarrow TS$, and most of the verifications that all these things satisfy the laws they are supposed to, but this is mostly what I wanted to figure out. Hopefully it’s useful to someone other than me. Any mistakes or comments, send me an email or tweet and I’d be happy to discuss.

I’ve finally updated my personal homepage! Highlights include up-to-date information about myself, a switch from Jekyll to Hakyll, and ditching Bootstrap for hand-coded CSS. I have some intent to actually post things to the blog in the future also, but whether that happens does remain to be seen.

Still to be done are re-implementing some sort of mobile/responsive design, adding a more formal CV, generating an RSS feed, and perhaps even a publication list. There are also no doubt plenty of places that could use a little prettification; I make no claims to being talented at web design.