Complete Rust Programming Study Guide

flowchart TD
    A[Hub] --> B[Key Concepts]
    A --> C[Core Principles]
    A --> D[Practical Applications]
    B --> E[Fundamental definitions]
    C --> F[Design patterns]
    D --> G[Real-world usage]

Rust is a systems programming language that guarantees memory safety without garbage collection. Its ownership system, lifetimes, and borrow checker prevent entire classes of bugs — null pointer dereferences, dangling pointers, data races, and buffer overflows — at compile time. This safety comes with a steep learning curve, but the result is code that is both correct and fast.

This hub page maps every resource on this site. The learning path takes you from Rust’s core ownership model through traits, async programming, and systems programming, building a thorough understanding of how Rust works and how to write idiomatic, safe code.

• Ownership and Borrowing
• Lifetimes
• Types and Data Structures
• Traits and Generics
• Error Handling
• Async Programming
• Systems Programming
• Learning Path
• Cross-Site Resources
• FAQ

Ownership is Rust’s most distinctive feature. Every value has exactly one owner. When the owner goes out of scope, the value is dropped. Borrowing lets you reference a value without taking ownership. Understanding ownership is the foundation of everything in Rust.

• Ownership Basics — move semantics, Copy trait, and Clone trait
• References and Borrowing — shared references, mutable references, and the borrow checker
• Ownership Transfer — function parameters, return values, and move vs copy
• Slice References — string slices, array slices, and the &str type

Move semantics — When you assign a value to another variable or pass it to a function, the original variable is invalidated. The value is moved, not copied. This ensures each value has exactly one owner at a time, preventing double-free bugs.

The borrow checker enforces two rules: you can have either one mutable reference or any number of immutable references to a value at any given time. This prevents data races at compile time. References must always be valid — the compiler tracks lifetimes to ensure references do not outlive the data they point to.

Copy vs Clone — Types that implement Copy are bitwise-copied on assignment (integers, booleans, floating-point). Types that implement Clone can be explicitly duplicated with .clone(). Most types implement Clone but not Copy because cloning heap-allocated data is expensive.

Lifetimes are Rust’s way of tracking reference validity. Every reference has a lifetime — the scope for which it is valid. The compiler infers lifetimes in most cases, but sometimes you need to annotate them explicitly.

• Lifetime Basics — lifetime elision rules, function signatures, and the ‘static lifetime
• Struct Lifetimes — storing references in structs and the need for lifetime annotations
• Lifetime Bounds and Traits — where clauses, lifetime bounds, and the relationship between lifetimes and generics

Lifetime elision — The compiler applies rules to infer lifetimes in function signatures. Each input reference gets its own lifetime. If there is exactly one input lifetime, it is assigned to all output lifetimes. If there are multiple input lifetimes and one is &self or &mut self, the self lifetime is assigned to outputs.

The 'static lifetime means the reference lives for the entire program. String literals have 'static lifetimes because they are embedded in the binary. Do not use 'static as a workaround for lifetime issues — understand what the lifetime is actually expressing.

