How to Code in Rust: Step-by-Step Guide from Ownership to Async
Key Takeaways:
- Rust's ownership system prevents memory bugs at compile time—no garbage collector needed.
- Async in Rust uses zero-cost abstractions; you can run thousands of tasks with minimal overhead.
- CLI tools built with Rust (like `ripgrep`) are faster than Python equivalents by 5-10x.
- Systems programming in Rust gives you C-level control with memory safety guarantees.
---
Why Rust? (And Why You Might Struggle at First)
I've taught Rust to about 200 developers over the past three years. The first week is always rough. People coming from Python or JavaScript hit the ownership wall hard. But once that clicks, Rust becomes addictive.
Rust isn't just another language. It's a systems programming language that runs as fast as C, prevents segfaults, and guarantees thread safety. Firefox uses it for CSS rendering. Dropbox rewrote their sync engine in Rust. Even Microsoft uses it for Windows kernel components.
Let's walk through the core concepts you'll need to build real Rust projects.
1. Ownership: The Thing That Trips Everyone Up
Ownership is Rust's unique memory management system. Every value has a single owner at any time. When the owner goes out of scope, the value is dropped.
```rust
fn main() {
let s1 = String::from("hello");
let s2 = s1; // s1 is moved, no longer valid
// println!("{}", s1); // This would fail to compile
println!("{}", s2); // Works fine
}
```
Think of it like a library book. Only one person can check it out at a time. If you hand it to someone else, you lose access until they return it.
Borrowing lets you use a value without taking ownership:
```rust
fn calculate_length(s: &String) -> usize {
s.len()
} // s goes out of scope, but since it's a reference, nothing happens
```
Rules to remember:
- You can have either one mutable reference or any number of immutable references.
- References must always be valid (no dangling pointers).
2. Structs, Enums, and Pattern Matching
Rust's type system is expressive without being overly complex.
```rust
enum Command {
Quit,
Move { x: i32, y: i32 },
Write(String),
}
fn handle_command(cmd: Command) {
match cmd {
Command::Quit => println!("Goodbye"),
Command::Move { x, y } => println!("Moving to ({}, {})", x, y),
Command::Write(text) => println!("Writing: {}", text),
}
}
```
Pattern matching is exhaustive—the compiler forces you to handle every case. No more forgetting to handle that edge case in production.
3. Error Handling: No More Try/Catch Nightmares
Rust doesn't have exceptions. Instead, it uses `Result
```rust
use std::fs::File;
use std::io::Read;
fn read_file(path: &str) -> Result
let mut file = File::open(path)?; // ? propagates errors
let mut contents = String::new();
file.read_to_string(&mut contents)?;
Ok(contents)
}
```
The `?` operator is your best friend. It returns early if there's an error, otherwise unwraps the value. You'll use it constantly.
4. Async: When You Need Concurrency
Rust's async model is based on zero-cost futures. Unlike Go's goroutines, Rust's async tasks have no runtime overhead. You pay only for what you use.
```rust
use tokio::time::{sleep, Duration};
#[tokio::main]
async fn main() {
let task1 = tokio::spawn(async {
sleep(Duration::from_secs(2)).await;
println!("Task 1 done");
});
let task2 = tokio::spawn(async {
sleep(Duration::from_secs(1)).await;
println!("Task 2 done");
});
task1.await.unwrap();
task2.await.unwrap();
}
```
Comparison: Rust vs Go concurrency
| Feature | Rust (Tokio) | Go |
| --------- | -------------- | ---- |
| Memory per task | ~512 bytes | ~4 KB |
| Startup time | Instant | ~200ns |
| Scheduling | Cooperative | Preemptive |
| Safety | Thread-safe by default | Race conditions possible |
Rust's async is harder to learn initially, but you can run 10 million concurrent tasks on a laptop without breaking a sweat.
5. Building a CLI Tool: Your First Real Project
Let's build a simple file search tool in less than 50 lines.
```rust
use std::env;
use std::fs;
fn main() {
let args: Vec
if args.len() < 3 {
eprintln!("Usage: {}
std::process::exit(1);
}
let pattern = &args[1];
let path = &args[2];
let contents = fs::read_to_string(path)
.expect("Something went wrong reading the file");
for (i, line) in contents.lines().enumerate() {
if line.contains(pattern) {
println!("{}: {}", i + 1, line);
}
}
}
```
Compile with `rustc search.rs`, and you have a binary that runs in milliseconds. The Rust compiler catches off-by-one errors and buffer overflows before you run it.
6. Systems Programming: When You Need Speed
Rust shines for systems programming—writing operating systems, embedded firmware, or game engines. You can call C libraries directly via FFI, or write kernel modules.
```rust
#[no_mangle]
pub extern "C" fn add(a: i32, b: i32) -> i32 {
a + b
}
```
This function can be called from C code. Rust ensures no null pointer dereferences, no buffer overflows, and no use-after-free bugs.
Common Pitfalls (From Teaching 200+ People)
1. Fighting the borrow checker: Accept it. The borrow checker is right 99% of the time. If it rejects your code, there's a subtle bug you're missing.
2. Overusing clones: Cloning is easy but expensive. Use references first, then `Rc` or `Arc` if needed.
3. Ignoring lifetimes: Most people don't need explicit lifetimes beyond `'static`. Stick with simple patterns.
FAQ
Q: How long does it take to learn Rust?
A: Most developers reach basic productivity in 2-3 months of daily practice. The ownership concept takes about 2 weeks to internalize. Async adds another month. Compare this to Python where you can be productive in a week—Rust's learning curve is steeper, but the payoff is fewer bugs.
Q: Can I use Rust for web development?
A: Yes, but it's not as beginner-friendly as Node.js. Frameworks like Actix-web and Rocket exist, but you'll need to understand async and threading. For simple APIs, Rust can handle 100,000+ requests per second on a single machine, compared to about 30,000 for a typical Express.js app.
Q: Do I need to understand C before learning Rust?
A: No. Rust was designed to be approachable for programmers from any background. Knowing C helps with understanding memory layout, but it's not required. I've taught Rust to people who only knew Python, and they learned ownership faster than C veterans (because they had fewer bad habits to unlearn).