Learning Rust

TL;DR: Learning Rust through deliberate practice—ownership, borrowing, and pattern matching. Steep curve, excellent compiler.

A project to learn the Rust programming language through deliberate practice and note-taking.

Why Rust?

• Memory safety without garbage collection
• Performance comparable to C/C++
• Modern tooling (cargo, rustfmt, clippy)
• Growing ecosystem and community

Learning in Public

Documenting my learning journey helps solidify concepts. See Evergreen Notes.

Progress

Completed

• Install Rust and cargo
• Complete “Hello, World!”
• Understand ownership basics
• Work through Rustlings exercises

In Progress

• Build a CLI tool
• Understand lifetimes deeply
• Explore async Rust

Planned

• Contribute to open source
• Build a web service with Axum
• Learn WebAssembly with Rust

Key Concepts

Ownership

The core innovation of Rust:

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // s1 is moved, no longer valid
 
    // println!("{}", s1); // Error! s1 was moved
    println!("{}", s2); // Works fine
}

Borrowing

References without ownership transfer:

fn calculate_length(s: &String) -> usize {
    s.len()
} // s goes out of scope but doesn't drop what it refers to
 
fn main() {
    let s = String::from("hello");
    let len = calculate_length(&s);
    println!("Length of '{}' is {}", s, len); // s still valid
}

Pattern Matching

Powerful and exhaustive:

enum Result<T, E> {
    Ok(T),
    Err(E),
}
 
fn handle_result(result: Result<i32, String>) {
    match result {
        Ok(value) => println!("Success: {}", value),
        Err(e) => println!("Error: {}", e),
    }
}

Resources

Resource	Type	Status
The Rust Book	Book	Reading
Rustlings	Exercises	Done
Rust by Example	Tutorial	Reference
Jon Gjengset videos	Video	Watching

Connections

Learning Rust connects to my broader knowledge management practice:

• Taking atomic notes on concepts
• Building projects to solidify learning
• Writing to understand (see slow thinking)

Reflections

On Difficulty

Rust’s learning curve is steep but the compiler is incredibly helpful. Each error message is a lesson.

The type system forces you to think about edge cases upfront. This connects to slow thinking - investing time now saves debugging later.

Related

• Personal Website - Might add Rust-powered features
• Knowledge Management
• The Value of Slow Thinking