🦀 Welcome — Programming, and Why Rust

This curriculum assumes Rust is your first programming language. If you’ve coded before, the early lessons will move slowly — skim them. If you haven’t, every word matters; read it in order, don’t skip.

The goal isn’t to make you a Rust expert in a weekend. It’s to give you a working mental model of how a program executes, and how Rust specifically helps you build one without the categories of bugs that have plagued every other systems language for fifty years.

What is a program?

A program is a sequence of instructions that a computer follows. You write the instructions in a programming language — a language designed to be unambiguous so a computer can carry them out exactly. Different languages have different strengths. Some are tuned for quick experimentation, some for absolute speed, some — like Rust — for safety and speed at once.

A program does three kinds of thing:

1. It holds data. Numbers, words, lists of things, files, network connections.
2. It transforms data. Adds two numbers, splits a sentence into words, sorts a list.
3. It produces output. Prints to your screen, writes a file, sends data over the network.

That’s it. Every program you’ve ever used — your browser, a game, the text editor these words were written in — is some elaborate combination of those three.

A few words you’ll need

Some terms come up constantly. Quick definitions, then we’ll see each in action:

• Variable: a name attached to a piece of data. let age = 30 makes age point at the number 30.
• Type: the shape of a piece of data. 30 is a number; "hello" is text; true is a yes/no value. Knowing the type means knowing what you can do with it.
• Function: a named piece of code that takes some inputs and (usually) produces an output. Like a recipe: name, ingredients, steps, result.
• Memory: the computer’s workspace, where data lives while the program runs. It has limits, can fill up, and reading or writing the wrong part causes crashes.
• Compile: the step where your text-file source code is converted into a runnable program (an executable or binary). The tool that does this is the compiler.
• Compile time vs runtime: “compile time” is when the compiler is reading your code; “runtime” is later, when the resulting program is actually running. Rust shifts many bugs that other languages catch at runtime to compile time, where they’re cheaper to fix.

What is Rust?

Rust is a systems programming language — meaning it can produce small, fast programs that run close to the metal: operating systems, browsers, databases, embedded devices. C and C++ have owned that territory for decades. They produce fast code, but they’re famously easy to crash: a forgotten check, a bad pointer, two threads stepping on each other’s data, and your program corrupts memory or, more often, just silently does the wrong thing.

Rust was built to be just as fast as C, but with the compiler enforcing — at compile time, before you even run the program — that those bugs are impossible to write. The defining feature is the borrow checker: a part of the compiler that tracks who owns each piece of data and refuses to build if you try to use data in an unsafe way.

The friction is the point. Rust is picky in the way a flight instructor is picky: every refusal is a lesson, and once you internalise the rules you stop making the class of mistake the rule was protecting you from.

The shape of the smallest program

Here’s the smallest complete Rust program. Don’t worry about understanding every character yet — just look at the shape, then change it and run it for real. (The code box below talks to the official Rust Playground, so the “Run” button compiles your edit with a real Rust compiler and shows you exactly what it prints.)

Three things happen:

1. fn main() { ... } defines a function called main. Rust starts every program by running the function named main. The { and } braces wrap the function’s body.
2. let greeting = "hello, world"; creates a variable called greeting and points it at the text. The semicolon ends the instruction.
3. println!("{greeting}"); calls a built-in tool called println! (the ! marks it as a macro — for now, treat it as “print a line”). The {greeting} gets replaced with the value of greeting when the program runs.

Try editing the greeting in the box above and hitting Run again. You just compiled Rust.

Why the compiler argues with you

If you’ve heard about Rust before, you’ve heard people say it’s hard. What they mean is the compiler rejects your code more often than other languages would, with longer error messages. That’s true. What’s also true:

• The error messages tell you exactly what’s wrong and frequently suggest the fix.
• Once your code compiles, it works far more reliably than equivalent code in most languages.
• The mental model is small. Three or four core rules carry almost everything else.

Watch it happen. The program below tries to add a number to a piece of text — nonsense, and Rust refuses to build it. Hit Run and read the error; this is the picky-compiler experience in one screen.

Notice what didn’t happen: the program never ran and did something weird. The compiler stopped it at the door and explained why. In many languages this same mistake slips through to runtime and corrupts your output silently. Rust shifts the failure earlier, to the cheapest possible place to fix it.

A short history of a stubborn language

What you’ll learn here

The next twelve lessons walk through Rust in roughly this order:

• Foundations (you’re here, plus lessons 1–3): how a Rust project is laid out and run, how variables and types work, how to make decisions and repeat work.
• Ownership & Borrowing (4–6): the unique-to-Rust rules about who owns data, who can read or write it, and how memory is freed automatically.
• Types & Traits (7–9): how to define your own kinds of data, share behaviour across many types, and build pipelines that transform data.
• Errors & Options (10): how Rust handles things that can go wrong without exceptions.
• Concurrency (11): how Rust runs multiple things at once without the bugs that plague other languages.
• Capstone (12): a small real program that uses every concept above.

Every code box in this course runs for real — edit it, break it, fix it. That feedback loop is the fastest way to learn.

Key takeaways

• A program is instructions that hold, transform, and output data.
• Variables name data; types describe what the data is and what you can do with it; functions are named recipes.
• Rust is fast like C, but the compiler refuses to build programs that would crash from common memory or threading bugs.
• The borrow checker is the part of the Rust compiler that enforces those rules. It’s a co-author, not an opponent.
• The next lesson installs Rust and runs your first program. Read it next.