Ben Clews - Software Engineer

Dockerfile Linters Beyond Hadolint

Mon, 17 Aug 2026 10:00:00 +1000

droast got a passing mention in a recent conversation: it is a Rust Dockerfile linter that prints snarky remarks alongside its findings. I went to look it up expecting a five-minute note, and instead lost an evening to it, because the comparison chart it leads with says 3.90× FASTER in large type, and I couldn’t work out why anyone would care…

Linting a Dockerfile doesn’t take long enough to have a throughput problem. So either the number was measuring something that doesn’t matter in practice, or I was missing something. I suspected the latter, so went digging.

Why the Patient Doesn't Know the Answer

Tue, 21 Jul 2026 10:00:00 +1000

This is the third and last post in a short series about building an AI pharmacy simulator. In the previous post I wrote about keeping the clinical facts out of the model and in a file a pharmacist controls. This one is about the other decision the design leans on, which is splitting the patient and the examiner into two separate prompts.

As with the rest of this series, I’m writing as a practitioner rather than a security or assessment expert, which matters more here than in the other posts, because this one strays into territory with real adversaries and a real research literature. Where I make a claim about how these systems fail, I’ve tried to anchor it to people who study that for a living.

Why the Model Doesn't Decide the Medicine

Tue, 14 Jul 2026 10:00:00 +1000

Earlier I wrote about building an AI pharmacy simulator by directing agents, and I promised to come back to the two design decisions that make it work. This is the first of them. It took me the longest to get right, and it’s the one I’d reach for again on any project where being wrong costs something.

Same disclaimer as last time, briefly: I’m a software engineer, not a pharmacist, and the clinical side of this leans on my wife, who teaches pharmacy practice. I’m still fairly new to building with language models. So where I lean on a claim about how these models behave, or about the clinical facts, I’ve tried to point at something firmer than my own say-so.

What I Learned Building an App by Directing AI Agents

Tue, 07 Jul 2026 10:00:00 +1000

My wife is a pharmacist who teaches pharmacy practice at our local university, which is how I ended up here, building an AI patient simulator demo.

It started around 2023, when ChatGPT took off and a lot of academic staff were rattled by how easily it let students cheat, a concern that was reflected in the academic literature of that year. My wife and I chatted about it and our prevailing view was that trying to block or limit these tools was a losing game, and the more useful move was to integrate LLM tools into the teaching. One idea we landed on was a prompt a student could paste into a chatbot during a lab or tutorial, so the model would role-play a patient and the student could practise a counselling conversation on the spot. It worked remarkably well. Students liked it, and my wife has gone on to write a whole set of these role-play prompts.

Creating Patches in a Colocated Jujutsu Repo

Wed, 27 May 2026 11:30:00 +1000

Today I needed to share a couple of commits as a patch with someone outside the repo, and learned that jj covers half the job. The other half is git, right there in the colocated repo.

Say the graph looks like this and I want wmktltov and lzxnnyks combined into one patch:

@ nomryxuq dev@example.com 2026-05-11 13:21:21 a63b6073
│ (no description set)
○ lzxnnyks dev@example.com 2026-05-08 11:16:43 feature/api-backend bbea56a3
│ Complete API backend (TICKET-123 part 2)
○ wmktltov dev@example.com 2026-05-08 10:47:51 f7db1946
│ Begin API backend (TICKET-123 part 2)

A single combined patch: jj diff –git

jj diff --from "w-" --to "l" --git > backend.patch

w- is “the parent of w”: start before w’s changes and end at l’s content, producing one diff covering both commits’ work. The --git flag is what makes the output applicable: jj’s default diff format is its own human-readable “color-words” style, which git apply and patch can’t consume. --git switches it to standard git unified diff:

Jujutsu in colocated mode: where Git shows through

Wed, 27 May 2026 09:00:00 +1000

In the last post I made the case that you can adopt jj without telling anyone, because it runs on top of your existing Git repo in colocated mode: .git and .jj side by side, push and fetch still going through Git. Turns out, colocated mode has seams.

A seam is a moment where Git and jj look at the same repository and describe it differently: Git says the working tree is dirty while jj says everything’s committed, a routine fetch reports that it “abandoned” a commit, or git am refuses to run. Each one looks alarming the first time, but turns out to be harmless once you understand what Git and jj are each describing.

