0 views
Read
#0
Learning Rust - Pre-Requisite Skills & Setup Environment
Before writing any Rust code, you need to understand the basic concepts of systems programming, static typing, and the command line. In this episode you set up the official Rust toolchain with rustup, an editor with rust-analyzer, and Git, then verify the environment with your first cargo project.
August 10, 2026
00
Read
#1
Learning Rust - History, Background & Why Rust Is Needed
This episode traces the history of Rust from Graydon Hoare's personal initiative at Mozilla to the stable 1.0 release, the RFC process, and the edition system. You will also compare Rust with C and C++ from the perspectives of memory safety, null safety, and thread safety, and determine when Rust becomes the right choice.
August 10, 2026
00
Read
#2
Learning Rust - Core Concepts & Main Architecture
This episode breaks down how Rust works behind the scenes: compilation via LLVM, the borrow checker, and the ownership model. You will also get to know cargo as a build system, package manager, and workspace manager, along with the main components such as crate, module, trait, impl, and generic.
August 10, 2026
00
Read
#3
Learning Rust - Writing Your First Rust Program
This episode builds your first complete Rust program: the structure of binary and library crates, basic data types, variable immutability and shadowing, functions and expressions, as well as control flow with match and if. All examples can be run directly with cargo.
August 10, 2026
00
Read
#4
Learning Rust - Error Handling and Result
This episode breaks down error handling in Rust: the Result and Option types as error-safe values, match for handling results, the ? operator for concise error propagation, as well as building custom errors with thiserror and anyhow for production applications.
August 10, 2026
00
Read
#5
Learning Rust - Struct, Enum, Trait, and Generic
This episode builds data types in Rust: struct, tuple struct, and unit struct, enums with match as algebraic data types, traits as interfaces with default impls, as well as generic constraints that make code reusable without runtime cost.
August 10, 2026
00
Read
#6
Learning Rust - Memory Safety, Borrowing, and Lifetimes
This episode breaks down the heart of Rust's memory safety: the ownership and borrowing rules for immutable and mutable references, basic lifetime annotations and reference validity, plus the practice of transferring ownership with move, clone, and copy. You will understand why many Rust programs compile without memory bugs.
August 10, 2026
00
Read
#7
Learning Rust - Packages, Crates, and Dependency Management
This episode discusses package management in Rust: structuring Cargo.toml with features and dependency versions, building multi-crate workspaces for large applications, as well as keeping dependencies secure with cargo audit and cargo tree.
August 10, 2026
00
Read
#8
Learning Rust - Data Serialization, Persistence, and I/O
This episode discusses data management in Rust: serialization and deserialization with serde for the JSON and TOML formats, file and network stream I/O, async I/O with tokio, as well as database integration with sqlx, diesel, or sea-orm.
August 10, 2026
00
Read
#9
Learning Rust - Schema Evolution, Config, and Environment
This episode discusses Rust application configuration with config, dotenv, or figment, data versioning and type compatibility when schemas change, as well as the practice of separating config per environment for dev, staging, and production.
August 10, 2026
00