Rust, gently.
The podcast.

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.

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.

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.

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.

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).

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.

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.

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.

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.

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.

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.

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.

For most of computing's history, the computer was a thing institutions owned, behind glass walls, fed punch cards by attendants in cold rooms. This episode walks through the inversion that ended that arrangement. It opens on the April nineteen sixty-four System slash three sixty announcement, where some of the machines on stage were fakes, and follows the personal computer revolution from Ed Roberts's Altair kit in a New Mexico warehouse, through the Wozniak and Jobs garage and the West Coast Computer Faire, to the I B M P C unveiling at the Waldorf Astoria. Along the way, you hear how a twenty-five thousand dollar licensing decision by Bill Gates quietly handed Microsoft the next thirty years.

Charley Kline sits at a U C L A terminal on the night of October twenty-ninth, nineteen sixty-nine, with a telephone handset in one hand and a teletype keyboard under the other, and types the two letters that will turn into the internet. This episode follows the protocol decisions made in the years that followed: Cerf and Kahn's nineteen seventy-four paper on T C P slash I P, the January nineteen eighty-three flag day cutover, Tim Berners-Lee's "vague but exciting" web proposal, and CERN's April nineteen ninety-three decision to make the World Wide Web royalty-free forever. The closed networks that competed against open, CompuServe, Prodigy, A O L, Minitel, every one of them well-funded and professionally run, every one of them lost. The shape of the internet you use today is the shape of that loss.

January ninth, two thousand and seven. Steve Jobs walks onto the Macworld stage and announces three new products, then reveals they are one device. Six hundred miles north, Mike Lazaridis, who built the BlackBerry, watches on a television and stops moving. This episode follows the moment the computer left the desk and moved into the pocket: the App Store launch in July two thousand and eight, the H T C Dream three months later running an operating system called Android, the twenty eleven crossover when smartphones outsold personal computers for the first time, and the resignation of Research In Motion's co-chief executives in twenty twelve. The pocket inversion is the structural reason most of the largest companies in the world today are companies that own a phone, or built software for one, or used one to rewrite an existing business.

Andy Jassy in early two thousand and three, rewriting the same proposal for the thirty-first time: that Amazon should sell its computing infrastructure to other companies by the hour, by the gigabyte, by the second, with a credit card. This episode walks through the A P I mandate Jeff Bezos sent around in two thousand and two, the S three launch on March fourteenth two thousand and six at fifteen cents per gigabyte, the E C two launch five months later built largely by a team in Cape Town, and the Lambda announcement at re:Invent in twenty fourteen. By the end, you understand how a quiet shift in accounting, capital expenditure becoming operating expenditure, collapsed the cost of starting a software company and reshaped which companies got built between two thousand and six and now.

September thirtieth, twenty twelve. Alex Krizhevsky, Ilya Sutskever, and Geoffrey Hinton submit a network they call AlexNet, trained on two consumer graphics cards in a bedroom, and the entire field of computer vision changes direction in an afternoon. This episode follows the chip that made it possible, NVIDIA's parallel architecture and the coo-duh framework Ian Buck designed, through the Transformer paper of twenty seventeen, Google's custom T P U, the November twenty twenty-two release of ChatGPT, and the H one hundred shortage that pushed NVIDIA past four trillion dollars in market value. The closing section names, for the first time in this season, what the infrastructure layer of A I is being rewritten in: Hugging Face Tokenizers, Safetensors, Candle, Text Generation Inference. Rust is the language of the A I infrastructure layer.

Open Linus Torvalds's laptop in Portland and count the lines of the Linux kernel and the number you get back is in the neighborhood of thirty-six million. Every line is text. The operating system that runs roughly ninety-five percent of cloud servers, every Android phone, every modern Tesla, the helicopter on Mars, is, when you peel back the polish, a very large pile of letters and punctuation sitting in files. This episode walks through what source code actually is, what a diff is, why text won the war over every prettier alternative, and what it means that a thirteen-year-old can propose a change to one of the largest systems in human history simply by writing a careful note.

