Programming on Patrick Stevens

LLM arithmetic

Sat, 13 Dec 2025 09:41:00 +0000

I keep seeing people going on about the 3.9 - 3.11 = 0.79 thing, but we already know why they do that and how to avoid it!

Robocop: automated code review

Mon, 10 Nov 2025 17:25:00 +0000

I wrote a basic LLM-based code review tool that’s distressingly effective.

LLMs sanding off the edges

Mon, 06 Oct 2025 22:59:00 +0100

I’m a bit concerned about a failure mode that is increasingly arising with LLMs: the divorce between how something looks, and its quality.

Boolean blindness

Fri, 29 Aug 2025 10:23:00 +0100

Why booleans are an advanced technique that should be used with care.

Some Python surprises

Sat, 21 Jun 2025 00:00:00 +0100

I am forever astonished that people describe Python as a simple language. Here are some of the things I found very surprising about it.

Things I've learned about the .NET runtime

Fri, 20 Jun 2025 00:00:00 +0100

While writing an MSIL interpreter, I discovered a bunch of unexpected things about the .NET runtime.

Announcing WoofWare.Expect

Tue, 17 Jun 2025 00:00:00 +0100

A basic but functional expect-testing framework for F#.

LLM effect on my programming (2025 edition)

Mon, 16 Jun 2025 09:28:00 +0100

Since my last post about this in 2024-03, LLMs have become a distinctly positive addition to my ability.

Unhinged rant about software

Fri, 27 Sep 2024 18:14:00 +0100

Modern software practices and their sadness.

ChatGPT's effect on my programming

Wed, 27 Mar 2024 12:01:00 +0000

After a decent while programming with ChatGPT, I’m not sure it’s even a net positive on my ability.

YAML is not a superset of JSON

Thu, 14 Mar 2024 00:12:00 +0000

All the reasons I know for why YAML is not a superset of JSON.

Why does no-confusion use equality rather than a recursive call?

Fri, 01 Mar 2024 13:51:00 +0000

A question about the definition of a no-confusion type.

Starting a suspended process

Fri, 19 Jan 2024 18:51:00 +0000

How to start a process into a suspended state on Linux

Squashed stacked PRs workflow

Wed, 18 Oct 2023 20:36:00 +0100

How to handle stacked pull requests in a repository which requires squashing all history on merge.

Nix fireside chat outline

Thu, 05 Oct 2023 20:00:00 +0100

A talk I gave at work about the Nix build system.

Property-based testing introduction

Sun, 01 Oct 2023 20:53:00 +0100

A talk I gave at work introducing property-based testing and then giving some more advanced techniques.

Notes for a Git fireside chat

Wed, 06 Sep 2023 13:51:00 +0000

A syllabus for a fireside chat to give at work, on Git

Crates (existentials in F#)

Tue, 19 Oct 2021 00:00:00 +0000

An introduction to the crate pattern for representing existential quantification in F#.

Metatesting your property-based tests

Thu, 27 May 2021 00:00:00 +0000

A rather little-known but very easy and high-reward way to sanity-check your property-based tests.

In praise of `--dry-run`

Fri, 21 May 2021 00:00:00 +0000

First-class support for a –dry-run mode makes a tool more maintainable, more testable, and more user-friendly.

Continuation-passing style

Mon, 22 Mar 2021 00:00:00 +0000

Motivating the technique of continuation-passing style, by looking at recursive functions.

Rewriting the Technical Interview, in Mathematica

Wed, 17 Mar 2021 00:00:00 +0000

An exploration into reaching into the internals of Mathematica to natively evaluate C code.

Software engineer syllabus

Wed, 03 Feb 2021 00:00:00 +0000

An incomplete but growing list of things I would make mandatory reading if I were building a software engineering syllabus.

Cyclic dependencies (a note from Hacker News)

Sat, 30 Jan 2021 00:00:00 +0000

A quick note from Hacker News about how to model in F# something that might look like cyclic dependencies.

Find the Bug, C# edition

Mon, 18 Jan 2021 00:00:00 +0000

A cute little exercise in bug-spotting.

A bug in Git

Mon, 28 Dec 2020 00:00:00 +0000

A bug I found and reported in Git.

Nulls and options (a note from Hacker News)

Sat, 10 Oct 2020 00:00:00 +0000

A quick note from Hacker News about why we want optional types but why ’null’ is unintuitive.

In favour of recursive functions, not imperative constructs, to make loops

Wed, 22 Jul 2020 00:00:00 +0000

How to write loops immutably and safely.

Static config (a note from Hacker News)

Sun, 05 Apr 2020 00:00:00 +0000

A quick note from Hacker News about my preference for static config rather than dynamic.

Defunctionalisation

Wed, 04 Mar 2020 00:00:00 +0000

An underappreciated tool for writing good software.

MIT Mystery Hunt 2020 answers

Thu, 16 Jan 2020 00:00:00 +0000

A couple of solution documents I made during the progress of the 2020 MIT Mystery Hunt.

MIT Mystery Hunt 2019 answers

Wed, 16 Jan 2019 00:00:00 +0000

A couple of solution documents I made during the progress of the 2019 MIT Mystery Hunt.

Chatting with Don Syme about the F# compiler

Mon, 10 Sep 2018 00:00:00 +0000

Notes from a chat with the creator of F#, about how to contribute to the compiler.

Dependent types overview

Sat, 21 Jul 2018 00:00:00 +0000

A quick overview of dependent types.

JSON comments (a note from Hacker News)

Sat, 02 Jun 2018 00:00:00 +0000

A quick note from Hacker News about why the comment-handling situation in JSON is bad.

Clojure and Exercism

Mon, 28 Mar 2016 00:00:00 +0000

I’ve been trying to learn Clojure through Exercism, a programming exercises tool. It took me an hour to get Hello, World! up and running, so I thought I’d document how it’s done. I’m using Leiningen on Mac OS 10.11.4.

Python, script shadowing

Tue, 26 Aug 2014 00:00:00 +0000

A very brief post about the solution to a problem I came across in Python.

In the course of my work on Sextant (specifically the project to add support for accessing a Neo4j instance by SSH), I ran into a problem whose nature is explained here as the Name Shadowing Trap. Essentially, in a project whose root directory contains a bin/executable.py script, which is intended as a thin wrapper to the module executable, you can’t import executable, because the bin/executable.py shadows the module executable.

Introduction to functional programming syntax of Mathematica

Fri, 24 Jan 2014 00:00:00 +0000

Recently, I was browsing the Wolfram Community forum, and I came across the following question:

What are the symbols @, #, / in Mathematica?

I remember that grasping the basics of functional programming took me quite a lot of mental effort (well worth it, I think!) so here is my attempt at a guide to the process.

In Mathematica, there are only two things you can work with: the Symbol and the Atom. There is only one way to combine these things: you can provide them as arguments to each other. We denote “\(x\) with arguments \(y\) and \(z\)” by “x[y,z]”.