Topic
Everything filed under Programming, newest first.
RSS · JSON · All topics
Thomas Neumann explains why classic lock coupling scales poorly on many-core CPUs because of physical contention on the root lock, how Optimistic Lock Coupling lets readers validate version numbers instead of writing, and how a C++ lock guard can encode validation in the type system so the compiler catches missed checks.
5 min · 1,105 words
Semantics for 2D Rasterization
Kulkarni, Whiting, and Panchekha introduce μSkia—a Lean-mechanized formal semantics for Skia 2D graphics—and an optimizer that speeds rasterization ~18.7% on Chrome-derived Skia programs while proving replacements correct.
4 min · 1,009 words
How nytpu built a terminal-friendly curl version of their site with ANSI styling, content negotiation, and practical notes for serving pretty pages to curl.
3 min · 756 words
The LISP curse, now coming to your ecosystem!
An essay arguing that LLM-assisted coding could spread the "LISP curse" to every ecosystem: when generating bespoke code is easy, developers work in isolation and open source collaboration on shared libraries may decline.
3 min · 623 words
Carson Gross on teaching, parenting, and why improvisational "yes, and" is a better stance for web software than premature abstraction—an htmx essay about compounding small improvements.
10 min · 2,277 words
Simon Sapin models Factorio Space Age quality upcycling with transition matrices and equilibrium equations, then builds an interactive TypeScript calculator for gambling, washing, upcycling, and asteroid reprocessing loops.
15 min · 3,372 words
Comparison of Arena Architecture in malloc()
When multiple threads simultaneously allocate or deallocate memory from the allocator, the allocator will serialize them. Programs making intensive use of the allocator actually slow down as the number of processors increases.
8 min · 1,880 words
Software occlusion culling in Block Game
Eniko walks through software-rendered occlusion culling for a voxel/block game on a weak integrated GPU—why CPU-side culling mattered, how the technique works, and the performance wins on modest hardware.
16 min · 3,579 words
What makes Lisp difficult to read?
The Lisp family of programming languages is infamous for their parenthesis-heavy syntax. Many people, myself included, find this syntax more difficult to read than the notation of languages like Python, Java or C. The perceived unreadability of Lisp is so significant that multiple attempts have been made to create new notations to aid Lisp’s adoption. Yet, despite these attempts and Lisp being nea
11 min · 2,635 words
How to draw variable-width Bézier strokes with current 2D graphics APIs, motivated by building pressure-sensitive tablet tools for live board work in university teaching; covers pressure, splines, stroke outlines and per-pixel checks. Licensed CC BY-NC-SA 4.0.
22 min · 5,121 words
A careful comparison of typeclasses and ML-style modules: what each abstraction is for, where the persistent confusion comes from, and how to choose between them when designing APIs and language features.
10 min · 2,361 words
How to run a city builder on 16 MHz
A look at how the original SimCity ran a full city simulation on a 16 MHz 386SX: its Simulate() function only runs a slice of the systems each frame, a frame-distribution trick that also shows up in Assetto Corsa's cubemap reflections and Unreal's Lumen lighting.
4 min · 998 words
The Graph Will Set You Free: Why Every Creative Tool Is Becoming a Node Canvas
Hirad Sab traces node-based creative tools from Sketchpad to modern AI canvases, arguing graphs are the right abstraction when generation becomes a networked, composable process.
8 min · 1,935 words
The Shadows Lurking in the Equations
FuzzyGraph visualizes equation error topography, not just exact zeros—revealing black holes, shadow lines, and near-solution underwater islands invisible to conventional binary graphing of algebraic curves.
5 min · 1,136 words
The Many Many Missed Opportunities of Sonic 06
Isaac Marovitz, working on the Marathon Recompiled project, digs into Sonic 06's rendering and cut content to show how much unfinished lighting, effects and polish the game shipped without, and what the recompilation can restore.
8 min · 1,888 words
A short opinion piece arguing constructors should never throw, do async work, or perform side effects; parsing, connecting, and validation belong in factory methods or explicit lifecycle methods so object construction stays simple and predictable.
2 min · 397 words
Type Safe Generic Data Structures in C
Daniel Hooper shows a technique for type-safe generic data structures in plain C that uses unions to attach type information to a generic container, building up from a basic linked list and comparing it with macro and void-pointer approaches so the compiler catches type errors at call sites.
7 min · 1,691 words
Malleable software: Restoring user agency in a world of locked-down apps
Ink & Switch’s essay on malleable software: why today’s locked-down apps strip user agency, and what it would take to restore tools people can reshape themselves.
34 min · 7,761 words
Why I Wrote the BEAM BookPost-mortems, coffee, and a decade of stubborn curiosity
The story behind The BEAM Book: a decade of keeping Klarna's Erlang core system running, three publishers, and an open-source sprint to finish a deep guide to the BEAM virtual machine's internals, plus lessons learned.
5 min · 1,157 words
How to prove equations using diagrams, part 1
Evan Patterson introduces e-graphs and initial functors as a way to prove equations using diagrams, showing how commutative diagrams can represent equational reasoning and how motifs among initial functors support that style of proof.
13 min · 2,894 words