Two men in their early thirties sat in a fluorescent-lit office in Murray Hill, New Jersey, in nineteen seventy-two, and built the first compiler that could compile itself. Every compiler since has been a descendant. This episode walks you through what compilation actually means, the six stages of work the machine does between your saved file and a running program, why a shared piece of infrastructure called L L V M sits quietly behind almost every modern language, and why the Rust compiler has become famous for being the most pedagogically generous teacher the field has ever produced.

In April of two thousand and five, Linus Torvalds lost his version control system to a vendor's licensing decision and had two weeks to build something better. The thing he built, called git, became, within a decade, the spine of essentially every software project on earth. This episode walks through what version control is, the family tree of systems that came before git, why distributed beat centralized, how GitHub turned the pull request into a cultural innovation, and why a single command called git blame can tell you the name of every engineer who ever touched a particular line in the system running your phone.

In the late summer of nineteen ninety-one, a Finnish computer science student named Linus Torvalds released a small operating system kernel into the world under a license, written by a stubborn man in Cambridge a decade earlier, that ensured no one could ever lock it up. That single licensing decision shaped the present. This episode traces the open source tradition from Richard Stallman's frustration with a Xerox printer in nineteen eighty, through the G N U project and the four freedoms, into the puzzling fact that the largest technology companies on earth now pay thousands of engineers full salaries to write code they give away. The language this show is named after lives in exactly this tradition.

At his Turing Award lecture in Nashville in nineteen eighty-one, Tony Hoare apologized for inventing the null reference. He called it his billion-dollar mistake. By twenty twenty-four the cost was closer to a trillion. This episode traces the field's long, humbling fight against bugs, from the N A T O conference in Bavaria in nineteen sixty-eight, through fifty years of static analysis and fuzzing and sanitizers and formal verification, to the moment in twenty fifteen when an outrageous-sounding promise about a new language from Mozilla turned out, slowly, to be true.

In a brick building in Murray Hill, New Jersey, in nineteen seventy-two, Dennis Ritchie wrote a small language called C so that the operating system Ken Thompson was building, called Unix, could run on more than one kind of machine. Ritchie's language turned out to be small, fast, and portable, and it spread with Unix through universities, into industry, and underneath nearly every operating system, database, web server, and embedded controller in use today. The cost of that fifty year reign is the family of memory bugs that account for roughly seventy percent of all serious security vulnerabilities in the industry. For half a century, no language was able to match C's strengths while removing that cost. Rust is the first language that has.

The garbage collector is the second great answer the industry tried to give to the memory bug problem. John McCarthy invented it at M I T in nineteen fifty-nine, for a research language called Lisp. It moved into the mainstream when Sun Microsystems released Java in May of nineteen ninety-five, and from there into almost every modern application language you have ever used. The trade is real and the cost is real. For a small but critical class of low latency software, the brief stop-the-world pauses that a garbage collector imposes are unacceptable. The story Discord told in February of twenty twenty, with the famous sawtooth latency graph and the flat line after the Rust rewrite, is the canonical illustration. Rust offers a third way: ownership, enforced at compile time, no runtime collector at all.

Over the last decade, almost every slow tool that working software engineers depended on has been replaced by a Rust equivalent. Andrew Gallant's ripgrep was an early flagship. Aleksey Kladov's rust-analyzer redefined what a language server could feel like. Dong Yoon Kang's swc and Tobias Koppers's Turbopack remade the JavaScript build pipeline. Charlie Marsh's Astral built ruff and u v, replacing the slow heart of Python tooling at roughly a hundredfold speedup. The replacements were not coordinated, were not a corporate strategy, and were not slightly faster. They were ten times, fifty times, in some cases more than a hundred times faster than the things they replaced. The cumulative effect on the daily experience of being an engineer has been quietly enormous.

