Introduction to Rust

Why Rust?

Many programming languages force you to make a tradeoff. You can have the raw speed and low-level control of a language like C or C++, but you risk memory bugs and crashes. Or you can have the safety and convenience of a language like Python, but you sacrifice performance. Rust is designed to give you both.

Rust is a systems programming language that runs blazingly fast, prevents segfaults, and guarantees thread safety.

It achieves this by focusing on three main goals:

Performance: Rust is a compiled language that produces highly optimized machine code, putting its speed on par with C and C++.
Safety: The language is designed to prevent common bugs, like null pointer errors and data races, at compile time. This means errors are caught before your program even runs.
Concurrency: Rust makes it easier and safer to write programs that do multiple things at once, without the bugs that often plague concurrent code.

A First Look at Rust

At first glance, Rust syntax might look familiar if you've seen C or C++. Here's the classic "Hello, world!" program in Rust:

// This is a comment.
// The main function is the entry point of the program.
fn main() {
    // The `!` indicates we're calling a macro, not a regular function.
    println!("Hello, world!");
}

Let's break this down:

fn main() { ... } defines a function named main. This is always the first code that runs in an executable Rust program.
println! is a macro that prints text to the screen. Macros are a way of writing code that writes other code, a powerful feature in Rust.

Compared to Python, Rust is more explicit. You have to compile your code before running it, and the syntax is stricter. Compared to C, it adds many modern features and safety checks.

Feature	Python	C	Rust
Performance	Slower (Interpreted)	Very Fast (Compiled)	Very Fast (Compiled)
Memory Safety	High (Garbage Collected)	Low (Manual)	Very High (Ownership)
Syntax	Simple, uses whitespace	C-family, requires semicolons	C-family, requires semicolons
Concurrency	Complex (GIL)	Difficult (Manual)	Safer by design

The Ownership System

The most unique feature of Rust is its ownership system. It's how Rust achieves memory safety without needing a garbage collector like Python or Java. The system is governed by three simple rules:

Each value in Rust has a variable that's called its owner.

There can only be one owner at a time.

When the owner goes out of scope, the value will be dropped (its memory is freed).

Let's see this in action. When a value is assigned to another variable, its ownership is moved.

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // Ownership of the data is moved from s1 to s2

    // This next line would cause a compile error!
    // s1 is no longer valid.
    // println!("{}", s1);
}

After let s2 = s1;, Rust considers s1 to be invalid. This prevents a problem called a "double free" error, where two variables could try to free the same memory. This is a common source of bugs in languages like C++.

Borrowing and Lifetimes

What if you want to let a function use a value without giving up ownership? For this, Rust has a feature called borrowing. You can create a reference to a value, which allows you to access it without taking ownership.

Think of it like lending a book to a friend. You still own the book, but your friend can read it for a while. You just can't both write in it at the same time.

fn main() {
    let s1 = String::from("hello");

    // We pass a reference to s1 to the function.
    // s1 is still the owner.
    let len = calculate_length(&s1);

    println!("The length of '{}' is {}.", s1, len);
}

// This function takes a reference to a String.
fn calculate_length(s: &String) -> usize {
    s.len()
}

Lifetimes are the final piece of the puzzle. They are Rust's way of ensuring that references are always valid. The compiler checks that any reference to data will never outlive the data it refers to. This prevents "dangling pointers," another common bug where a pointer refers to memory that has already been freed.

Together, ownership, borrowing, and lifetimes form a powerful system that lets Rust be both fast and safe.

Ready to check your understanding of these core concepts?

Quiz Questions 1/5

What are the three primary goals that guide Rust's design?

Quiz Questions 2/5

In Rust, the println! syntax indicates that println! is a...

These concepts are the foundation of writing safe and efficient Rust code. While they might feel different from other languages, they are what give Rust its unique power.

Mastering Rust for Systems Programming