Laurence Tratt spent years believing Fred Brooks’s no-silver-bullet argument—that no single language or tool could give an order-of-magnitude productivity improvement. Then he rewrote a single-threaded website builder into a multi-threaded Rust program in under 5 minutes. It ran correctly on the first try. It has stayed working correctly since.
What Actually Happened
Tratt’s site builder (the one generating the page you’re reading) had gotten slow enough to disrupt editing. Single-threaded optimizations weren’t enough. He guessed that multi-threading would fix the pauses—but in any other language, that guess would mean weeks of debugging data races and deadlocks. In Rust, he made the change, compiled, and it just worked. Total confidence, zero crashes.
Why Rust Breaks the Pattern
Most languages let you reason locally about a function but give you no guarantees about how that function interacts with shared state across threads. Rust’s ownership and borrowing rules force the programmer to resolve data-race conditions at compile time. The compiler doesn’t just check types—it checks access patterns. That means when you write a local chunk of code, you get a global property: the program is free from data races. Tratt calls this “local reasoning for global properties,” and it’s exactly what made his five-minute rewrite possible.
What This Means for AI and Language Design
Tratt has been fielding questions about whether new languages will help AI write better code. His earlier answer was “probably not”—AI can already produce plausible local chunks in any language. But AI today struggles with code that requires global understanding, often inserting unnecessary defensive checks that explode the state space. If that limitation persists, language design could help by making global properties locally checkable—just as Rust does for concurrency. Tratt isn’t predicting the exact shape of such languages, but his experience shows the principle works in practice.
One language that lets you guarantee a global property from a local annotation is worth more than a thousand new syntaxes. The next step is figuring out which other global properties we can make locally checkable.
Source: Local Reasoning for Global Properties
Domain: tratt.net
Comments load interactively on the live page.