On September fourteenth, two thousand and twenty-two, Cloudflare rolled out Pingora, the Rust proxy that replaced their long-serving engine x infrastructure. By the end of the day they were handling the same traffic with roughly seventy percent less C P U and sixty-seven percent less memory. That kind of speedup is not just quantitative. When per-step latency drops by an order of magnitude, entirely new categories of software become possible. Discord's chat backend, Figma's multiplayer engine, A W S Firecracker running every Lambda call, Cloudflare Workers, Polars replacing pandas in serious data work, Microsoft rewriting parts of the Windows kernel, the Linux kernel itself accepting Rust in version six point one of December twenty twenty-two. The revolution is quiet. You live inside it.

For most of the history of computer security, government guidance focused on practices: better tests, more tools, larger security teams, faster patching. The premise was that careful enough was achievable in C and C plus plus. Microsoft's twenty nineteen disclosure that seventy percent of their patched vulnerabilities were memory safety bugs, and the matching numbers from Google and Apple, made it clear the premise was wrong. On November tenth, twenty twenty-two, the N S A's Cybersecurity Directorate told American industry in writing to stop starting new projects in C. In December twenty twenty-three, C I S A and the Five Eyes followed. In February twenty twenty-four, the White House Office of the National Cyber Director went further. The European Union's Cyber Resilience Act, the D A R P A T R A C T O R program, and Android's measurable safety drops all point in one direction.

The foundational episode of a season about a particular corner of the data world. James Gosling, in nineteen ninety-one, wanted a way to write a program once and have it run on every chip a cable company might ship. The answer he and his team shipped in nineteen ninety-five was the Java Virtual Machine, a piece of software that pretends to be a processor that does not exist. This episode is a clean, no-jargon walk through what the JVM actually is, what it does, and what it costs. Startup time, memory overhead, garbage collection pauses. The gifts and the bill. The foundation underneath the next four episodes of the season.

The story of Apache Spark, told as the origin of an institution. Zaharia's bet, written into the first lines of code in August of two thousand and nine, was that you could keep data in memory between operations and recompute lost pieces from a recipe instead of from copies. The bet became the Resilient Distributed Dataset, the best-paper-winning idea behind a company called Databricks, which is today worth one hundred and thirty-four billion dollars. This episode walks through the architecture, the API, the company, and the protocol called Spark Connect that, in twenty twenty-two, accidentally opened the door through which the rest of this season will walk.

An itemized accounting of what running Apache Spark in two thousand and twenty-six actually costs the businesses that use it. Five specific costs, with numbers attached, drawn from Databricks' own engineering posts and AWS's own tuning documentation. Cold start delays measured in seconds. Garbage collection eating thirty to fifty percent of wall clock. Memory overhead three to five times the equivalent in Rust. The Python boundary turning user-defined functions into row-by-row serialization grinders, at half a millisecond to five milliseconds per row crossing. The bonus observation: Spark is bad at small data, and most analytical workloads in two thousand and twenty-six fit on one fat machine.

The clean, no-marketing description of Sail, the Rust-native drop-in replacement for Apache Spark. Built on Apache Arrow and Apache DataFusion. Speaks Spark Connect from the first commit. Runs the same PySpark code your team already wrote, on the same data, in a single binary, with milliseconds to start instead of seconds, with no garbage collector, and at roughly a sixteenth of the cost on the published TPC-H benchmark. The thesis: Spark's architectural choices made sense for a two thousand and ten data center, not a two thousand and twenty-six one, where a single AWS instance can have a terabyte of memory and a hundred and ninety-two cores.

The widened lens for the season. The pattern that produced Sail is not unique. The same architectural bet is playing out across every layer of the data infrastructure stack. Spark gets replaced by Sail and DuckDB and Polars. Flink by Materialize and RisingWave. Kafka by Redpanda. Druid and Pinot by ClickHouse. Apache Arrow, Apache DataFusion, and the lakehouse storage formats Iceberg and Delta Lake are the substrate that makes the transition fast, because data stays put while engines change. The forecast: most new data infrastructure shipped at scale over the next five years will be native, written in Rust or C plus plus, not JVM.

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.

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.

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.

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 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.