Lifetime annotations ('a) describe relationships between references without changing the actual lifetime. A function fn longest<'a>(x: &'a str, y: &'a str) -> &'a str says the return value’s lifetime is tied to both inputs — it lives as long as the shorter of the two.

Rust has a rich type system with structs, enums, tuples, arrays, vectors, and hash maps. Enums are algebraic data types — each variant can hold data, making them powerful for modeling state machines and recursive data structures.

• Structs — field initialization, methods, associated functions, and tuple structs
• Enums and Pattern Matching — enum variants, match expressions, and destructuring
• Collections — Vec, HashMap, HashSet, and BTreeMap
• String Types — String vs &str, UTF-8, and string manipulation

Enums with data are Rust’s algebraic data types. An enum variant can hold values of different types: enum Shape { Circle(f64), Rectangle(f64, f64), Triangle { base: f64, height: f64 } }. This makes enums ideal for modeling domain states and recursive data structures like linked lists and trees.

Pattern matching with match is exhaustive — the compiler ensures all variants are handled. Destructuring extracts data from enum variants and structs. Pattern matching is the primary way to handle conditional logic in Rust.

String vs &str — String is a heap-allocated, growable string that owns its data. &str is a string slice — a reference to a string stored elsewhere. Function parameters should take &str to accept both String and &str references.

Traits define shared behavior. A trait is a set of methods that a type can implement. Generics allow you to write code that works with any type that implements a given trait. Together, traits and generics enable polymorphism without inheritance.

• Trait Basics — defining traits, implementing traits, and the trait bound syntax
• Trait Objects — dynamic dispatch, the dyn keyword, and object safety
• Generics — generic functions, structs, enums, and monomorphization
• Trait Features — default methods, associated types, and operator overloading
• Common Traits — Display, Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash

Trait bounds constrain generics to types that implement specific traits. fn print_all<T: Display>(items: &[T]) requires T to implement Display. Multiple bounds use +: T: Display + Clone. The where clause provides an alternative syntax for complex bounds.

Monomorphization — Rust generates specialized code for each concrete type used with a generic function. This means generics have zero runtime cost — the compiler generates type-specific code at compile time. This is different from Java’s type erasure.

Trait objects (dyn Trait) enable dynamic dispatch — the method to call is determined at runtime using a vtable. Trait objects have a small runtime cost but enable heterogeneous collections: Vec<Box<dyn Shape>>. Not all traits are object-safe.

Rust handles errors with Result<T, E> and Option<T> — no exceptions. Result represents success (Ok) or failure (Err). Option represents presence (Some) or absence (None). The ? operator propagates errors concisely.

• Result and Option — creating, pattern matching, and unwrapping
• The ? Operator — error propagation, the From trait, and ergonomic error handling
• Custom Error Types — defining error types, the thiserror and anyhow crates
• Error Handling Patterns — when to use unwrap, expect, and how to design error types

Result<T, E> is the core error type. Ok(value) represents success. Err(error) represents failure. Functions that can fail return Result, and the caller must handle both cases. The ? operator short-circuits on error, propagating it up the call stack.

Optionrepresents an optional value. Some(value) means the value is present. None means it is absent. Option replaces null in other languages. The ? operator works with Option too — it returns None early if the value is absent.

The ? operator is syntactic sugar for error propagation. file.read_to_string(&mut content)? returns early with the error if the read fails. The From trait enables automatic error conversion, so you can use ? across different error types.

Rust’s async/await provides asynchronous programming with zero-cost abstractions. Futures are state machines compiled to efficient code. The async ecosystem includes Tokio for the runtime, async-std as an alternative, and frameworks like Axum and Actix for web services.

• Async Basics — async fn, .await, and the Future trait
• Async Runtime — Tokio, async-std, and the executor model
• Streams and Async Traits — Stream trait, async streams, and async in traits
• Concurrency Patterns — tokio::spawn, join!, select!, and channels

Futures in Rust are lazy — they do nothing until polled. The .await keyword suspends execution until the future completes. The compiler transforms async functions into state machines that implement the Future trait.

Tokio is the most widely used async runtime. It provides a multi-threaded executor, timers, I/O primitives, and channels. tokio::spawn launches a task on the runtime. tokio::select! races multiple futures.

Zero-cost abstractions — Rust’s async/await compiles to efficient state machines with no heap allocation or virtual dispatch. The overhead is comparable to hand-written state machines, making async Rust competitive with synchronous code in performance.

Rust is designed for systems programming — operating systems, device drivers, embedded systems, and performance-critical applications. Its lack of garbage collection, fine-grained memory control, and FFI capabilities make it suitable for low-level programming.

• Unsafe Rust — unsafe blocks, raw pointers, and when to use unsafe
• FFI and Interop — extern “C”, bindgen, and calling C from Rust
• Memory Layout — repr, alignment, padding, and size
• Embedded and No-std — no_std, embedded Rust, and bare-metal programming

Unsafe Rust enables operations the borrow checker cannot verify: dereferencing raw pointers, calling unsafe functions, accessing mutable static variables, and implementing unsafe traits. Unsafe blocks do not disable the borrow checker — they add capabilities the compiler cannot verify.

FFI (Foreign Function Interface) enables Rust to call C code and vice versa. extern "C" declares functions with C calling conventions. bindgen auto-generates Rust bindings from C headers. This enables gradual migration of C codebases to Rust.

No-std Rust removes the standard library dependency, enabling Rust in environments without an OS: embedded systems, bootloaders, and kernel modules. The core crate provides fundamental types. The alloc crate adds heap allocation.

Rust has a steep learning curve. The ownership system requires a mental shift from garbage-collected languages. Follow this progression.

• Understand ownership, borrowing, and the borrow checker
• Learn move semantics, Copy, and Clone
• Write small programs using references and slices

• Master structs, enums, and pattern matching
• Learn traits, generics, and trait bounds
• Study the common traits — Display, Debug, Clone, PartialEq

• Learn Result, Option, and the ? operator
• Understand lifetime annotations and elision rules
• Study custom error types with thiserror and anyhow

• Learn async/await and the Tokio runtime
• Study unsafe Rust and FFI
• Build a real systems project — CLI tool, web server, or embedded application

Wyatt’s Notes is a network of interconnected programming and study sites:

• C++ Programming Guide — if you are comparing Rust with another systems language
• Go Programming Guide — Go and Rust serve different niches in systems and backend programming
• Python Programming Guide — if you are comparing Rust with a high-level language
• Computer Science Study Guide — algorithms and data structures that apply to Rust
• Networking Guide — relevant for building networked Rust applications

Rust has the steepest learning curve of any mainstream language. Basic competence — writing programs that compile — takes 2–3 months. The ownership system requires a mental shift. Professional competence — writing idiomatic Rust with lifetimes, traits, and async — takes 6–12 months. The learning curve flattens significantly once ownership clicks.

The borrow checker is a compile-time analysis that tracks references to ensure they are always valid. It enforces ownership and borrowing rules: each value has one owner, references cannot outlive the data they point to, and you cannot have a mutable reference while immutable references exist. It prevents data races, dangling pointers, and null pointer dereferences.

It depends on your goals. Rust provides memory safety without garbage collection, making it ideal for systems programming, performance-critical code, and embedded systems. Go is simpler and faster to learn, making it ideal for web services, DevOps tooling, and rapid development. Learn Rust if you need maximum performance; learn Go if you need to ship fast.

Yes. Frameworks like Axum, Actix, and Rocket provide productive web development in Rust. Rust’s performance, type safety, and async/await make it excellent for high-performance APIs and microservices. The ecosystem is smaller than Node.js or Python but growing rapidly.

String is a heap-allocated, growable string that owns its data. &str is a string slice — a reference to a string stored elsewhere. Function parameters should take &str to accept both String and &str. Use String when you need to own and modify the string.

For most applications, no. Safe Rust provides everything you need. Unsafe Rust is required for FFI, implementing certain low-level abstractions, and working with hardware. Use unsafe sparingly and encapsulate it behind safe abstractions.

Last updated: 24 July 2026

Written by Wyatt. For questions or feedback, visit wyattau.com.