Introduction to Rust

Getting Started with Rust

Rust is a programming language that focuses on three things: safety, speed, and concurrency. It achieves these goals without a garbage collector, which is a process that runs in the background to clean up memory in languages like Java or Python. Instead, Rust uses a unique system called ownership to manage memory at compile time. This means many potential bugs are caught before your program even runs.

This focus on safety and performance has made Rust popular for everything from web servers and command-line tools to game engines and embedded systems.

Setting Up Your Environment

The easiest way to get Rust on your machine is with rustup, the official toolchain installer. It manages your Rust versions and keeps them updated.

# For macOS, Linux, or other Unix-like OSs:
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# For Windows, visit rustup.rs for the installer.

Running this command installs everything you need, including:

rustc: The Rust compiler.
cargo: Rust's package manager and build tool.
rustdoc: A tool for generating documentation.

Let's test the installation by creating a classic "Hello, world!" program. Cargo makes this simple.

# Create a new project called 'hello_world'
cargo new hello_world
cd hello_world

Cargo generates a new directory with a Cargo.toml file for project configuration and a src directory containing main.rs for your code. The main.rs file will already have this inside:

// This is the main function where the program starts.
fn main() {
    // Print text to the console.
    println!("Hello, world!");
}

To compile and run the program, just use cargo run from inside the hello_world directory.

$ cargo run
   Compiling hello_world v0.1.0 (/path/to/hello_world)
    Finished dev [unoptimized + debuginfo] target(s) in 0.50s
     Running `target/debug/hello_world`
Hello, world!

Ownership and Borrowing

Rust's most unique feature is its ownership system. It's a set of rules the compiler checks at compile time to ensure memory safety. If you've used other systems languages, you're likely familiar with manual memory management and its common pitfalls. Rust's ownership system helps you avoid them.

The rules of ownership are simple:

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

Think of it like a physical object. If you have a book and you give it to a friend, you no longer have it. Your friend is the new owner. In Rust, this is called a 'move'. Let's see it in action.

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

    // This line won't compile because s1's value was moved to s2.
    // println!("s1 is {}", s1);
}

If you try to compile this code, you'll get an error telling you that the value of s1 was moved. This prevents a 'double free' error, where two variables might try to clean up the same memory.

But what if you just want to let a function use a value without giving up ownership? For that, you use 'borrowing'. You can lend a reference to your data.

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

    // We pass a reference to s1, so we don't move it.
    let len = calculate_length(&s1);

    // We can still use s1 here because we still own it.
    println!("The length of '{}' is {}.", s1, len);
}

// This function borrows a String instead of taking ownership.
fn calculate_length(s: &String) -> usize {
    s.len()
}

By using the ampersand &, we create a reference that 'borrows' the value without taking ownership. The function can read the data, but it can't modify it. This is an immutable borrow. Rust also allows mutable borrows (&mut) for when you need to change the borrowed data, but with strict rules to prevent conflicts.

Concurrency in Rust

Concurrency, or running multiple computations at the same time, is notoriously difficult to get right. Common problems include 'race conditions', where multiple threads try to access and change the same data at once, leading to unpredictable results.

Rust's ownership and borrowing rules extend to concurrency. The compiler can detect potential race conditions at compile time, turning a difficult runtime bug into a compile-time error you can fix immediately.

Rust's motto for concurrency is: Fearless Concurrency. The type system and ownership rules give you the confidence to write concurrent code without introducing subtle bugs.

Rust's standard library provides tools for creating threads to run code in parallel. Let's look at a simple example of spawning a new thread.

use std::thread;
use std::time::Duration;

fn main() {
    // Spawn a new thread with a closure
    let handle = thread::spawn(|| {
        for i in 1..5 {
            println!("hi number {} from the spawned thread!", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 1..3 {
        println!("hi number {} from the main thread!", i);
        thread::sleep(Duration::from_millis(1));
    }

    // Wait for the spawned thread to finish
    handle.join().unwrap();
}

In this code, the main thread and the spawned thread run at the same time. The handle.join() call makes the main thread wait for the other thread to complete its work before the program exits.

Because the compiler enforces rules about who can access data when, you can write multi-threaded code that is safe by design. This is a huge advantage for building high-performance applications.

Quiz Questions 1/5

What are the three core goals that the Rust programming language is designed to focus on?

Quiz Questions 2/5

Which command is used to create a new Rust project directory with a default structure and configuration file?

With these fundamentals of installation, ownership, and concurrency, you're ready to start exploring what Rust can do. These core concepts are what make the language so powerful and reliable.

Rust for Web Development