Notes

A Ruby implementation written in my language Mere, run under a test that collects every 50 safepoints, passed 6 GB and kept going. There were three causes. One was a quadratic walk in the runtime. Another was macOS's malloc: today's macOS keeps freed memory in both the resident size and the footprint, and gives none of it back when asked, so region blocks of 16 KB or more are now mapped and unmapped. I first decided Linux needed nothing, because glibc returns large blocks -- then measured, and Linux passed 6 GB in 17 seconds: glibc's mmap threshold rises once a mapped block is freed. A program now fixes it when it starts. Nothing is freed later than before, ordinary programs run at the same speed, and the programs that blew up hold 24-31% less. I got it wrong twice along the way.

Go 1.27 turned its SIMD experiment into a platform-independent package. I set its design, feature by feature, against the SIMD my own language Mere already had, and measured each one before deciding. One feature came across -- fused multiply-add, 1.4x on a vertex transform -- and on WebAssembly, which has no fma instruction, it had to be written in integers and checked against the hardware, case by case, hundreds of millions of times. Six did not come across, each for a measured reason. The gate for the one that did found two unrelated compiler bugs.

Erdős problems are falling for a few hundred dollars each, while only 28% of enterprise AI projects fully achieve ROI. That gap doesn't correlate with difficulty. What the winning fields share is a way to check whether an output is correct without a human judging it.

mere-ruby's IO was weak, and the reason looked obvious: its File has no file descriptor. I was about to add one. Measuring first showed the descriptor would fix eight rows of thirty-five — and the work I did instead uncovered two ordinary bugs that the structural explanation had been covering for. On why the order of work decides what you are able to find.

Suno and Udio get the headlines, but what actually shifted the ground under music was source separation, automatic transcription, and OMR — the technologies that take music apart. A 2026 survey from the perspective of someone who plays piano.

I read Gleam's compiler next to my own — Mere, an ML-family language with five backends — five times over, and took fifteen things from it. Eleven were wires to answers my compiler already computed; only two were language features. The borrowings were not the return. What paid was that copying forced one small feature through all five backends and made me write a gate for every item, and that is how nine defects came out — including one that had shipped.

mere-ruby is a Ruby-subset interpreter written in Mere, my own small ML-family language. Producing its conformance record took ninety minutes, and I had never measured why. A day spent making that sweep honest instead of making the interpreter fast — where every fix was caught, corrected or killed by a measurement, including six of my own ideas and one retraction that turned out to be the error.

Two days after writing up a container stack, I went looking for leftovers. I found a default disk that every test had avoided, a number I had printed because I could not explain it, a capability I had called meaningless without asking the kernel, and a help text that deleted two commands when I documented one option. All four had a check sitting next to them, agreeing with the others.

A VMM on Hypervisor.framework, a daemon that speaks the Docker Engine API, an OCI runtime, a registry, tar and gzip — written in a small ML-family language of my own, until the real docker CLI connected to it unchanged. What that maps to in published specifications, what it deliberately does not do, and the bugs that only showed up when something real was asked of it.

I asked why my Ruby interpreter lived in one 54,063-line file. The answer was not that I preferred it that way — it was that the language could not express the split. Getting to 30,392 lines took no language change; the last 29,606 took a new declaration form, which then landed with four defects that seven green unit tests could not see.

A text editor in my own language that never loads the file: 208 MB opens in 0.5 s at 24.7 MB. But the editor was not the yield. Ten of its eleven findings went into the language, and five of those lived where the existing test suite structurally cannot look — including an editor I published two months ago that could not be saved or quit from in a real terminal.

A status note on one language's Wasm backend: capabilities lowered to WASI interfaces, real network programs running as components on two hosts, a threading wall that turned out not to be WASI's, and a playground that had quietly tripled in size because nobody was measuring it. The whole of it is 1,064,718 bytes down to 616,025.

