In the Henley Royal Regatta two teams at a time propel their boats up a river and compete to be first to go a distance. Teams get assigned to their starting stations – Berkshire or Buckinghamshire – at random. From there, it is a straight shot up the river, with the lane from each starting station being seemingly identical.

I didn’t know any of this, but a reader reached out some time ago because they had noticed something odd about this, and they wanted to borrow me as a sounding board. Here’s the odd thing: the team that starts from the Berkshire station has won 53.5 % of the 7555 races in the historic data this reader looked at. This is highly unexpected. If teams are assigned at random, and the starting stations are practically equal, then the starting station of the winning team should be a coin flip.

If we flip 7555 coins, we would never have as many as 53.5 % come up heads.

(Continue reading the full article on the web.)

Since about three years past time immemorial, the RSS feed for this site has been very anaemic. It had article titles and dates, and that was it. Many readers have requested that I include the full article in the feed, or at least a preview, but I’ve always put it off because it has sounded difficult to accomplish technically.

The way the RSS feed for this site is generated is in two steps:

1. First a little loop in Emacs Lisp runs through the first few items of a sorted and filtered list of files belonging to this project. This loop constructs an org-element syntax tree for the RSS feed, and renders it out to a temporary file as an Org mode file.
2. Then the regular Org exporting framework takes over and exports that file as an RSS file using the ox-rss backend.

(Continue reading the full article on the web.)

Some decade ago I read a good implementation of fizzbuzz. What set it apart was its excellent modularity. The original article is no longer on the web, but this is my reconstruction:

module Main where

import Control.Monad (guard)
import Data.Foldable (for_)
import Data.Maybe (fromMaybe)

fizzbuzz i =
  fromMaybe (show i) . mconcat $
    [ "fizz" <$ guard (rem i 3 == 0)
    , "buzz" <$ guard (rem i 5 == 0)
    ]

main =
  for_ [1..100] $
    putStrLn . fizzbuzz

The great thing about this implementation is that when we get the natural change in requirements – that we are supposed to print “zork” for multiples of seven – we can accommodate that change by simply adding the line that does so:

(Continue reading the full article on the web.)

Some time ago I read an article on what makes a good tutor. It explicated many of the things I do when tutoring, so obviously I thought it was a great article. When I had a side gig as a private tutor, I covered mostly maths and physics, so that’s how I’ll frame things in this article. The same thing applies to other fields too, but it might be harder the further away from maths they are.

The main thrust of the lost article (as I remember it) was that effective tutors are highly empathetic to the level of motivation of their student, and they quickly adjust the lesson to that. That’s it. That’s the main thing good tutors do differently. If motivation decreases, they switch to lighter content, or even transition into non-lesson conversation. If motivation increases, they ramp up the difficulty of the lesson. Tutoring is, say, 80 % motivation management.

Okay, but that undersells it a little. Lesson difficulty is not fixed for any topic; it depends on the student. Annoyingly, it even depends on the student’s level of motivation! The tutor must somehow know what is going to be difficult and what is going to be easy for their student, in every specific situation.

(Continue reading the full article on the web.)

Spaced repetition is best introduced in the words of Gwern: it is

a mechanical golem that will never forget, and never let us forget whatever we chose to.

If this was a medical treatment or lessons from a personal coach, it would be priced so that only high-ranking politicians, CEOs of big companies, and Silicon Valley programmers could afford it. But spaced repetition is available to anyone, at a cost of only teens of minutes a day. More people ought to use it, but some do not because they harbour misunderstandings about it. Today, we’ll clear some of these up.

(Continue reading the full article on the web.)

Ada is incredibly well designed. One way this shows is that it takes the big, monolithic features of other languages and breaks them down into their constituent parts, so we can choose which portions of those features we want. The example I often reach for to explain this is object-oriented programming.

I never truly understood object-oriented programming until I learned Ada, which breaks down object-oriented programming into separate features, like

• encapsulation,
• reuse,
• inheritance,
• abstract interfaces,
• type extension, and
• dynamic dispatch.

(Continue reading the full article on the web.)

Many of you get notified of new articles via RSS, and some of you stay tuned through the email newsletter. The email subscribers have, in the past three weeks, answered a survey on their understanding of maths topics. I asked three questions of increasing difficulty:

1. How advanced maths have you formally studied?
2. How advanced maths are you still comfortable using?
3. How advanced maths do you know well enough to teach someone else?

(Continue reading the full article on the web.)

Creating abstractions should not be left to beginners. Richard Gabriel says puts it well::

Abstractions must be carefully and expertly designed, especially when reuse or compression is intended. However, because abstractions are designed in a particular context and for a particular purpose, it is hard to design them while anticipating all purposes and forgetting all purposes, which is the hallmark of the well-designed abstractions.

