Rust, gently.
The podcast.

What a program actually is, told through a kitchen and a recipe.

If you have never written a line of code, this is your start. We do not look at code today. We build the picture in your head first: a program is a set of careful instructions, written for a reader who brings nothing with them. The skill of programming is the skill of thinking precisely. Programming languages sit on a spectrum from forgiving to strict, each making different trade-offs. Rust sits a little toward the strict end.

What happens when a computer reads your recipe.

You hand your recipe to a translator called the compiler. The compiler edits and translates. The translated version is a long sequence of small numbers called machine code, which the computer can read. Memory is a long hallway of numbered boxes. Most serious software bugs live in those boxes. Rust's whole personality is built around catching those bugs before the program ever runs.

A short, honest tour of where programming languages came from, what they trade off, and where Rust sits on that spectrum.

Imagine a long shelf of cookbooks. Different cuisines, different audiences, different ambitions, none of them interchangeable. Programming languages spread out the same way, and for the same reason: there is no one perfect cookbook because there is no one kind of cook. This episode walks the listener through the fast-versus-forgiving spectrum, names a handful of languages and where they sit on it, then introduces three other dimensions that often decide which language a team actually picks. By the end, you have a mental shelf, and you know roughly where any given language belongs on it.

Where Rust came from. An engineer with a side project, a company with a bug list that wouldn't die, and the slow path from a folder on a laptop to a stable 1.0 promise.

In two thousand and six, in an apartment in Vancouver with a broken elevator, an engineer named Graydon Hoare started a side project. He worked at Mozilla, where the security team filed bug after bug, every quarter, about the same family of memory mistakes inside Firefox. The bugs were not caused by bad engineers. They were the cost of doing business in C plus plus. Graydon's side project, eventually named after a family of unkillable fungi, was an attempt to make those bugs impossible by design. Mozilla noticed, sponsored the work, started a parallel browser engine called Servo to prove it could be done, and in May of two thousand and fifteen released Rust one point zero with a promise that sounded almost outrageous. This episode is the origin story.

The adoption story. The first quiet years after Rust 1.0, the inflection points, and the cascade that put Rust inside every major technology company in the world.

For the first few years after Rust shipped in 2015, most of the world ignored it. The few companies that did try it started reporting back numbers the rest of the industry could not ignore. This episode walks through the inflection points in roughly chronological order: Amazon's Firecracker and Bottlerocket in 2020, Cloudflare's Pingora replacing NGINX and now serving over a trillion requests per day, Discord's rewrite that made their tail-latency spikes disappear, Microsoft inside the Windows kernel, Google measuring Android memory-safety vulnerability drops, and the Linux kernel accepting Rust in 2022 after thirty years of refusing every other language. Plus the eight-year Stack Overflow love streak, the artificial intelligence inference layer moving to Rust, and the developer tools renaissance (ripgrep, ruff, uv).

The honest comparison. Where Rust now wins by default, where it is the wrong tool, and how to develop the instinct for telling the difference.

After three episodes of the adoption story, this is the corrective. Every good tool is good at some things and not others. The woodworker's most valuable skill is not knowing which tool to use; it is knowing which tool not to use. This episode walks through both sides. The domains where Rust is now the default choice: databases and query engines, web infrastructure, developer tools, AI inference, embedded systems, cryptography, game engines. The domains where Rust is the wrong tool: quick prototypes, first-time programmers, desktop applications, mobile applications, one-off scripts, interactive data notebooks. The pattern across both sides is consistent, and once you see it, your hand starts going to the right tool without you thinking about it.

Hello, world, but as a journey. Three lines of Rust, taken apart piece by piece until every character has a reason behind it.

The first program almost everyone writes in any new language is called hello world. It is small enough to fit on a napkin. It also contains, in compressed form, almost everything you need to know about the personality of the language. This episode is the audio version of that ritual. We read the three lines aloud, slowly, the way you might read a poem. We unpack `fn main`, the empty parentheses, the curly braces, the `println` macro, the exclamation mark that marks it as a macro, the double-quoted string, the semicolon. We then take a moment to introduce Cargo, the tool that ships with Rust and does almost everything a Rust programmer ever needs. By the end, you can read a complete working Rust program out loud and know what every piece of it means. That literacy is the foundation for everything that follows.

Variables. The mailbox image. The keyword `let`. And the quiet Rust opinion that says, by default, the value in the box doesn't change.

A variable is a labeled box that holds a value. Every program needs them, because every useful program needs to remember things as it runs. This episode meets the Rust keyword `let`, the snake-case naming convention, and the single design choice that sets Rust apart from almost every other language: immutability by default. Once you've put a value in the box, you can't change it without explicitly asking for the box to be openable, with the small word `mut`. That default closes off an entire family of bugs before they can happen, and it's one of the quiet reasons Cloudflare, Discord, and every other team that picked Rust seriously, ended up with software that stays steady under real-world load.