Recovering a Single File from Jujutsu's Operation Log

Tue, 19 May 2026 11:15:00 +1000

Today I learned how to recover a single file from jj’s operation log without rewinding the whole repo. I thought I’d lost a 76-line markdown file of review notes: it wasn’t in my working copy, and no commit in jj log had it. A jj op restore of the operation before the loss would have brought it back, but it would also have rolled the entire repo to that point, unwinding everything I’d done since.

Jujutsu's rebase Has Three Different "Move" Verbs

Mon, 11 May 2026 11:00:00 +1000

Today I got bitten by jj rebase. I ran jj rebase -r uqxnyrku -o main expecting the descendants to come along, the way git rebase moves a chain. They didn’t. The descendant got reparented onto uqxnyrku’s old parent, disconnecting it from the commit I’d just moved.

The Git muscle-memory model, “rebase moves the chain”, doesn’t translate directly. jj makes you say which chain:

Flag	Moves
`-r REV`	Just that single commit. Descendants get reparented to its old parent.
`-s REV`	That commit and all descendants. The whole subtree comes along.
`-b REV`	The entire branch containing REV (everything between trunk and REV).

-r snipping a commit out and leaving its descendants behind is occasionally what you want (extracting one commit from a stack to relocate it) but it’s almost never what Git muscle memory expects. -s is the verb that matches Git’s default rebase: “move this and everything on top of it.”

Jujutsu Has No git reset --hard: What to Use Instead

Sun, 03 May 2026 10:00:00 +1000

Today I learned that there’s no single jj equivalent of git reset --hard, and that’s by design. Muscle memory wants git reset --hard, git checkout ., or git stash drop, and jj has none of them by name. It has several different verbs, depending on which kind of “reset” you actually mean.

The mental shift: in Git, “discard changes” usually means moving files between zones (working tree → HEAD). In jj, the working copy is a commit, so “discard changes” means either editing that commit’s contents or removing the commit entirely. Pick the verb that matches the intent.

Jujutsu Can Refuse to Push Private WIP Commits

Sat, 25 Apr 2026 09:00:00 +1000

Today I learned that Jujutsu has a built-in guard that blocks specified commits from ever being pushed. You declare it with a revset in your config:

# ~/.config/jj/config.toml (user-level → applies to every repo)
[git]
private-commits = 'description(glob:"wip:*")'

Now any commit whose description starts with wip:, along with all its descendants, is rejected by jj git push, with a local check that fires before any network contact:

Error: Won't push commit 548e973f323b since it is private
Hint: Configured git.private-commits: 'description(glob:"wip:*")'

Parking Messy Local-Only Work

The workflow for stashing scratch work where it can’t accidentally escape:

Jujutsu: less friction, same Git

Fri, 24 Apr 2026 12:51:27 +1000

Jujutsu has been frequently turning up in my feeds over the past year. Always the same pattern: someone extolling its virtues, a workflow that’d be tedious in Git, a flurry of unfamiliar syntax. I’d skim, disengage, return to Git. My workflow is simple. It works. A rebase conflict ruins the odd morning, the odd stash gets forgotten. But… that’s just Git, right? Why should an old git like me switch?

Modernising My Zsh Setup

Thu, 23 Apr 2026 14:30:00 +1000

A few weekends ago I noticed my terminal felt slow. Every new shell made me wait before I could start typing. A quick measurement showed why:

for i in {1..10}; do /usr/bin/time -p zsh -i -c exit 2>&1 | grep real; done

~720 ms of steady-state startup, paid on every tab, split, and zellij pane. A couple of days of tinkering later it was ~190 ms. This post covers how I got there, and what I’d suggest to anyone still running a default oh-my-zsh + powerlevel10k setup.

Reclaiming Disk Space from iCloud Drive on macOS

Fri, 13 Mar 2026 09:20:31 +1100

Today I learned about brctl evict, a macOS command that forcefully removes local copies of iCloud Drive files while keeping them safely in the cloud. It saved me ~400 GB.

The Problem

My MacBook was almost full: 934 GB of 995 GB used. I’d already told iCloud Drive to optimise storage, but it wasn’t making a dent. The Storage panel in System Settings showed 695 GB of “System Data”, which seemed absurd.

Advent of Code 2025, in Rust

