Most async Rust tutorials start with Tokio and skip what async actually is. This post goes back to first principles – the Future trait, the poll model, why Rust ships no runtime, and what a runtime is actually doing when it runs your code.
Tag: systems programming
Async Rust with Tokio Part 1: How Async Rust Works – Futures, Poll, and the Runtime Model
Before you can use Tokio effectively, you need to understand what async Rust actually is under the hood. This post covers the Future trait, the poll model, why Rust has no built-in runtime, and how laziness gives you control that most async runtimes do not.
Advanced Rust Series Part 10: Advanced Lifetime Tricks – Variance, PhantomData, and Zero-Cost Abstractions
The final part of the series goes deep into the type system: variance, PhantomData, the drop checker, and the techniques library authors use to write APIs that are both safe and zero-cost. The type-state pattern, newtype pattern, and phantom ownership explained with production-grade examples.
Advanced Rust Series Part 9: Lifetime Patterns in Production Code – Common Mistakes and How to Fix Them
Theory is one thing. Production code is another. This post covers the ownership and lifetime patterns that appear in real Rust codebases, the mistakes developers make repeatedly, and the diagnosis process that resolves borrow checker conflicts that have no obvious fix.
Advanced Rust Series Part 8: The Self-Referential Struct Problem – Pin, Unpin, and Async State Machines
Pin and Unpin are two of the most conceptually difficult parts of Rust. They exist to support self-referential structs and async state machines – understanding them demystifies how async Rust works under the hood and when you actually need to think about them.
Advanced Rust Series Part 6: Lifetimes in Trait Definitions and Bounds
Traits and lifetimes interact in ways that go well beyond what you see in basic Rust. This post covers lifetime bounds on traits, trait objects with lifetimes, and higher-ranked trait bounds – the features that power flexible and safe library APIs.
Advanced Rust Series Part 5: Lifetimes in Structs and Enums – Holding References Safely
Holding references inside structs and enums is where lifetime annotations become unavoidable. This post covers how to annotate data structures that borrow from external data, what the constraints mean in practice, and the design patterns that keep your code clean.
Advanced Rust Series Part 4: Lifetime Elision – What the Compiler Infers and When You Must Be Explicit
Most Rust code compiles without a single lifetime annotation. That is not luck – it is lifetime elision, a set of deterministic rules the compiler applies automatically. Understanding those rules tells you exactly when you need to write annotations and why some errors catch you off guard.
Advanced Rust Series Part 3: Lifetimes Demystified – Why They Exist and How to Read Them
Lifetimes are the part of Rust that scares developers the most. But they are not magic – they are just a way to tell the compiler how long references are valid. Once you understand what the compiler is actually asking, lifetime annotations start to make sense.
Advanced Rust Series Part 2: Borrowing Rules in Depth – The Borrow Checker Mental Model
The borrow checker is not a random obstacle – it has a clear set of rules and a consistent mental model. Once you internalize how it reasons about your code, you stop fighting it and start working with it. This post breaks down those rules at a level that changes how you write Rust.