Types. Numbers, words, true and false. Why the computer cares about kinds even when the values look identical to the eye, and why Rust cares more than most languages do.

The jars in a baker's pantry look almost identical. Sugar and salt are both fine white powder. But mixing them up ruins the cake. That's what types are about in programming. This episode meets the basic kinds of values a Rust program can hold: `i32` for whole numbers, `f64` for decimals, `bool` for true-or-false, `char` for a single character, `String` for text. It walks through Rust's strict static typing, type annotations with the colon syntax (`let butter: i32 = 200;`), and type inference as the quiet gift Rust gives back in exchange for the strictness. The strictness, like every other Rust opinion we've met, closes off a family of bugs that other languages let through at run time.

Operators. The small verbs of the language. Arithmetic, comparison, logical and-or-not. And the small Rust opinion about integer overflow that has saved real production code from real bugs.

A fruit seller weighing apples, comparing coins to a price, deciding whether the total is enough — these are operations, the small verbs that make any system actually do something. This episode walks through the three families of operators in Rust: arithmetic (plus, minus, star, slash, percent), comparison (double equals, less-than, greater-than, and their cousins), and logical (double ampersand for and, double vertical bar for or, exclamation mark for not). It also covers compound assignment (plus-equals, minus-equals) and the small Rust opinion about integer overflow: by default, Rust refuses to let the wrap-around happen silently, the way C did in the Ariane 5 rocket failure that destroyed itself fifty seconds after launch.

Functions. The recipe within the recipe. How a working chef breaks the kitchen into named, reusable sub-recipes, and why working Rust programmers do the same.

A chef in a busy kitchen does not invent the stock every time she needs it. She made it once, gave it a name, and now she ladles from it into every dish that needs it. That is exactly what a function is in programming. This episode introduces the `fn` keyword properly, walks through a function signature (name, parameters with types, arrow, return type, curly-brace body), and shows how Rust uses the no-semicolon-on-the-last-expression rule to make a function's return value flow naturally out the bottom. It closes with the working-Rust-programmer habit of writing small functions, named for what they do, layered carefully on top of each other.

The if-else. The branching path. And the small Rust twist that makes if-else not just a statement but an expression with a value.

A baker on a Saturday morning looks at two bowls of dough. One has risen enough; one has not. He shapes the first into loaves, and he carries the second back to the warm corner of the kitchen for more time. That moment of looking-and-deciding is what every interesting program does, constantly. This episode walks through Rust's if, else, and else-if shape, the rule that conditions must produce a true-or-false value, and the small but consequential Rust design choice that makes if-else an expression: the whole branching block has a value, which lets a decision flow directly into a variable assignment in one line. It also mentions `match` as the larger cousin of if-else that you will start to see in serious Rust code.

The persistent instructions you leave for every future agent session to read. The chef's notebook on the prep station. The durable form of context.

A prompt is for one session; a rulebook is for every session. This episode walks through CLAUDE.md, AGENTS.md, and the discipline of writing a short, dense, surprising document that the agent reads automatically before any work begins. What belongs in it: standing conventions, working agreements, things a new colleague would have to be told on their first day. What does not: anything the agent could derive from reading the code. The episode closes with the discipline of removal, the practice that keeps the rulebook from rotting into noise.

What humans still own. The slow accumulated judgment about what should exist. The visible bottleneck of orchestration in the age of agents.

The agent can write code that compiles, passes tests, and does the thing. The feature can still be wrong. This episode names taste directly: the slow, accumulated sense of what works and what does not, built up over years of seeing software hit the real world and succeed or fail. In the world before agents, taste was hidden behind the work of typing. In the world with agents, it is standing in the open, where it was always doing most of the work. The episode closes with a practical move: start every project with a short, opinionated statement of what you will not compromise on.

The hiker who has wandered off the marked trail. The small set of moves that recover the work, and the cost of pushing through instead.

Agents get stuck in loops that look like effort but produce no progress. The agent's confident tone often hides this until the cost has mounted. This episode walks through the small playbook of moves to make once you recognize the pattern: stop, clear context, narrow scope, show rather than tell, restate the goal in different words, and finally escalate. It also names the prevention layer: better briefs and better context lead to fewer loops in the first place.

The nurse who takes vitals every morning, regardless of what the patient self-reports. The verification discipline that is the bottleneck of leverage.