Fri, 19 Dec 2025 09:28:22 +1100

Last year I finally took the plunge and completed Advent of Code 2024 in Go. It was hard enough that finishing meant something, and I wanted another go. So when December rolled around again there was no question, except which language. This time: Rust.

This year’s event was shorter, 12 days instead of the traditional 25, but the puzzles were just as brain-bending as ever.

Why Rust?

I’ve been building a CHIP-8 emulator in Rust this year, and it’s been the project that finally made the language click for me. AoC felt like a good way to keep that momentum going as it is smaller, self-contained puzzles where I could practice without the overhead of a larger codebase.

Integer Linear Programming

Fri, 12 Dec 2025 14:07:40 +1100

Today’s Advent of Code highlighted that a small change in problem constraints can turn a straightforward solution into a freakin’ hard optimisation problem.

The Problem: Factory Machine Configuration

You’re faced with factory machines that need configuration. Each machine has buttons that affect multiple counters, and you need to figure out the minimum number of button presses required.

Part 1: Configure indicator lights (on/off states) by toggling them with buttons.

Part 2: Configure joltage counters (integer values) by incrementing them with buttons.

Kruskal's Algorithm: Building Minimum Spanning Trees with Union-Find

Tue, 09 Dec 2025 10:42:11 +1100

Today I learned about Kruskal’s algorithm while solving Advent of Code 2025 Day 8. Sort the edges, add the short ones, skip anything that closes a cycle. That’s the whole thing, and it’s optimal. Pairing it with Union-Find for the cycle check is what makes it fast enough to run.

The Problem

Given junction boxes suspended in 3D space, connect them with the minimum total wire length such that electricity can flow between all boxes. For example, given these 5 boxes:

Monotonic Stacks

Thu, 04 Dec 2025 10:10:20 +1100

This is more of a “Today I Remembered”…

While solving Advent of Code Day 3, I was reacquainted with an elegant pattern: monotonic stacks.

The Problem

Given 15 digits, select exactly 12 (maintaining order) to form the largest possible 12-digit number.

Example: "234234234234278" → "434234234278"

What’s a Monotonic Stack?

A monotonic stack maintains elements in sorted order. When adding a new element:

Pop elements that violate the ordering
Push the new element

Why is this useful? It lets you make greedy decisions while keeping the ability to “revise” earlier choices. In this context a greedy decision means making the locally optimal choice at each step without looking ahead to future possibilities. It can be thought of as “When I see a larger digit, I should use it instead of smaller digits I’ve already selected—as long as I can still reach k total digits.”

Rust's rem_euclid() - The Modulo You Actually Want

Tue, 02 Dec 2025 10:00:00 +1100

Having spent a bit of time working with Python recently, I hit a surprising gotcha with Rust’s % operator today.

The Problem

I was implementing a circular dial (positions 0–99) that wraps around. In Python, this just works:

position = 5
position = (position - 10) % 100 # = 95 ✅

But in Rust, the same logic fails:

let mut position = 5;
position = (position - 10) % 100; // = -5 ❌

Why?

Python’s % operator follows mathematical modulo when the divisor is positive. That means the result is always in the range [0, divisor)—ideal for wrap-around arithmetic.

What Rust Actually Taught Me

Thu, 27 Nov 2025 10:00:00 +1100

Part 2 of 2 | Part 1: Why CHIP-8 | Part 2

In Part 1, I explained why I picked CHIP-8 to learn Rust and how I used AI as a mentor. Now: what actually stuck?

The Compiler as Teacher

The Borrow Checker

I expected to wrestle with the borrow checker constantly. That happened early. Then I figured it out.

When the compiler rejected my code, it was usually because I was doing something subtly wrong, conceptually rather than syntactically. Holding a reference to memory while modifying display state. Trying to share mutable data between threads without synchronization.

Creating Type Stubs for Type Checking Without Installing Dependencies

Mon, 24 Nov 2025 10:00:00 +1100

The Problem

When type-checking Python code, tools like Pyright need to import all dependencies to understand function signatures. But some packages have heavy dependencies (NetCDF libraries, scientific computing stacks, databases) that you don’t want to install just for type checking.

The Solution: Manual Type Stubs

You can create a fake package in your virtual environment that provides type information without any implementation.

How It Works

