Skip to content

Still Brook.

Observations & other curiosities

Notes on software
and the things
we make.

Open the notebook
An engraved computer on spindly legs beside a brook, with a bird, a leafy twig, and a curling paper tape.
Fig. 01 — A machine for wandering thoughts.

Latest essay

A couture show has two customers for each camera frame. The archive wants every stitch. The backstage monitor wants whatever just happened. Jai and Goose put a very different price on that handoff.

Read the essay
A model in a pleated red coat turns on top of a film camera.
Illustration generated with GPT Image

Pages from the notebook

107 of 133 essays

107 essays found. Page 8 of 9.

  1. The route changes the road

    SUMO confronted the feedback between route choice and congestion in its earliest design, then made routing and simulation correct each other through an explicit iterative toolchain.

  2. The branch predictor cannot force your thunk

    Compiling a lazy functional language to WebAssembly works best when demand analysis removes thunks before lowering; branch hints can only annotate the predictable control flow left behind.

  3. The round-trip test

    Bun's Rust rewrite changed the language, implementation, review process, and security budget at once; an LLM port back to Zig would reveal which improvement came from where.

  4. The cabinet of impossible machines

    Five languages from one archived esolang repository show what happens when functions, bits, sets, a self-modifying machine description, or Peano arithmetic is forced to carry an entire program.

  5. The runtime surplus

    WebAssembly has an engine surplus because runtimes can compete independently while useful contracts, packages, debugging, and deployment require ecosystem agreement.

  6. Polish does not compile

    Polish makes a terrible programming language because too much of each sentence lives outside the text, in the speaker and the conversation.

  7. Functional before runtime

    Zig's comptime can compose functions and types into specialized programs while the runtime keeps allocation and control flow in plain sight.

  8. Grain meets you halfway

    Trying Grain convinced me that functional language design becomes approachable when algebraic data types feel ordinary, mutation is explicit, and WebAssembly stays a deployment detail.

  9. Thirty-two bytes at once

    In stable Rust, a practical SIMD workflow keeps the scalar loop around as the oracle for one fenced AVX2 kernel and lets the benchmark decide whether the kernel survives.

  10. Straight to the module

    Hand-written WebAssembly is a pleasure while the whole contract fits on one screen, and misery the moment it needs an ABI.

  11. Fail where the fault lives

    Fail-fast is a debugging rule about exposing faults near their cause; reliable systems contain the damage there and make recovery explicit rather than crashing broadly.

  12. The architecture diagram shrank

    Cloudflare keeps folding routing, state, durable work, browsers, containers, and AI into one programmable surface, and that compression is the real advantage.

A note in the margin

A little curiosity goes a long way.

Still Brook is an independent journal about software, systems, and the quiet decisions that shape what we make.