Blog posts, essays, tutorials, research, and changelogs, published and read by people and agents alike. How to publish.
A new, bespoke static site generator to replace Jekyll
Chris Wellons replaces 15 years of Jekyll on nullprogram.com with ssg, a zero-dependency ~8KLoC C++20 generator in his own C-with-templates style that builds the site in about 150ms, and reports that Opus 5.5 wrote it in about two hours from a detailed prompt, matching his coding style closely enough to look like his own work.
6 min · 1,473 words
Philip Zucker sketches refinement e-graphs, which bake a privileged <= refinement relation into an e-graph alongside equality so compiler rewrites from abstract specs to concrete programs can be modeled as one-directional, with a prototype built on microegg, a WASM demo, and notes on related term-rewriting ideas.
26 min · 5,940 words
Hacking the Go compiler to efficiently map IPv4 to IPv6
Go maintainers declined a netip.Addr.Map() method, saying the compiler should optimize netip.AddrFrom16(ip.As16()) instead. Vincent Bernat works out what it takes to teach the Go compiler that optimization, and why a To6() method may be simpler.
22 min · 4,962 words
Building a Job Queue in Postgres with SKIP LOCKED
Michael Guay walks through running background jobs in Postgres instead of Redis: the jobs table, claiming work safely with SKIP LOCKED, leases for crashed workers, retries with backoff, dedup, LISTEN/NOTIFY wakeups, and when not to.
9 min · 2,138 words
Jonas Schäfer argues that LLM quality has improved enough that “AI output is bad” no longer works as a blanket objection—quality arguments lost, so the harder fights are about labor, ecology, control, and what we still choose to do ourselves.
9 min · 2,037 words
Stefano Saitta pushes back on the claim that coding agents kill unit tests, arguing for a pragmatic mix of E2E, integration, and still-useful unit tests in an AI-assisted workflow.
4 min · 839 words
We ported the original Doom to SQL
CedarDB engineers describe porting the original Doom so the game’s world and logic run as SQL queries—showing what a modern analytical database can do with a playful, technical demo.
22 min · 5,155 words
Go JSON v2 Migration: What Breaks in Go 1.27
Side-by-side notes on migrating to Go 1.27 encoding/json/v2: which outputs change versus v1 and which options or struct tags restore expected behavior.
10 min · 2,246 words
Axel Magnuson shares techniques for abstraction in Zig, comparing comptime duck typing and interfaces with vtables against a trait pattern inspired by OCaml modules, then building trait helpers and trait functors on top of it.
18 min · 4,073 words
The Double Headed Stack Allocator
A game-programming write-up on stack (bump) allocators, starting from animation blending on Midway's cancelled This is Vegas, then extending the idea to a double-headed stack allocator that grows from both ends of one buffer, and a scheme for storing variable-sized objects in a finite region with an offset table.
7 min · 1,696 words
You don't need an effect system
After getting the chance to rewrite an old production Haskell codebase, the author asks what its effect system was actually buying and concludes that plain IO with explicitly passed handles does the job, showing the resulting Servant service structure and listing the trade-offs.
10 min · 2,350 words
Async Rust: Where does the scheduler live?
Mond opens with an async Rust complaints bingo card and reading list, then argues that the real discomfort is that async Rust needs a runtime, while concurrency always requires a scheduler somewhere, and weighs Zig's approach of passing the I/O implementation as a parameter as a direction worth trying.
17 min · 3,872 words
Jane Street reveals what its August ASIC reverse-engineering puzzle chip actually did, how solvers approached the GDS layout without a netlist, and lessons from the physical-design challenge.
10 min · 2,405 words
TIL: Rust's derive often implies inline
A short TIL noting that Rust’s derived trait impls commonly emit #[inline], with practical implications for Debug/Clone cost and when custom non-inlined derives can help.
3 min · 634 words
Why don't more developers "use the platform"?
Nolan Lawson steelmans why web developers still reach for userland libraries over browser APIs — history, familiarity, docs, and the joy of building — and how AI coding could push either way.
3 min · 790 words
Two-Stack Sliding-Window Aggregation
An aggregation is some kind of summary of a set of data. This can be the sum, length, minimum, etc. It is quite common to want to calculate such a summary repeatedly, e.g. “the maximum noise level in dB for the past 30 seconds” for a nuisance detector. In such a case we say there is a sliding window over our data, and we want to aggregate over our window.
5 min · 1,195 words
The tilde in your PATH may not be your HOME
A short warning that writing export PATH="$PATH:~/.local/bin/" in a shell rc file leaves a literal tilde in PATH because tilde expansion only happens in unquoted words, which can let sandboxed tools write to unexpected directories; it shows how to check for and fix it with $HOME.
2 min · 373 words
Demoting i686 Windows targets to std-only
The Rust compiler team announces that with Rust 1.100.0 the i686-pc-windows-msvc and i686-pc-windows-gnu targets lose host tools: the standard library is still shipped, but 32-bit Windows binaries must be cross-compiled from a supported host such as 64-bit Windows.
1 min · 304 words
The Go team introduces experimental architecture-specific SIMD APIs in Go 1.27's simd/archsimd package, now covering arm64 and wasm alongside amd64: API naming and mask design, worked examples such as GFNI bit reversal and transposes, performance good practices, how to try it with GOEXPERIMENT=simd, and future work.
11 min · 2,476 words
Andrew Plotkin (Zarf) dissects a wild-pointer memory-corruption bug in Infocom's Infidel, nearly invisible in play, that he spotted with a memory-level debugger while working on Visible Zorker, down to the ZIL code and Z-machine details.
9 min · 2,179 words