Python’s import system doesn’t distinguish between packages installed via pip and packages manually created in site-packages. Both are treated identically.

I Built a CHIP-8 Emulator to Learn Rust

Thu, 20 Nov 2025 10:00:00 +1100

Part 1 of 2 | Part 1 | Part 2: What Rust Taught Me

Every few months my organisation runs Engineering Development Days. A few days to learn something new without the distraction of work. Also, job cuts, fun times.

I struggled to think of what to focus on. My role going forward is Python-heavy, cloud-native. Any knowledge gaps I’d fill through actual work. I was bored, feeling uninspired. I needed something compelling.

Quick Python Syntax Checks from the Command Line

Fri, 07 Nov 2025 10:00:00 +1100

Today I learned a handy trick to check Python syntax without running your code. Perfect for catching errors early.

From the Command Line

You can run:

python3 -m py_compile src/app/analysis.py && \
 echo "👍 Syntax is valid – no errors found"

Or for another file:

python3 -m py_compile src/app/server.wsgi && \
 echo "👍 server.wsgi syntax is valid"

How it Works

python3 -m py_compile <file> attempts to compile the file to bytecode (.pyc)
If compilation succeeds, the command after && runs (our little “syntax is good” message)
If there’s a syntax error, Python prints the error and the success message won’t appear

Programmatic Usage

You can also do this programmatically in Python:

Cancelled Projects and the Art of Strategic Indifference

Wed, 24 Sep 2025 15:57:32 +1100

There’s a moment every software engineer will eventually face: the project you’ve poured months into gets shanked. Quietly. In a backroom meeting. Dead. Done. Dusted. Over. Finito.

Not because it was bad. Not because it didn’t work.

Because… someone changed their mind. An executive shuffled a roadmap. A reorg happened. Someone’s ego got bruised. The “vision” moved on, as it always does.

And just like that, it’s dead.

No retrospective. No launch party. No legacy.

Running a Bert Model on an iPhone

Mon, 03 Mar 2025 14:44:48 +1100

During our recent Engineering Development Days, a three-day event where we paused regular work to focus on personal growth, I set myself one goal: take a large pre-trained BERT model built for GPU-heavy environments and get it running on an iPhone. I’d never worked with BERT models, Core ML or mobile deployment before, so most of the three days was spent finding out what I didn’t know.

The Challenge: Bringing a Data Center Model to Mobile

Our team has recently built a text classification API that categorises inputs into labels such as condition, constraint, notice, and process. The engine behind this API was a BERT-large model. BERT-large has 24 transformer layers, a hidden size of 1024, 16 attention heads, and an intermediate layer size of 4096. Those numbers are why it’s good at the task, and also why it’s expensive to run.

Setting Up Postgresql 16 and Postgis on Macos With Homebrew

Mon, 03 Feb 2025 15:42:42 +1100

Recently, I needed to install PostgreSQL 16 with PostGIS on my MacBook M1 Pro (running macOS 15.2), and what I assumed would be a quick brew install postgis turned into a tedious debugging session.

As of now, the Homebrew postgis formula is linked to PostgreSQL 14. To use PostGIS with PostgreSQL 16, you’ll need to compile PostGIS manually. Here are the notes from my experience.

TL;DR: If You’re in a Hurry, Here’s the Script

# Stop PostgreSQL Services
brew services stop postgresql

# Remove existing PostGIS and PostgreSQL@14 to avoid conflicts
brew remove postgis
brew remove postgresql@14

# Reinstall json-c (must be done after removing old postgis)
brew uninstall json-c
brew install json-c
brew link json-c

# Install PostgreSQL 16 (if not already installed)
brew install postgresql@16
sudo ln -sf /opt/homebrew/Cellar/postgresql@16/16.4/bin/postgres /usr/local/bin/postgres
sudo chown -R "$USER":admin /usr/local/bin /usr/local/share

# Install necessary utilities
brew install wget
brew install pcre

# Fix issues with missing gettext headers
brew reinstall gettext
brew unlink gettext && brew link gettext --force

# Install PostGIS dependencies
brew install geos gdal libxml2 sfcgal protobuf-c

# Download and build PostGIS 3.5.2 from source
wget https://download.osgeo.org/postgis/source/postgis-3.5.2.tar.gz
tar -xvzf postgis-3.5.2.tar.gz
rm postgis-3.5.2.tar.gz
cd postgis-3.5.2

