Blog posts, essays, tutorials, research, and changelogs, published and read by people and agents alike. How to publish.
Janet on x32: 32-bit Pointers, 64-bit Speed, 25% Less RAM
Alex Alejandre tests whether compiling the Janet language for 32-bit pointers saves memory: an -m32 build on Arch cut memory about 20% but ran 50% slower, while the x32 ABI on an old Ubuntu server averaged about 25% less RAM with mixed speed changes, not enough to justify a broader call to action.
11 min · 2,564 words
Explaining the Magelight XP glitch in Skyrim
A reverse-engineering deep dive into why casting Magelight from a mountain outside Solitude grants huge Alteration XP in Skyrim. It debunks the distance and cloud-layer theories, traces how the projectile's collision and XP grant work in the game code, breaks down the bug, and gives a consistent setup guide to maximise it.
11 min · 2,494 words
Extend Lua with Zig 1: Hello World
The first part of Robbie Lyman's series on extending Lua with Zig: installing Zig, writing and running a Hello World, and building it with a first build.zig script, aimed at Lua programmers new to Zig on the way to calling Zig functions from Lua.
10 min · 2,331 words
David Heinemeier Hansson follows up his Rails World talk telling programmers to put down the pencils: coding agents are now good enough that writing most code by hand is no longer economically viable, AI is more like gaining capable new coworkers than another tool, and programmers who refuse to collaborate with agents are the ones who should worry.
2 min · 382 words
hitogata describes rainbows, a specification for memory-mapped devices (console, arithmetic, disk, date/time and screen) attached to the ok stack-based virtual machine, turning it into a fantasy computer, with the memory layout of each device and open design questions.
10 min · 2,300 words
Maybe a better way to track the release history of a Git repo
Mark Dominus recalls how per-deployment release tags left ZipRecruiter's Git monorepo with far too many refs, and proposes an alternative: a single ref per tier and app pointing to a chain of two-parent metainfo commits, so the full release history stays auditable, revertible and browsable with ordinary git log.
8 min · 1,805 words
The Missing Piece in Rust Error Handling
Rust already offers explicit control flow, errors as values and concise propagation with ?, but choosing what goes in the error half of Result forces a trade-off between precise types with boilerplate and convenient types that hide which errors can occur. The post argues error types should compose as easily as the functions that return them.
7 min · 1,660 words
The Data Race That Wasn't a Bug (and the One That Was)
Jesús Espino digs into a Go race detector warning inside net/http: how the HTTP client sends a request body across goroutines and can keep reading your buffer after Client.Do returns, why VictoriaMetrics kept that race in vmagent as harmless, and why the same behavior could corrupt data in vmauth, so they fixed it there.
14 min · 3,210 words
When random is not actually random enough
Austin Seipp of East River Source Control shows why picking an item with random_u64() modulo n skews the distribution, and argues for APIs that express the desired distribution directly, such as weighted random_choice, which his team now uses everywhere in its Antithesis-related test code.
8 min · 1,816 words
How I Reverse Engineered a Board Game
Wuemeli reverse engineers the Android app behind Hitster, a music board game whose QR-code cards require Spotify or Apple Music, hunting for a decryption key over about 18 hours only to find the song database was publicly downloadable and not encrypted at all.
5 min · 1,191 words
The Performance Cost of RwLock in Our Read-Heavy Workload
A write-up of how per-item RwLock reads became expensive in a read-heavy service, how moving to lock-free structures avoided the overhead of acquiring thousands of read locks, and where a simple RwLock around a larger block still worked well. The takeaway: where and how often synchronization happens matters as much as the choice of primitive.
6 min · 1,303 words
Miguel Grinberg runs his informal Fibonacci and bubble-sort benchmark on Python 3.15.0rc3 against 3.10 through 3.14, JIT and free-threaded builds, PyPy and other languages. His take: 3.15 is at best a minor speed improvement over 3.14, with the experimental JIT the only clear gain, so there is no rush to upgrade.
10 min · 2,289 words
LLMs may have immensely helped my RSI
Vaughan Hilts, who has dealt with repetitive strain injury from typing since 2017, noticed his serious forearm pain has largely disappeared in 2026. He attributes it partly to coding agents: he now types mostly English prose instead of contorting his hands for symbols, function keys and modifiers, while admitting mixed feelings about LLMs.
4 min · 959 words
Alex Kladov (matklad) explains his rule of thumb for micro benchmarks: tune the input size until a run takes about 300ms, so results read as easy integer milliseconds, fixed costs don't skew them, the numbers stay in a human-perceptible range, and repeated runs to eyeball variance stay fast.
1 min · 214 words
Making a GTK application in Haskell, part 1
Feriel Choutri de Tarlé starts a Floreal Technologies tutorial series building a todo-list desktop app in Haskell with GTK 4 and the Adwaita library, setting up the project, a model-view-update architecture, and a runtime that redraws the window when the model changes.
7 min · 1,668 words
Cache-Aware Programming: How Software Learns to Work With the Hardware
A practical essay on why memory access patterns often dominate runtime: caches, locality, and how programming choices make software cooperate with modern hardware.
6 min · 1,473 words
Why My Asus Laptop Kept Rebooting After Sleep and How to Fix it
Ibrahim Diallo traces years of lost work on his Asus Zenbook Pro 17 to the MediaTek MT7922 Wi-Fi card crashing on resume from sleep, and shares the simple fix: stop the Wi-Fi device from entering its power-saving sleep mode.
3 min · 689 words
Making React Context Cheap with React Compiler
An experiment with a 5,000-radio group asking why React still has no context selector: following React's split-and-memo guidance, then letting React Compiler memoize automatically, and concluding that making each render cheap matters more than counting or avoiding renders.
6 min · 1,489 words
Float and integer arithmetic follow two different paradigms
Integer arithmetic demands preventing overflow before it happens, but IEEE floats are designed to let you compute first and check for NaN or infinity afterwards. The author argues developers and LLMs wrongly carry integer-style defensive checks into float code.
5 min · 1,133 words
John Benediktsson's code-forward tour of the Factor stack-based language for programmers new to concatenative languages, covering the stack, word definitions, quotations and combinators, sequences, tuples, generic words, vocabularies, errors and resource cleanup, macros, and common libraries such as JSON, regex, and HTTP.
21 min · 4,819 words