Variables, mutability, basic types Learning Rust with Songs · 3:52 Dive into the fundamentals of Rust programming as you explore how to declare variables using the `let` keyword, understand why immutability is the default, and learn when to use `mut` to allow values to change.
Functions and control flow Learning Rust with Songs · 3:23 Dive into the fundamentals of Rust functions, exploring how to define them with the `fn` keyword, work with parameters, and specify return types using arrow syntax.
Ownership (the concept) Learning Rust with Songs · 3:25 Ownership (the concept) breaks down one of Rust's most fundamental principles — that every piece of data must have exactly one owner at a time. Listeners will come away understanding how this golden rule keeps memory safe and code running cleanly.
Move semantics (the mechanics) Learning Rust with Songs · 4:32 Dive into one of Rust's most fundamental concepts — move semantics — and discover how ownership transfers between variables, why originals become invalid after a move, and how this system keeps your programs fast and memory-safe without unnecessary copying.
Borrowing rules Learning Rust with Songs · 3:54 Dive into Rust's borrowing system and learn how references let you access values without taking ownership, keeping memory safe and your programs running clean.
Error handling with the question mark operator Learning Rust with Songs · 4:04 Discover how Rust's question mark operator provides an elegant solution for handling potential function failures, allowing errors to propagate gracefully instead of crashing your program.
Traits Learning Rust with Songs · 3:24 Dive into one of Rust's most powerful abstraction tools as you explore how traits let you define shared behavior across different types, creating clean, reusable contracts that keep your code organized and consistent.
Option and Result Learning Rust with Songs · 4:07 Dive into Rust's powerful Option and Result types, learning how to elegantly handle values that may or may not exist and operations that might fail — all without the dreaded null pointer surprises.
Iterators and closures Learning Rust with Songs · 3:34 Dive into two of Rust's most powerful features — iterators and closures — and discover how they work together to let you process data sequences elegantly and efficiently.
Collections (Vec, HashMap) Learning Rust with Songs · 3:37 Dive into Rust's most essential collection types, exploring how Vec lets you store and manipulate dynamically-sized sequences of data, while HashMap gives you powerful key-value storage for more complex organizational needs.
Smart pointers (Box, Rc, Arc) Learning Rust with Songs · 4:19 Dive into Rust's powerful smart pointer types as this track breaks down how Box, Rc, and Arc solve real memory management challenges, from single-owner heap allocation to safely sharing data across multiple parts of your program.
Interior mutability (RefCell, Mutex) Learning Rust with Songs · 3:31 Dive into the concept of interior mutability in Rust, exploring how RefCell and Mutex allow you to modify data that would otherwise be locked as immutable. You'll learn when to reach for each tool — RefCell for single-threaded runtime borrow checking and Mutex for safe shared mutation across multiple threads.
Macros basics Learning Rust with Songs · 4:07 Dive into the world of Rust macros, the powerful code-generation tools that eliminate repetition by expanding templates at compile time, saving you from writing the same code over and over again.
Shared state concurrency Learning Rust with Songs · 3:24 Dive into the challenges of shared state concurrency, where multiple threads competing for the same data can lead to dangerous race conditions. Learn how Rust's Arc and Mutex types provide safe, reliable solutions for managing shared data across threads.
Unsafe Rust (when and why) Learning Rust with Songs · 4:07 Venture into the shadowy side of Rust where safety guarantees are temporarily set aside, exploring when and why developers reach for unsafe code to unlock raw pointers, low-level memory access, and capabilities the compiler can't verify.
Structs and impl blocks Learning Rust with Songs · 4:21 Dive into the world of custom data types as Structs and impl blocks teaches you how to bundle related data fields into reusable blueprints, then bring them to life with their own methods and behavior.
Enums and pattern matching Learning Rust with Songs · 5:16 Dive into Rust's powerful enum system and discover how to define custom types with distinct variants, then use pattern matching to elegantly handle each case with precision and clarity.
By Case | Transparen LLC Learning Rust with Songs · 2:59 A deep dive into Rust's pattern matching system, exploring how the compiler enforces exhaustive case coverage to ensure every possible path through your code is handled.
Efficient Data Structure Selection Learning Rust with Songs · 3:24 Dive into the trade-offs between core data structures like arrays and linked lists, learning how memory layout, cache performance, and operation speed should guide your choices when writing efficient Rust programs.
Variable Sizing and Alignment Optimization Learning Rust with Songs · 3:24 Dive into the world of memory efficiency in Rust, where smart data type choices and struct field ordering can dramatically reduce wasted space. Learn how compiler alignment rules and padding work, and how to arrange your data structures to keep your programs lean and fast.
Stack Management and Recursion Control Learning Rust with Songs · 3:40 Dive deep into how Rust manages the call stack during function execution, exploring how stack frames are built, what they contain, and what happens when recursion pushes memory to its limits.
Compile-Time Memory Optimization Learning Rust with Songs · 3:16 Dive into the power of compile-time memory optimization in Rust, where you'll discover how to let the compiler do the heavy lifting before your program ever runs. Learn to use flags, constants, and dead code elimination to write leaner, faster programs that squeeze out every unnecessary byte.
Dynamic Memory Management Strategies Learning Rust with Songs · 3:15 Dive into the world of smart memory allocation strategies, where you'll learn how to avoid fragmentation pitfalls by pooling resources, grouping similar-sized allocations, and pre-allocating chunks to keep your programs running lean and efficient.
Memory Profiling and Debugging Techniques Learning Rust with Songs · 3:57 Dive into the essential tools and techniques for tracking down memory issues in Rust, from using Valgrind to catch leaks and allocation errors to leveraging GDB for dissecting crashes through stack traces.
Advanced Memory Mapping and Overlays Learning Rust with Songs · 3:57 Dive into the world of memory mapping and bank switching techniques that allow systems to transcend their built-in address space limitations. You'll learn how to unlock hidden memory banks and dramatically expand available resources even under tight hardware constraints.
BusyBox and Embedded Distribution Tools Learning Rust with Songs · 4:02 Explore how BusyBox packs hundreds of essential Linux utilities into a single compact binary, making it the go-to solution for embedded systems where memory and storage are at a premium.
Yocto Project: Professional Embedded Linux Learning Rust with Songs · 3:00 Dive into the Yocto Project, the powerful framework for building custom embedded Linux distributions, and learn how BitBake recipes, meta layers, and configuration files work together to create tailored operating systems for specialized hardware.
Architecture Porting Fundamentals Learning Rust with Songs · 4:10 A deep dive into the essentials of porting Rust to custom hardware, covering how architecture-specific code, abstraction layers, and device trees work together to bridge the gap between silicon and software.
Kernel Debugging and Performance Analysis Learning Rust with Songs · 2:59 Dive into the world of low-level kernel debugging as you learn to wield tools like KGDB to diagnose system crashes, set breakpoints, and trace execution through kernel space. You'll gain practical techniques for stepping through kernel functions and monitoring variables to pinpoint performance bottlenecks and critical failures.
Kernel Architecture Overview Learning Rust with Songs · 3:52 A deep dive into the fundamental split between kernel space and user space, revealing how your computer's most privileged layer manages memory, files, and processes while keeping applications safely separated above.
Introduction to Menuconfig Learning Rust with Songs · 3:16 Dive into the world of Linux kernel configuration with an introduction to Menuconfig, the interactive terminal tool that lets you navigate and customize kernel options with simple keystrokes.
Hardware Detection and Driver Selection Learning Rust with Songs · 3:23 Dive into the world of hardware detection as you learn how to identify and catalog the devices connected to your system using essential Linux commands like lspci, uncovering vendor IDs, device IDs, and everything from graphics cards to audio controllers. By the end, you'll know how to survey your hardware landscape and understand the information needed to find and select the right drivers.
Built-in vs Module Configuration Learning Rust with Songs · 3:24 Exploring the fundamental tradeoff between built-in and module-based kernel configuration, listeners will gain a clear understanding of how feature placement affects memory footprint, flexibility, and overall system performance.
Essential Kernel Subsystems Learning Rust with Songs · 3:39 A deep dive into the three foundational kernel subsystems — filesystem, networking, and memory management — Essential Kernel Subsystems breaks down how each layer works and how to configure them so your system runs at its best.
Device Driver Categories Learning Rust with Songs · 3:14 Explore the three fundamental categories of device drivers in the Linux kernel — block, character, and network — and discover how each one handles data differently to bridge the gap between hardware and software.
Kernel Build Optimization Learning Rust with Songs · 5:38 Kernel Build Optimization dives into the art of trimming bloated kernels for embedded and resource-constrained systems, teaching you how to identify and strip out unnecessary drivers, network stacks, and filesystems to reclaim precious memory and build leaner, more efficient Rust-powered systems.
Advanced Configuration Techniques Learning Rust with Songs · 5:14 Dive into the world of modular Rust configuration as this chapter breaks down how to split complex settings across multiple files, making your projects cleaner, more manageable, and version-control friendly. You'll learn how to work with configuration fragments that can be merged strategically, replacing unwieldy monolithic setups with focused, purposeful components.
Debugging Kernel Configuration Issues Learning Rust with Songs · 4:21 A deep dive into diagnosing and resolving kernel configuration problems, teaching listeners how to identify missing modules, broken dependencies, and driver issues that prevent a system from booting.
What Are Device Trees? Learning Rust with Songs · 2:56 A deep dive into the history and purpose of device trees, tracing how embedded systems evolved from hardcoded hardware descriptions to flexible, kernel-independent configurations that make driver development and board support far more manageable.
Device Tree Source Syntax Basics Learning Rust with Songs · 3:08 Dive into the fundamentals of Device Tree Source syntax, exploring how nodes and properties work together to map hardware components like chips and pins in embedded systems design.
Standard Device Tree Properties Learning Rust with Songs · 3:26 Dive into the world of device trees and discover how the Linux kernel identifies and communicates with hardware through properties like compatible strings, learning how these key-value pairs bridge the gap between physical silicon and the software drivers that control it.
Device Tree Compilation Process Learning Rust with Songs · 3:56 Demystifying the journey from human-readable Device Tree Source files to binary DTB format, this track walks you through the compilation pipeline — from preprocessor handling to final binary output — giving you a clear mental model of how hardware descriptions become machine-usable data.
Bootloader and Device Tree Loading Learning Rust with Songs · 3:52 Bootloader and Device Tree Loading walks through the critical early stages of system startup, from power-on reset through hardware validation to kernel preparation, revealing how the device tree binary (DTB) is loaded into memory and passed to the kernel via register three.
Kernel Device Tree Processing Learning Rust with Songs · 3:19 Dive into the kernel's boot process as it parses the Device Tree Blob, uncovering how magic numbers, version checks, and binary structures guide the system in discovering and configuring the hardware it needs to run.
Driver Matching and Platform Devices Learning Rust with Songs · 4:32 Explore how the Linux device tree works and how compatible strings connect hardware nodes to their matching drivers, as the platform bus brings devices to life at boot time.
Device Tree Overlays Learning Rust with Songs · 5:28 Device Tree Overlays explores how to dynamically modify hardware configurations at runtime without rebuilding the entire device tree, teaching listeners how to add sensors, load drivers, and extend system capabilities on the fly.
Debugging Device Tree Issues Learning Rust with Songs · 3:46 Dive into the world of embedded Linux debugging as this track walks you through diagnosing and resolving Device Tree issues when hardware fails to initialize. You'll learn how to interpret boot log errors, inspect proc/device-tree, and verify compatible strings and register values to get your devices back online.
Kernel Space vs User Space Architecture Learning Rust with Songs · 4:11 Dive deep into the fundamental architecture dividing modern operating systems into kernel space and user space, exploring how CPU privilege rings protect system resources while keeping applications safely contained in their own execution environment.
Driver Types and the Device Model Learning Rust with Songs · 3:49 Explore the three fundamental Linux driver types—character, block, and network—and discover how each one handles data differently within the kernel's device model.
Memory Management in Kernel Space Learning Rust with Songs · 3:16 Dive into the unique world of kernel-space memory management, where standard user-space functions like malloc don't exist and special kernel allocators like kmalloc and vmalloc rule the game — you'll learn when and why to use each one.