Three weeks of adding SIMD to a small self-hosted language with five backends: hoisting bounds checks so clang can vectorize, two 128-bit types, and RISC-V vector instructions on a CPU the language wrote for itself. What paid, what did not, and the four properties of a loop that decide which.

A measurement note. Ruby has SIMD in its JSON extension and its parser, but not in the encoding scan that every string from a file or socket goes through. On this machine, reading 4 MiB of Japanese text costs 15 ms of scanning; the same file in ASCII costs nothing. Here is how that was verified and what it would take to fix.

An attempt to define the best possible web application framework from first principles — eight problems derived from the definition of a web app, nine design decisions each paired with the evidence that would overturn it, and seven gates that almost nobody ships.

Every company that clamped down on AI spending in 2026 did it in the same order — and got the question wrong. Notes on allocating AI budget across roles.

The diagnosis is right: with AI writing the code, the bottleneck moves from generation to verification. The prescription is usually written in language features — types, formatting, fast compiles, a thick standard library. Checked against one week of logs, not one of the things that actually caught an error was inside the language.

A subscription leak in a small app turned into a question about the language, and the answer was no. Two starting premises — faster is better, do not depend on a collector — were a purchase, and the things Mere cannot do are the invoices arriving one at a time.

Adding a fifth backend sounds like more capability. The truer story is a loop closing: a self-hosted compiler met a CPU the language had already written, and most of the new power was recombination — not a new target, but two old dogfoods finally allowed to meet.

A survey of recent trends in programming language design and implementation across five axes — memory safety, concurrency, type systems, implementation toolchains, and cross-cutting design philosophy — followed by an honest look at whether effect systems, the hottest topic in the field, will actually turn out well: their tailwinds, headwinds, and most likely landing place.

Adding a feature is visible work. Deciding not to add one — and being able to show why — is the harder half of language design.

Now that AI tools have made 'the ability to build' itself cheap, value shifts to everything *other than* building. Sorting what gets commoditized from what stays scarce, and reasoning from four sources of hard-to-copy-ness — physical/regulatory reality, proprietary data and trust, taste, and the compounding of time — toward what is actually advantageous to build.

Key signatures, relative keys, diatonic chords, and progressions all connect on a single wheel. An interactive circle of fifths that plays sound when you click.

A survey of how modern web UIs are actually built — VDOM, signals, compile-time reactivity, web components, server-driven, FRP, islands, resumability, state machines, functional UI — collected while deciding what frontend story my own programming language should aim for.

What determines whether a sequence of characters can be heard as music? A note on character-to-pitch mapping, the cognitive ceiling around 5–9 pitches, and why Japanese hiragana is unusually well-suited to sonification.

Integrating Bedrock and shipping an MCP server is the minimum bar in 2026. Everything beyond is a waiting game.

Other people's casual evaluations don't matter. What matters is whether the problem in front of you gets solved and what you wanted to make actually gets made.

A tool that generates Live2D-ready PSDs from YAML layer structure definitions. Register the result as a Clip Studio Paint template, and the layer scaffolding step disappears from every new character.

After reading the novel and watching the film, reflections on the beauty of visual storytelling and the irreplaceable power of a novel's inner voice.

Metronome, note flash cards, scale reference, and practice timer — four browser tools built to address common piano practice challenges.

Apples in curry aren't just a Japanese quirk. Three layers of science and history explain why fruit and spice meet in kitchens worldwide.

Should you spend time crafting AI tool configurations, or building things with them? A framework for deciding.

How the Maillard reaction works when food is heated, and how to use it to make your cooking better.

Why I chose Astro, Cloudflare, and Drizzle ORM — and how they fit together.

In 2026, AI tools made individuals fast again. But this window probably won't stay open for long.

Pokemon's first slow-life sandbox. A fusion of Minecraft and Animal Crossing, with the highest Metascore in series history.

On accepting what can't be done, even when you want it badly.

What should individual developers build when AI can write code?

A CLI tool for tracing the 'why' behind code. Built it in a day, and it immediately became non-ideal.