0.3Introduction to Rust
In the previous lesson (0.2), we covered what high-level languages are. There are hundreds of them. Each one is a bundle of design decisions (what to make easy, what to make fast, what to make impossible), and you can learn a lot about a language by asking which trade-offs it picked. So before you spend the next few months with Rust, you deserve to know what you're signing up for.
A short history
Rust began in 2006 as a personal side project of Graydon Hoare, then a programmer at Mozilla (the makers of Firefox). Mozilla had a very practical interest in the idea: browsers are enormous programs written mostly in C++, and a large share of their security holes traced back to exactly the category of memory mistakes Rust set out to eliminate. Mozilla began officially sponsoring the project in 2009 and unveiled it publicly in 2010.
After years of public, sometimes drastic, redesign, Rust 1.0 shipped on May 15, 2015. Everything you'll learn in this course exists in the shape that 1.0 and its successors settled on. Since then, the language has moved at a steady, deliberately boring pace: a new stable version every six weeks, with a promise that code which compiles today keeps compiling tomorrow. (The language does evolve in larger steps too, called editions; lesson 0.12 covers those.)
In February 2021, stewardship of the language passed from Mozilla to the independent Rust Foundation, whose founding members (Amazon Web Services, Google, Huawei, Microsoft, and Mozilla) give you a fair picture of who depends on Rust today.
What makes Rust different
For decades, picking a language meant picking a side in one big trade-off.
On one side: languages like C and C++, which compile to fast machine code and give the programmer direct control over the machine's memory. The price is that the language trusts you to use that control correctly. When you slip (use memory after freeing it, write past the end of an array), the program doesn't politely stop: it corrupts data, crashes mysteriously, or opens a security hole. Decades of experience say these mistakes are not a beginner problem. The best C++ programmers in the world ship them constantly.
On the other side: languages like Java, Python, C#, and Go, which protect you from those mistakes by managing memory automatically with a garbage collector: a system that periodically finds and frees memory your program is no longer using, while the program runs. It works, but it costs speed and predictability, and it puts a layer of machinery between you and the machine.
Rust's bet is that this trade-off is not a law of nature. It aims to give you the speed and control of C++ and the safety of the garbage-collected languages, by moving the safety checks to compile time. The Rust compiler enforces a set of rules about how memory is used (you'll meet them as the ownership system, starting in chapter 8), and a program that breaks the rules doesn't crash at 3 a.m. — it fails to compile this afternoon. No garbage collector, no babysitting at runtime, because the checking already happened.
Key insight
The cultural difference in one line: C++'s philosophy is "trust the programmer." Rust's is "the compiler has your back." Most of what you'll learn in this course is how to work with that strictness instead of against it.
This is also the honest explanation of Rust's reputation for being hard: the compiler rejects programs other languages would happily run (and let fail later). More on that below.
Q: What is Rust good at?
Rust's home turf is anywhere speed, reliability, or low-level control matter: command-line tools, web servers and backend services, embedded devices, game engines, browsers, operating systems, and the infrastructure other software runs on.
And it's not a niche bet. Rust is in Firefox (where it started), in Android and Windows system components, and, as of December 2025, an officially supported language for code in the Linux kernel: the first new language admitted for kernel code in the project's history, which had been C (plus slivers of assembly) for over three decades. Amazon's Lambda service runs customer code inside Firecracker, a virtualization engine written in Rust; Cloudflare serves a large share of the internet's traffic through Rust services; Discord famously rewrote a core service from Go to Rust when garbage-collection pauses became visible to users. In Stack Overflow's annual developer survey, Rust has been the most loved (renamed "most admired" in 2023) language every single year from 2016 through 2025: a full decade.
Q: Is Rust hard?
We won't lie to you: Rust has a reputation for a bumpy first month, and the reputation is earned. The compiler is strict, and early on it will reject programs that feel like they ought to work. It's a bit like learning to drive with an instructor who grabs the wheel a lot.
Two things make this much better than it sounds. First, Rust's error messages are the best in the business: they point at the exact problem, explain it, and usually suggest the fix. Learning to read them is a skill this course teaches deliberately, starting in chapter 1. Second, the strictness is front-loaded. The rules that feel fussy in week two are the same rules that later let you change big programs without fear, because the compiler re-checks everything you might have broken. Rust is hardest at the start and gets easier as your programs get bigger; most languages work the other way around.
This course exists to flatten that first month: the rules arrive in small pieces, in an order designed so each one makes sense before the next one appears.
Q: Do I need to learn C or C++ first?
No. This course assumes no programming experience at all. Coming from C++ changes which parts of Rust feel surprising; it doesn't change whether you can learn it.
Q: Why learn Rust as a first language?
Because the compiler that's strict with experts is patient with beginners. Mistakes that would be silent, random-looking crashes in C++ are caught in Rust at compile time, with an explanation attached. A beginner's worst enemy isn't difficulty; it's mystery, the program that fails with no clue why. Rust converts most mysteries into error messages, and error messages can be learned from.
Rust's own website states the goal as "empowering everyone to build reliable and efficient software." Everyone includes you.
In the next lesson, we'll zoom out and look at the process of developing a program, which involves a good deal more than typing code.