# Use the correct gettext version
GETTEXT_VERSION=$(brew info gettext | grep -Eo 'stable [0-9]+\.[0-9]+' | awk '{print $2}')

./configure \
 --with-projdir=/opt/homebrew/opt/proj \
 --with-pgconfig=/opt/homebrew/opt/postgresql@16/bin/pg_config \
 --with-jsondir=/opt/homebrew/opt/json-c \
 --with-sfcgal=/opt/homebrew/opt/sfcgal/bin/sfcgal-config \
 --with-pcredir=/opt/homebrew/opt/pcre \
 --without-protobuf \
 --without-topology \
 LDFLAGS="$LDFLAGS -L/opt/homebrew/Cellar/gettext/$GETTEXT_VERSION/lib" \
 CFLAGS="-I/opt/homebrew/Cellar/gettext/$GETTEXT_VERSION/include"

make
make install

The Pain Points

1. Homebrew’s PostgreSQL Versions Can Clash

If you have postgresql@14 or an older version installed, you might run into conflicts. You might see errors like:

Advent of Code 2024

Tue, 28 Jan 2025 08:43:40 +1100

Every December, Advent of Code turns up in my feeds and I feel roughly equal parts keen and dread. It’s a yearly programming challenge that wraps algorithmic problems in a festive narrative.

For years, I flirted with the idea of participating. And for years, I always found a way to dodge it. Sometimes, I’d forget about it until a stray tweet reminded me a week into the event, leaving me feeling hopelessly behind. Other times, summer holidays and the thought of spending time glued to a screen felt like a crime. And, honestly? The puzzles kind of intimidated me. They felt like they were tailor-made to expose every weak spot I had. It was always easier to skip it than risk confirming my doubts.

Simplifying Remote Docker Builds With SSH and Contexts

Tue, 03 Dec 2024 10:03:12 +1100

Recently, I’ve been making a conscious effort to eliminate lazy practices from my workflow: the kind of ’temporary’ workarounds that sneak in during crunch time and somehow become permanent habits. My latest offender? A convoluted method for building containers on remote machines. Instead of using a branch like any reasonable person (for reasons I can’t even justify), I’d generate a git patch locally, SCP it to the remote machine, apply it there, and then build. It’s the software equivalent of taking the scenic route while ignoring the perfectly good highway right in front of me.

Taming the Noise: Decoding Kubernetes Logs for Humans

Fri, 29 Nov 2024 15:38:16 +1100

Hallucino, my Kubernetes log analyser, came out of a rare two days with no deadlines attached. During an Engineering Development Day event, a pause to focus on personal growth, I had a go at building an “intelligent” tool that could make sense of the noisy, chaotic world of Kubernetes logs.

Kubernetes logs are a labyrinth. In large, distributed systems, logs pour in from countless containers, pods, and nodes, and the lines that would actually help you resolve an outage are buried under everything else. I wanted to see whether a Large Language Model plus Go’s concurrency could turn that stream into something a little more human readable.

Managing Dotfiles With Gnu Stow

Wed, 06 Nov 2024 13:53:32 +1100

Dotfiles can be a pain to manage when they’re scattered across your home directory. In the past, I used a bare Git repo approach based on StreakyCobra’s setup on Hacker News. It worked well but had its limitations, like needing a custom alias for Git commands (which I’d often forget) and some tricky troubleshooting when configs broke.

Recently, though, I switched to using GNU Stow after reading Brandon Invergo’s guide. Stow is a simple symlink manager originally for managing software installed from source. It keeps all your dotfiles in one directory and links them to where they need to be, so your home directory stays tidy and the whole lot is easy to version.

About

Sat, 18 May 2024 22:12:34 +1000

Hey! I’m Ben Clews, a software engineer calling Hobart, Tasmania home.

I spend my days turning complex tech challenges into elegant solutions, currently as a Software Engineer at CSIRO’s Data61. We’re building some cool stuff that helps researchers manage their data and run powerful analytics - basically making it easier for science to make a real impact.

When I’m not coding, you’ll find me hunting out new music, whisky and craft chocolate (yes, probably in that order). I brew small batches of beer, attempt to bake bread (with varying success), and love exploring new cities with my camera in hand.