go on semikolan

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.

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.