Variables, mutability, basic types symphonic, cinematic, dramatic, orchestral · 3:33 Dive into the foundational world of Rust variables, where you'll discover how immutability works by default and how the `mut` keyword unlocks the power to reassign values. Through dramatic orchestral swells, this chapter makes the essential distinction between fixed and mutable bindings unforgettable.
Functions and control flow jazz, smooth, saxophone, lounge · 3:10 Dive into the fundamentals of Rust functions, from declaring them with `fn` to working with parameters and return types, all while exploring how control flow shapes the logic that brings your code to life.
Ownership (the concept) reggae, caribbean, tropical, sunny · 3:03 Dive into one of Rust's most fundamental concepts — ownership — and discover how every piece of data has exactly one owner at a time, keeping memory safe and your code running clean.
Move semantics (the mechanics) jazz, smooth, saxophone, lounge · 3:31 Dive into one of Rust's most fundamental concepts: move semantics, where ownership of a value transfers completely from one variable to another, leaving the original invalid and eliminating the need for expensive data copies.
Borrowing rules reggae, caribbean, tropical, sunny · 3:54 Dive into one of Rust's most fundamental concepts as borrowing and references are broken down into simple, clear ideas that show you how to safely access values without taking ownership.
Lifetimes dark, ambient, mysterious, atmospheric · 4:18 Dive into one of Rust's most powerful and mysterious concepts as lifetimes are unveiled, revealing how the compiler tracks the lifespan of variables to ensure references never outlive the data they point to.
Structs and impl blocks rock, electric guitar, powerful, anthem · 4:21 Structs and impl blocks teaches you how to group related data into custom types using Rust's struct keyword, giving your programs a clean, organized foundation. You'll learn how to define fields with their types and bring your data structures to life with associated functionality through impl blocks.
Enums and pattern matching rock, electric guitar, powerful, anthem · 3:21 Dive into Rust's powerful enum system and discover how to define custom types with distinct variants, then master pattern matching to elegantly handle each case with precision and control.
Option and Result jazz, smooth, saxophone, lounge · 3:34 Dive into Rust's elegant approach to handling uncertainty with Option and Result, the powerful types that replace dangerous null values and unpredictable errors with clear, expressive code that forces you to handle every possible outcome.
Error handling with the question mark operator reggae, caribbean, tropical, sunny · 2:59 Dive into Rust's elegant error handling with the question mark operator, a powerful shorthand that automatically propagates errors up the call stack so your code stays clean, safe, and crash-free.
Generics rock, electric guitar, powerful, anthem · 3:32 A deep dive into Rust's powerful generics system, showing you how to write flexible, reusable code that works across multiple types without repeating yourself.
Traits jazz, smooth, saxophone, lounge · 3:46 Dive into one of Rust's most powerful features as traits unlock the ability to share behavior across different types through clean, contract-based design. You'll learn how to define common functionality that multiple types can implement, making your code more flexible and expressive.
Iterators and closures lo-fi, ambient, dreamy, relaxed · 3:09 Dive into two of Rust's most powerful features as you explore the Iterator trait and how closures work together to create clean, expressive loops that elegantly step through data.
Collections (Vec, HashMap) reggae, caribbean, tropical, sunny · 3:14 Dive into Rust's most essential collection types as Vec and HashMap take center stage, teaching you how to store, access, and dynamically manage data whether you need ordered lists or key-value pairs.
Modules and Cargo rock, electric guitar, powerful, anthem · 4:18 Modules and Cargo dives into how to keep growing Rust projects clean and maintainable by organizing code with the `mod` keyword and grouping related functions together. Listeners will learn how to break large codebases into logical, manageable pieces using Rust's powerful module system.
Smart pointers (Box, Rc, Arc) reggae, caribbean, tropical, sunny · 3:17 Dive into Rust's smart pointer types — Box, Rc, and Arc — and discover how they help you manage heap memory, share ownership across your program, and keep your code safe and efficient.
Interior mutability (RefCell, Mutex) lo-fi, ambient, dreamy, relaxed · 3:31 Dive into the world of interior mutability as Rust's RefCell and Mutex unlock the ability to modify data that would otherwise be off-limits, with RefCell handling single-threaded runtime borrow checking and Mutex keeping shared data safe across multiple threads.
Threads and message passing lo-fi, ambient, dreamy, relaxed · 3:25 Dive into Rust's concurrency model as you explore how to spawn threads and safely pass messages between them. You'll discover the tools Rust provides to make parallel programming powerful without the pitfalls of data races.
Shared state concurrency lo-fi, ambient, dreamy, relaxed · 2:49 Dive into the world of shared state concurrency in Rust, where multiple threads compete for the same data and race conditions lurk around every corner. You'll discover how Arc and Mutex work together to safely manage shared data, keeping your multithreaded programs stable and sound.
Async/await basics reggae, caribbean, tropical, sunny · 3:04 Dive into Rust's async/await syntax and discover how to write non-blocking code that keeps your program running smoothly while waiting on slow operations like file I/O or network requests.
Testing patterns jazz, smooth, saxophone, lounge · 3:29 Dive into Rust's testing ecosystem, from unit tests that verify individual functions to integration tests that ensure your components work together seamlessly. You'll learn how to write and organize tests using the `#[test]` attribute, giving you the confidence that your code does exactly what you expect.
Common traits (From, Into, Display, Debug) reggae, caribbean, tropical, sunny · 2:34 Dive into four of Rust's most essential traits — From, Into, Display, and Debug — and discover how they handle type conversions and control the way your data presents itself to both users and developers.
Macros basics jazz, smooth, saxophone, lounge · 3:07 A smooth introduction to one of Rust's most powerful features, macros — reusable code templates that expand automatically so you can write less and do more.
Unsafe Rust (when and why) symphonic, cinematic, dramatic, orchestral · 3:56 Venture beyond Rust's safety guarantees into the powerful world of unsafe code, where raw pointers and low-level operations unlock capabilities the compiler can't verify — and discover exactly when and why crossing that boundary is justified.