This is one of my favourite quotes on abstraction, because “anticipating all purposes and forgetting all purposes” so aptly summarises how a good abstraction is made. I was reminded of this when I read the first sentence of issue 34 of Frontend at Scale, where it is phrased as “how to care about anything without caring about everything”.

(Continue reading the full article on the web.)

The internet is full of people dismissing lines of code as a measurement. People say things like

Lines of code written has been firmly established over the decades as a largely meaningless metric.

and

(Continue reading the full article on the web.)

When interacting with databases in Haskell, we use a library called Persistent to create mappings between database content and Haskell data types. This library can also query for records and update them, as long as the operations involved are very basic.

Once operations become more complicated, we turn to Esqueleto, a lower-level library which reuses Persistent data mappings but let us write nearly raw SQL queries. The main difference between raw SQL and Esqueleto is that Esqueleto is type safe, meaning the compiler will complain if we write invalid Esqueleto queries. If we accidentally try to cram a varchar column into an UTCTime field in a Haskell object, the compiler will let us know. Not the pager going off at 3 AM.

Another strength of Esqueleto is that it is, in a sense, plain Haskell code. This is also its drawback. I have long struggled with learning to write Esqueleto fluently. Some colleagues suggested that maybe the problem is I don’t practice writing it enough. So I picked up an arbitrary SQL tutorial I found on the web, and followed it but writing Esqueleto instead.

(Continue reading the full article on the web.)

I was reading the METR article on how LLM code passes test much more often than it is of mergeable quality. They look at the performance of LLMs doing programming when the success criterion is “passes all tests” and compare it to when the success criterion is “would get approved by the maintainer”. Unsurprisingly, LLM performance is much worse under the more stringent success criterion. Their 50 % success horizon moves from 50 minutes down to 8 minutes.

As part of this they have included figures such as this one:

(Continue reading the full article on the web.)

I read Ian Whitlock’s article on why he can’t quit Magit and it inspired me to share more about Magit from my perspective. This article will focus on rebasing.

Here I have opened the git log, by first opening Magit (which I have bound to the F3 key), and then pressing lL. The first l is the prefix key for dealing with the git log, and the second L is to to view the log for all local branches (and the remote branches they track.)

(Continue reading the full article on the web.)

Teaching an adult to ride a bike is easy. This is how:

1. You hand them a smaller bike so they can comfortably reach the ground.
2. You instruct them to not focus on going in any particular direction, but instead always steer into the fall.

That’s it. That’s the whole trick to cycling. 99 % of the time, the handlebars are only there to keep the bike under your body. 1 % of the time you use the handlebars to upset the balance to initiate a turn.

(Continue reading the full article on the web.)

TL;DR: To use a shell script as a Nix flake check, turn it into a derivation with runCommand. It must

• Create a file named as suggested in the environment variable $out.
• Print the desired “how to fix” information to stdout.
• Exit with status code 1 if the check failed, otherwise 0.

These three steps are not strictly documented anywhere, but are all needed for a shell script to work as a good flake check.

(Continue reading the full article on the web.)

The problem with Qwerty keyboards on small touchscreen devices is that they are designed for ten-finger typing, and we typically only use two thumbs to type. Surely there must be ways input can be optimised for two thumbs beyond the Qwerty keyboard.

Obviously, one of the best alternatives would be treating the touchscreen as a proper iambic morse code key. Unfortunately, no good implementation of that concept exists for Android. Of the choices that are available, the one that speaks to me the most is KeyBee.

At this point, I have used KeyBee for less than a human gestation period and I can’t imagine going back to Qwerty. Learning a new input method is a couple of weeks of painful frustration, followed by another couple of weeks of slow going, but then after that everything goes automatically and you wonder why you didn’t do it before.

(Continue reading the full article on the web.)

Imagine we want to figure out what round-trip times we can expect between Sweden and New Zealand. We ping a server belonging to the University of Waikato from Stockholm, and record the following round-trip times in milliseconds.

We want to tell our friend about our experience, but we don’t want to send over this entire table. A decent way to summarise a distribution is by a tolerance interval, which means the central portion in which some fraction of the values end up. For our case, we might pick the fraction 90 %, meaning only 5 % of the data will be smaller, and 5 % will be greater than the interval.

(Continue reading the full article on the web.)

Rajiv Prabhakar presents us with a hypothetical:

You and your friend are walking by a magic store and find a trick coin. You toss it 14 times and end up with 10 heads. Your friend thinks at least one of the next two tosses will end up tails, and is willing to offer you $10 in an even-money bet on it. Should you take him up?

This is a fancy way of asking,

(Continue reading the full article on the web.)

Here’s an example of a system of equations I came across.

