Rust
Full course · 21 lessonsRust is a systems programming language focused on safety, speed, and concurrency without a garbage collector. It powers everything from embedded devices to cloud infrastructure.
Getting Started with Rust
Install Rust, understand Cargo, create projects, write Hello World, and explore the toolchain.
Variables, Mutability, and Data Types
Variables, mutability, constants, shadowing, scalar types, compound types, and type inference.
Ownership and Borrowing
Ownership rules, move semantics, borrowing with references, mutable references, and the borrow checker.
Slices and References
String slices, array slices, string vs &str, slice patterns, and danging reference prevention.
Structs, Enums, and Pattern Matching
Struct definitions, tuple structs, unit structs, enums, Option and Result, match expressions, and if let.
Methods and Associated Functions
Method syntax, self parameters, associated functions, method chaining, and traits for shared behavior.
Vectors, Strings, and HashMaps
Vec<T> operations, String vs &str, HashMap and HashSet, iterating collections, and collection performance.
Error Handling: Result and Option
Result<T, E>, Option<T>, the ? operator, combinators (map, and_then, unwrap_or), custom error types, and error conversion.
Generics and Traits
Generic functions and structs, trait definitions, trait bounds, impl Trait, and blanket implementations.
Lifetimes
Lifetime annotations, lifetime elision rules, struct lifetimes, static lifetime, and lifetime subtyping.
Closures and Iterators
Closure types (Fn, FnMut, FnOnce), iterator adapters, iterator combinators, consuming producers, and lazy evaluation.
Modules, Crates, and Cargo
Modules and paths, module file system, external crates, Cargo.toml, features, and workspaces.
Smart Pointers: Box, Rc, Arc
Box<T> for heap allocation, Rc<T> for shared ownership, RefCell<T> for interior mutability, Arc<T> for thread safety.
Concurrency: Threads and Message Passing
Thread spawning, join handles, message passing with channels (mpsc), shared state with Arc, Send and Sync traits.
Async/Await and Tokio
Async functions, await syntax, futures, Tokio runtime, async I/O, tasks, and async patterns.
Unsafe Rust and FFI
Unsafe keyword, raw pointers, calling C functions, writing C-compatible APIs, and safety invariants.
Testing and Documentation
Unit tests, integration tests, doc tests, test organization, benchmarks, and documentation with rustdoc.
Macros
Declarative macros (macro_rules!), procedural macros, derive macros, attribute macros, and function-like macros.
Performance and Optimization
Profiling with perf/flamegraph, release optimizations, SIMD, inlining, and benchmark-driven optimization.
Building a CLI Application
Argument parsing with clap, error handling, configuration, logging, testing, and building a complete CLI tool.
WebAssembly with Rust
Compiling to WebAssembly, wasm-pack, wasm-bindgen, web-sys, DOM access, and performance considerations.
Free Books
The Rust Programming Language (The Book)
The official introductory bible covering ownership, borrowing, lifetimes, traits, and concurrency.
Rust by Example
Runnable code snippets illustrating Rust concepts and standard library features.
Comprehensive Rust (Google)
A multi-day course by Google covering Rust fundamentals, Android, and embedded systems.
Official Documentation
Rust Documentation Hub
All official language docs, library specs, compiler guides, and edition notes.
The Rust Reference
The formal specification of Rust syntax, grammar, semantics, and memory model.
The Rustonomicon
The advanced guide exploring unsafe Rust, low-level memory, and FFI.
Rust Standard Library Docs
Deep API documentation for all built-in primitives, traits, and modules.