Hello, World! 👋

What programming actually is

A program is a list of instructions for a computer, written in a language both humans and machines can deal with. Computers only truly understand machine code: raw numbers. So we write in a human-friendly language (Rust!) and use a compiler to translate it into machine code.

Rust's compiler is called rustc, and it's famously strict, in the best way. Think of it as a friendly proofreader who catches your mistakes before your program ever runs, instead of letting it crash later.

Your first program

fn main() {
    println!("Hello, world!");
}

Three lines. Let's take them apart like a curious crab:

• fn main(): fn declares a function (a named block of instructions). The one called main is special: it's where every Rust program starts. No main, no program.
• { }: curly braces mark where the function's body begins and ends. Everything between them belongs to main.
• println!("Hello, world!"): prints text to the screen, then moves to a new line. The ! means it's a macro, a super-powered function that can do things normal functions can't (like accept any number of arguments). For now, just remember: printing needs the bang.
• ;: the semicolon ends an instruction, like a period ends a sentence.

Leaving notes: comments

Anything after // is a comment: the compiler ignores it completely. Comments are notes to your future self.

fn main() {
    // I wrote this on day one. Hi, future me!
    println!("Hello, world!"); // this part actually runs
}

Meet Cargo, your project butler 🎩

You could compile files by hand with rustc, but nobody does. Rust ships with Cargo, a tool that creates projects, builds them, runs them, tests them, and fetches libraries. In your terminal:

cargo new hello_rusty   # create a project
cd hello_rusty          # step inside
cargo run               # compile + run

Cargo made this folder structure for you:

hello_rusty/
├── Cargo.toml    ← project info & dependencies (like a recipe card)
└── src/
    └── main.rs   ← your code lives here (.rs = Rust source)

After running, a target/ folder appears too; that's where compiled machine code goes. You never edit it, and you can always delete it; Cargo will rebuild.

Break it on purpose 🔨

Here's a Rusty School secret: the fastest way to learn is to break things and read what the compiler says. Delete the semicolon after println!(...) and run it. You'll get something like:

error: expected `;`, found `}`
 --> src/main.rs:2:34
  |
2 |     println!("Hello, world!")
  |                              ^ help: add `;` here

Look at that: it tells you the file, the line, the column, and the exact fix. Rust's error messages are the best teaching assistant you'll ever have. Never fear red text: read it.

fn main() {
    println!("My name is Chris.");
    println!("I could eat tacos forever.");
}

fn main() {
    println!("  🦀");
    println!("~~~~~~~~");
    println!("the rusty sea");
}