Ben Clews - Software Engineer

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, having used 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: A Rust-Flavored Journey

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 challenging, rewarding, and left me wanting more. So when December rolled around again, there was no question: I was coming back for round two. This time, though, I wanted to push myself in a different direction: Rust.

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

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 transform 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. What struck me most was how elegantly the greedy approach works. It seems almost too simple to be optimal, yet the proof is surprisingly straightforward. Pairing it with Union-Find for cycle detection makes the whole algorithm both intuitive and efficient.

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 Is a Teacher

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 tools, databases, etc.) 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 tackled a challenge that was both technically demanding and rewarding. The goal was straightforward yet ambitious: adapt a large pre-trained BERT model, originally designed for GPU-heavy environments, to run efficiently on an iPhone. This was uncharted territory for me, as I had never previously worked with BERT models, Core ML or mobile deployment. The learning curve was steep, yet fun.

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, an event pops up in the software development world that stirs excitement, dread, and inspiration in equal measure: Advent of Code. It’s a yearly programming challenge that combines festive themes with algorithmic problem-solving, drawing in developers from all walks of life.

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

Some projects emerge from necessity, others from curiosity. Hallucino, my Kubernetes log analyser, came from a rare chance to set aside deadlines, deliverables, and sprint boards in favour of learning and exploration. During an Engineering Development Day event, a two-day pause to focus on personal growth, I dove into the challenge of crafting an “intelligent” tool that could make sense of the noisy, chaotic world of Kubernetes logs.

Kubernetes logs are a goldmine of information, but also a labyrinth. In large, distributed systems, logs pour in from countless containers, pods, and nodes. Amid this flood are hidden gems: critical insights that can resolve outages, optimise performance, or detect brewing problems. But the sheer volume often buries their value. I wanted to explore the possibilities of combining modern Large Language Models (LLMs) with Go’s concurrency capabilities to transform unstructured logs 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. The beauty of Stow is that it keeps all dotfiles neatly organized in one directory and links them to where they need to be, which keeps your home directory clean and makes version control easier.

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.