Introduction to Rust

Beginner ~15 min read

Rust is a modern systems programming language that focuses on safety, speed, and concurrency. It achieves memory safety without garbage collection, making it ideal for performance-critical applications while preventing common bugs like null pointer dereferences and data races.

What is Rust?

Rust is a statically-typed, compiled language designed for building reliable and efficient software. Created by Mozilla Research, Rust has become one of the most loved programming languages according to Stack Overflow's annual developer survey.

Key Features:

Memory Safety: Prevents segmentation faults and data races at compile time
Zero-Cost Abstractions: High-level features with no runtime overhead
Concurrency: Fearless concurrency with compile-time guarantees
Performance: Comparable to C and C++ in speed

Your First Rust Program

Let's start with the traditional "Hello, World!" program to see Rust in action:

Output

Click Run to execute your code

Pro Tip: The println! macro (note the !) is used for printing to the console. Macros in Rust are powerful metaprogramming tools that generate code at compile time.

Why Choose Rust?

Rust solves problems that have plagued systems programming for decades:

Problem	Traditional Approach	Rust Solution
Memory Leaks	Manual memory management or GC	Ownership system (compile-time)
Null Pointer Errors	Runtime checks	Option type (no null)
Data Races	Careful programming + testing	Borrow checker (compile-time)
Performance	C/C++ (unsafe) or GC (slower)	Zero-cost abstractions

Use Cases

Rust excels in domains where performance and reliability are critical:

Operating Systems: Parts of Linux kernel, Redox OS
Web Browsers: Firefox components (Servo engine)
Game Engines: High-performance game development
Embedded Systems: IoT devices, microcontrollers
Web Assembly: Fast, safe code for the web
CLI Tools: Fast command-line utilities (ripgrep, exa)

The Rust Philosophy

Rust's design is guided by three core principles:

Safety First: Rust prevents entire classes of bugs at compile time. If your code compiles, you can be confident it won't have memory safety issues or data races.

Performance: Rust gives you low-level control without sacrificing safety. No garbage collector means predictable performance.

Productivity: Great tooling (Cargo, rustfmt, clippy), excellent error messages, and a helpful community make Rust productive despite its learning curve.

Learning Curve: Rust has a steeper learning curve than languages like Python or JavaScript. The ownership system and borrow checker require a different way of thinking about memory management. Be patient—the investment pays off!

Rust vs Other Languages

Understanding where Rust fits in the programming language ecosystem:

Language	Speed	Safety	Best For
Rust	⚡⚡⚡	🛡️🛡️🛡️	Systems, performance-critical apps
C/C++	⚡⚡⚡	🛡️	Legacy systems, game engines
Go	⚡⚡	🛡️🛡️	Web services, cloud infrastructure
Python	⚡	🛡️🛡️	Scripting, data science, web

Common Mistakes

1. Expecting Rust to be like C/C++

While Rust is a systems language, its ownership model is fundamentally different from manual memory management.

// This won't compile in Rust!
// let s1 = String::from("hello");
// let s2 = s1;  // s1 is moved, not copied
// println!("{}", s1);  // Error: s1 no longer valid

// Correct approach: clone or borrow
let s1 = String::from("hello");
let s2 = s1.clone();  // Explicit copy
println!("{} {}", s1, s2);  // Both valid

2. Fighting the borrow checker

New Rustaceans often struggle with the borrow checker. Instead of fighting it, learn to work with it—it's preventing bugs!

// The borrow checker is your friend
// It prevents this dangerous pattern:
// let mut data = vec![1, 2, 3];
// let first = &data[0];
// data.push(4);  // Error! Can't modify while borrowed
// println!("{}", first);

// Correct: finish borrowing before modifying
let mut data = vec![1, 2, 3];
{
    let first = &data[0];
    println!("{}", first);
}  // Borrow ends here
data.push(4);  // Now OK

3. Ignoring compiler warnings

Rust's compiler provides excellent error messages. Read them carefully—they often include suggestions for fixes!

// Compiler will warn about unused variables
// let unused = 42;  // Warning!

// Prefix with _ to indicate intentionally unused
let _unused = 42;  // No warning

Exercise: Your First Rust Program

Task: Modify the program to print personalized information about yourself.

Requirements:

Create a variable for your name
Create a variable for your age
Print a greeting message using both variables
Add a comment explaining what the program does

Output

Click Run to execute your code

Show Solution

// A simple Rust program that introduces yourself
fn main() {
    let name = "Alice";
    let age = 25;
    
    println!("Hello! My name is {} and I am {} years old.", name, age);
    println!("I'm learning Rust programming!");
}

Summary

Rust is a systems programming language focused on safety, speed, and concurrency
Memory safety without garbage collection through the ownership system
Prevents common bugs like null pointers and data races at compile time
Performance comparable to C/C++ with modern language features
Excellent tooling including Cargo (package manager) and helpful compiler messages
Growing ecosystem used in browsers, operating systems, web assembly, and more

What's Next?

Now that you understand what Rust is and why it's valuable, the next step is to get Rust installed on your system. In the next lesson, we'll cover Installation & Setup, where you'll install Rust, set up your development environment, and verify everything is working correctly.

Next Installation & Setup