When the agent says "tests pass" or "all clean", the summary is not always the whole story. This episode walks through the small mechanical moves that close the trust gap: ask for pasted output instead of summaries, verify the specific gate the agent claims to have crossed, scale verification with the size of the change, and learn the agent's specific blind spots over time. The argument is that trust is the bottleneck of leverage: too little and you read every line yourself, too much and the bugs slip through. The sweet spot is a skill, built with practice.

The conductor in front of the orchestra. The shift from one agent on one task to several agents working in coordination, and what new skills it requires.

Single-agent work moves the bottleneck from typing to reviewing. Once you notice that, running multiple agents in parallel becomes a way through the ceiling. This episode walks through what makes parallel agent work actually work: a tool like worktrees so the agents don't step on each other, the discipline of giving each one an independent task, and the coordination skill of switching between them without losing the thread. It also names the three specific failure modes (integration tax, silent drift, coordination collapse) and the honest limit of how many parallel agents one person can effectively guide.

The carpenter's notebook at the end of the season. The longitudinal practice that compounds your skill as an orchestrator over months and years.

The agent does not learn over time. You do. The retro is the structured form of that learning. This episode walks through the small ritual: thirty minutes a week, three headings (what went well, what kept tripping us up, what to change in the rulebook), and the discipline of writing the lessons into your CLAUDE.md so the next session starts a step ahead. Teams that hold this practice consistently pull away from teams that do not, even when working with the same agents on the same kinds of problems. The compounding is real.

The carpenter finally upgrades from a hand plane to a power planer. The wave of small everyday tools that have been quietly rewritten in Rust.

A search tool, a linter, a formatter, a package manager. None of these are the product, but they shape the daily working life of every programmer. Over the last five years, almost all of them have been quietly rewritten in Rust, and the replacements are typically ten to a hundred times faster than what came before. This episode walks through the pattern (ripgrep, ruff, uv, biome, swc), why Rust is the perfect language for this niche (small binaries, fast startup, single-file distribution), and the rust-analyzer story specifically, which is the kind of leap that enables new workflows the old tools could not have supported.

The historic 2022 moment when the Linux kernel accepted Rust as its second supported language. What has actually happened since.

For thirty years, the Linux kernel admitted exactly one programming language: C. In 2022, after careful technical work and long mailing-list debate, the kernel community accepted Rust. This episode looks at the cultural significance of that moment, the actual drivers that have shipped in the three years since (storage, cryptography, network drivers, file system layer), the friction in the community including the public departures of prominent C maintainers, and the steady forward trajectory that suggests Rust will keep growing as a fraction of new kernel code. The acceptance was the loudest possible signal that this language has earned a place in the most demanding part of systems programming.

An old bridge across the river, kept up but showing fatigue cracks. A new bridge being built alongside, slowly absorbing the traffic. The story of OpenSSL, Heartbleed, and the Rust libraries that are quietly taking over.

Almost every secure connection on the internet runs through a small cryptographic library. For decades, that library has been OpenSSL, written in C, and the memory bugs in it have produced some of the most expensive software incidents in history including Heartbleed. This episode walks through the systematic replacement of memory-unsafe cryptographic libraries with memory-safe Rust alternatives: rustls, age, Signal protocol implementations, BoringSSL replacements. The migration is being pushed not just by the industry but by governments, with the NSA, CISA, and the White House all explicitly recommending memory-safe languages for new infrastructure. The next decade of internet security will run on libraries the previous decade could not have produced.

The universal travel adapter. The small piece of hardware that lets one device work in any country's outlets. WebAssembly as the universal adapter for code, and Rust as the language that fits it most naturally.

WebAssembly, often shortened to Wasm, is a portable, sandboxed binary format for running code anywhere. It started in the browser. It now runs on serverless platforms, on edge networks, inside plugins, in databases, in places that have nothing to do with the web. This episode walks through what Wasm is, where it came from, why Rust has emerged as the front-runner language for writing Wasm code (small binaries, fast startup, well-defined memory model, mature tooling), and the future being unlocked by the Component Model and WASI. Software is becoming place-independent. Rust is the language that fits this new shape.

The night shift at a shipping port. The invisible infrastructure that moves the modern world. The corner of computing that has, more than any other, bet on Rust.

The deepest layer of the modern internet, the small operating systems and runtimes that schedule and isolate every customer workload at scale, is being steadily rewritten in Rust. This episode walks through the AWS Rust commitment in detail: Firecracker, the microVM that runs every Lambda call; Bottlerocket, the operating system for hosting containers; the broader pattern across Microsoft, Google, Cloudflare, and beyond. The argument is that the cloud is a leading indicator of where the rest of computing is going. When the most demanding, cost-sensitive, safety-critical software in the world picks a language, the rest of the industry tends to follow.