\[\left\{\begin{array}{l} & 4x & - & 3y & = & -17 \\ - & 2x & + & y & = & 7 \end{array} \right.\]

There’s a fast way to solve this, which is to take two of the lower equation and add to the upper equation. This makes the \(x\)’s cancel out and removes some of the \(y\)’s, leaving us with

(Continue reading the full article on the web.)

The 2026 ACX prediction contest asks whether any justice of the Supreme Court (SCOTUS) will leave during the year. Well, actually it asks whether one of two things will happen:

• Congress enacts a bill that changes the number of seats in the SCOTUS; or
• a sitting justice officially leaves office.

The first condition seems extremely unlikely. All actual changes to the size of the SCOTUS happened in the years 1801–1869. At the time, representatives of the SCOTUS had to regularly travel across the US. Asking six people to cover all that country when horseback was the most efficient mode of transport was unrealistic so the SCOTUS was gradually expanded when the size of the US expanded.

(Continue reading the full article on the web.)

One of the questions of the 2026 ACX prediction contest is whether Nvidia’s stock price will close below $100 on any day in 2026. At the time of writing, it trades at $184 and a bit, so going down to $100 would be a near halving of the stock value of the highest valued company in the world.

It’s an interesting question, and it’s worth spending some time on it.

If you just want the answer, my best prediction is that the probability is around 10 %. I didn’t expect to get such a high answer, but read on to see how we can find out.

(Continue reading the full article on the web.)

The last few questions of the ACX 2025 prediction contest just resolved. This means we can take stock of what went right and what went wrong.

My preferred metric of forecasting performance is the average blind Brier score, since this is what’s popularly used as a reference for comparison across forecasting contexts. In the ACX 2025 contest, I achieved a Brier score of 0.21 – the same as in the 2024 edition!

(Continue reading the full article on the web.)

We could use an electronic calculator to figure out the rescaled amounts, but a slide rule makes it so much easier. The picture above was taken while following a recipe that called for 2 tsp of baking powder, and I wanted to make as large a batch as I could given the remaining 3.3 tsp of baking powder I had – a proportion of 2:3.3. You can see the slide rule is set to a proportion of 2:3.3 because – if you open the image in a new tab to make it larger – the number 2 on the C scale (on the bottom of the sliding middle part) is above 3.3 on the D scale just below.

But wait, the number 1 on the C scale is also just above 1.65 on the D scale. And 14 (or, if you will, 1.4, since with slide rules we ignore decimal points) on the C scale is above 23.1 on the D scale. Indeed. It’s set to those proportions too, because they are the same proportion. This is what makes the slide rule so powerful.

(Continue reading the full article on the web.)

Here are the costliest natural disasters per year, since 1900. This covers only single events; it does not count longer-running processes like multi-year droughts.

(Continue reading the full article on the web.)

I evaluate LLMs by how well they play text adventures. The last update I made was when Haiku 4.5 was released. Now that Google has released a preview of Gemini 3 Flash, I had to run the benchmark again. I had expected it to blow the other models out of the water, which it did … almost.

The following plot illustrates the distribution of the relative scores achieved by each tested model.

(Continue reading the full article on the web.)

As readers of the premium newsletter know, I have been playing some more go recently. In particular, thanks to the release of the book Mastering Mini Go, I have discovered how exciting go on a 9×9 board is. I feel like this faster-paced, smaller game has taught me a lot, because it is so rich in feedback. This comes from it being very unforgiving. Small-ish mistakes quickly lose the game, and that becomes clear just a few moves later.

Here are some things which 9×9 go has made me realise:

• The relaxed win requirement (called komi) White gets to compensate for Black’s first-move advantage is bigger than I thought. Black needs to really apply pressure to have a chance of winning, while White can focus more on playing a solid defense.
• Having the ability to freely decide where to play the next move (called sente or initiative) is important. Being able to take the next big point on the board after a local exchange is like getting another first-move advantage partway into the game.
• Retaining the initiative requires knowing when groups are settled, and not playing additional moves just to be sure. Sometimes it even requires knowing when a group is unsettled, but there is still a more important intersection to play on elsewhere on the board.
• Attacks and invasions are different things: attacks exploit weaknesses in the opponent’s groups to get free moves on the outside, while invasions create groups inside the opponent’s territory that either survive, or at least create new weaknesses that can later be attacked.
• Invasions live by having at least two directions to run when attacked (called miai). Invasions that don’t live can still be useful: the threat of rescuing an invasion can create the potential for attacking moves on the outside of the opponent’s invaded territory.
• Weaknesses (called aji) in defensive structures can be severe. A single cutting point or one group with a few liberties might be no big deal. But when there are many bunched up, the opponent might find the one move (called tesuji) that starts a sequence that breaks open a wall and throws in question territory thought to be well-defended.
• To invade successfully, one needs a sense of when a space is too small and with insufficient aji to make an invasion possible. The amount of aji determines how small is too small, but it’s a complex, context-dependent tradeoff.

(Continue reading the full article on the web.)