semikolan

The Markdown reference

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

Headings

H1 · Heading one

H2 · Heading two

H3 · Heading three

H4 · Heading four

H5 · Heading five

H6 · Heading six

Inline formatting

Text can be bold, italic, bold italic, ~~struck through~~, or inserted. You can highlight a phrase to draw the eye, drop in inline code, and link to another post.

When Big-O Lies

Mon, 20 Jul 2026 00:00:00 +0000

There’s a particular kind of confidence that comes from writing O(n log n) in a design doc. It feels like a proof. And it is one — about a limit you will, in practice, never reach.¹ The trouble starts when we treat the asymptote as advice for the machine in front of us.

Last week I replaced a “slow” quadratic scan with a “fast” sort-then-sweep. The theory was unimpeachable. The result was slower — for every realistic input we actually saw.

Pretty-print JSON in one shell pipe

Sat, 18 Jul 2026 00:00:00 +0000

When you just want to read an API response and don’t feel like installing anything:

bash

curl -s https://api.example.com/thing | python -m json.tool

python -m json.tool ships with every Python install and pretty-prints stdin. No jq, no dependencies. Here’s the whole thing, command and output:

bash

$ echo '{"name":"ada","langs":["go","rust"]}' | python -m json.tool
{
    "name": "ada",
    "langs": [
        "go",
        "rust"
    ]
}

For anything more than eyeballing — filtering, reshaping — reach for jq. For a quick look, this is already on your machine.

git switch beats git checkout

Thu, 09 Jul 2026 00:00:00 +0000

git checkout does too much: it moves branches, restores files, detaches HEAD, and creates branches — all under one overloaded verb. That’s why it’s a classic source of “I ran the right command and lost my changes.”

Since Git 2.23 the job is split into two honest commands:

git switch -c new-feature   # create and move to a branch
git switch main             # move to an existing branch
git restore path/to/file    # discard changes to a file

switch only changes branches. restore only touches files. The name tells you the blast radius before you hit enter.

git commit --fixup and autosquash

Thu, 02 Jul 2026 00:00:00 +0000

When review feedback belongs in a commit three back, you don’t have to hand-edit a rebase todo. Mark the fix, then let Git sort it:

git commit --fixup=<sha>          # stages a "fixup! <subject>" commit
git rebase -i --autosquash main   # reorders and squashes it automatically

--fixup writes a specially-named commit; --autosquash recognizes the name, moves it next to its target, and pre-marks it as fixup in the todo list. You just confirm. Set git config --global rebase.autosquash true and the flag is on by default.

The Quiet Cost of a Fast Loop

Tue, 30 Jun 2026 00:00:00 +0000

The first time I saw a sorted array process faster than an identical unsorted one, I assumed I’d measured wrong. Same data, same instructions, same count. The only difference was order — and order, I’d been taught, doesn’t change complexity.

It doesn’t. It changes the constant, and the constant is a physical thing living in the branch predictor.

The branch that couldn’t guess #

A modern CPU runs ahead of itself. When it hits an if, it doesn’t wait to learn the answer — it bets, and speculatively executes the branch it thinks you’ll take. Guess right and the work is already done. Guess wrong and it throws away a dozen in-flight instructions and starts over.

Go's errors.Join

Sat, 27 Jun 2026 00:00:00 +0000

Before Go 1.20, returning “here is everything that’s wrong” meant building your own error slice type. Now the standard library does it:

func validate(u User) error {
    var errs error
    if u.Name == "" {
        errs = errors.Join(errs, errors.New("name is required"))
    }
    if u.Age < 0 {
        errs = errors.Join(errs, errors.New("age must be non-negative"))
    }
    return errs // nil if nothing was joined
}

errors.Join ignores nil arguments, so the accumulate-in-a-loop pattern just works. And errors.Is / errors.As still see through the joined result to each underlying error.

Go's defer runs in LIFO order

Thu, 18 Jun 2026 00:00:00 +0000

Multiple defer statements in a function run in reverse order — the last one deferred runs first:

func process() {
    f := open()
    defer f.Close()      // runs second

    tx := f.Begin()
    defer tx.Rollback()  // runs first
    // ...
}

This is the right default: teardown happens in the reverse of setup, so inner resources release before the outer ones they depend on. It mirrors how a stack unwinds — which is the whole point.

Reading the Standard Library for Fun

Thu, 11 Jun 2026 00:00:00 +0000

The standard library is the best-reviewed code most of us will ever have free access to, and almost nobody reads it. I’ve started treating it like a museum you’re allowed to touch — pick one function, follow it all the way down, and notice every decision that isn’t the obvious one.

sort.Slice is not quicksort #

If you’d asked me to implement sort.Slice, I’d have written quicksort and moved on. Go’s implementation is a pattern-defeating quicksort — pdqsort — and the difference is a catalogue of the ways plain quicksort betrays you in production.

Cache Invalidation, Mostly Naming

Tue, 12 May 2026 00:00:00 +0000

The joke is that there are two hard problems in computer science: cache invalidation and naming things. I’ve come to think they’re the same problem wearing two hats.

What a key really is #

A cache key is a name for a claim: “the answer to this question is that value.” Invalidation is just noticing the claim stopped being true. The reason invalidation is hard is almost never the eviction mechanics — it’s that the key doesn’t actually name the claim.

The Profiler Is Always Right

Fri, 03 Apr 2026 00:00:00 +0000

I keep a mental list of times I was certain I knew where the time was going, ran a profiler to confirm it, and got humbled. The list is long. The profiler’s record against me is perfect.

The bottleneck was never where I looked #

I’d stare at the gnarly nested loop, the obvious O(n²), and optimize it for an afternoon. The profiler would then point, flatly, at a json.Marshal call in the logging path that ran on every request. The scary algorithm ran twice a day. The boring serialization ran a million times an hour.

Tools I Use

Sun, 01 Feb 2026 00:00:00 +0000

A snapshot of what I reach for. It changes slowly — I tend to keep tools until they actively get in my way.

Editor & terminal #

Neovim with a config I maintain as kolan.vim. LSP, Telescope for fuzzy everything, Treesitter.
Ghostty as the terminal. Fast, GPU-accelerated, sensible defaults.
tmux for sessions that outlive the terminal window.
fish shell for interactive use, POSIX sh for anything I’d commit.

Languages & build #

Go for services and CLIs — fast builds, boring concurrency, one binary out.
Rust when I need the guarantees or the last 20% of performance.
SQLite for local tools, Postgres for anything that outlives a process.

Hardware #

14" MacBook Pro (M-series) — the fans have never turned on.
A mechanical keyboard with tactile switches, because I stare at it all day.
One external monitor. Two felt like more context-switching, not less.

Also on the machine #

ripgrep and fd — I haven’t typed grep or find in years.
jq for JSON, hyperfine for benchmarks, git for everything.

Reading List

Thu, 15 Jan 2026 00:00:00 +0000

No rating system and no particular order. If a book is here, it earned the time and changed how I think about something.

Recently #

The Art of Doing Science and Engineering — Richard Hamming. Half technique, half career advice from someone who watched computing get invented. The “you and your research” chapter is worth the whole book.
A Philosophy of Software Design — John Ousterhout. The clearest argument I’ve read that complexity is the enemy and deep modules are the cure. Short, opinionated, correct.
Designing Data-Intensive Applications — Martin Kleppmann. The book I wish I’d had before I ever touched a distributed system. I re-read a chapter roughly every time I break production.

Older, still with me #

The Mythical Man-Month — Fred Brooks. Fifty years old and still describes every project I’ve been on.
Working in Public — Nadia Eghbal. Changed how I think about open source maintenance and the cost of “free.”

A Year of Reading Postmortems

Tue, 02 Dec 2025 00:00:00 +0000

I spent last year reading one public postmortem a week — outages from companies large enough to be forced into candor. I expected exotic failures. What I found was the same three or four stories wearing different logos.

The retry that became the outage #

The single most common shape: a small failure triggers automatic retries, the retries multiply the load, and the load turns a blip into a self-sustaining fire. The system’s own recovery mechanism is the accelerant.

The Case for Boring Databases

Sun, 14 Sep 2025 00:00:00 +0000

My default database is Postgres, and my second choice is also Postgres. This isn’t nostalgia. It’s that “boring” is a technical property, and it’s one I want more of as a system gets important.

What boring buys you #

A boring database is one whose failure modes are already written down — in blog posts, in Stack Overflow answers, in the scar tissue of every engineer you’ll ever hire. When it’s 3am and something is wrong, you are not the first person to see this error. That is worth more than almost any feature.

Search

Mon, 01 Jan 0001 00:00:00 +0000