Advanced Rust Programming

From Mastery to Expert Systems Craft

Introduction: The Expert’s Rust

1. What This Book Assumes You Already Know
2. Why Go Deeper: The Gap Between Competent and Expert
3. The Mental Models That Matter Most
4. How to Read This Book

Chapter 1: Advanced Ownership and Borrowing

1. The Borrow Checker as a Constraint Solver
2. Variance: Covariance, Contravariance, and Invariance
3. Drop Semantics and Destructor Order
4. Complex Ownership Patterns Across Modules
5. Pinning and Self-Referential Structures (Preview)
6. Pitfalls: Use-After-Free in Safe Code and How to Avoid It

Chapter 2: The Trait System Deep Dive

1. Higher-Ranked Trait Bounds (HRTBs) in Practice
2. Associated Types Versus Generic Parameters
3. Generic Associated Types (GATs): Problems They Solve
4. Trait Objects and Dynamic Dispatch: When and How
5. The Orphan Rule, Sealed Traits, and API Design
6. Supertraits, Negative Impls, and Trait Resolution
7. Pitfalls: Coherence Failures and Ambiguous Resolutions

Chapter 3: Type-Level Programming and Advanced Patterns

1. The Type-State Pattern: Encoding State in Types
2. Zero-Sized Types: PhantomData and Marker Traits
3. Dynamically Sized Types (DSTs) Deep Dive
4. The Newtype Pattern: Safety, ABI, and Ergonomics
5. Compile-Time Computation with Const Generics
6. Pitfalls: Type Inference Limits and Error Explosion

Chapter 4: Interior Mutability and Smart Pointers

1. The Philosophy of Interior Mutability
2. RefCell, Cell, and UnsafeCell: The Hierarchy
3. Reference Counting: Rc, Arc, Weak, and Cycles
4. Building Custom Smart Pointers Safely
5. Synchronization Primitives as Interior Mutability
6. Pitfalls: Panics in Drop, Deadlocks, and Memory Leaks

Chapter 5: Memory Layout and Representation

1. Alignment, Padding, and Struct Layout Rules
2. #[repr] Attributes: C, Pack, Transparent, and Integers
3. Enum Memory Representation and Tagged Unions
4. Fat Pointers and Metadata
5. Cache-Friendly Data Layout and Performance
6. Pitfalls: Undefined Behavior from Misaligned Access

Chapter 6: Concurrency Foundations — Send, Sync, and Atomics

1. Send and Sync: Auto Traits Explained
2. Atomic Operations and Memory Ordering
3. The Sequential Consistency Default and When to Relax It
4. Building Thread-Safe Abstractions with Auto Traits
5. Crossbeam and Advanced Concurrency Utilities
6. Pitfalls: Data Races in Safe-Looking Code

Chapter 7: Advanced Concurrency and Lock-Free Patterns

1. Lock-Free Versus Wait-Free: Definitions and Trade-offs
2. Implementing a Lock-Free Stack in Rust
3. Work-Stealing Queues and Parallel Task Scheduling
4. Epoch-Based Reclamation (mimalloc, tikv-jemalloc patterns)
5. Rayon, Scope-Based Parallelism, and Data Parallels
6. Pitfalls: ABA Problem, False Sharing, and Priority Inversion

Chapter 8: Asynchronous Rust — Futures, Pinning, and Executors

1. The Future Trait: Polling Semantics from First Principles
2. Pin and Why Self-Referential Futures Need It
3. Executors: Work-Stealing, I/O, and Task Scheduling
4. Task Cancellation, JoinHandles, and Scope Safety
5. async/await Desugaring and Common Gotchas
6. Pitfalls: Blocking the Executor, Unpin Bounds, and Pin Projection

Chapter 9: Macros and Metaprogramming

1. Declarative Macros: Pattern Matching in macro_rules!
2. Hygiene, Span Preservation, and Debugging Macros
3. Procedural Derive Macros: Generating Boilerplate
4. Attribute and Function-Like Procedural Macros
5. Token Streams, Parsing with Syn, and Quoting
6. Pitfalls: Macro Explosion, Nightly Instability, and IDE Support

Chapter 10: Unsafe Rust and Safe Abstractions

1. The Contract of unsafe: What You Pledge to Uphold
2. Raw Pointers: *const, *mut, Nullability, and Dangling
3. Aliasing Rules and the Strict Alias Rule in Rust
4. Validity Requirements: When Is a Value “Valid”?
5. Building Safe Abstractions Over Unsafe Code
6. Pitfalls: Undefined Behavior That Compiles Cleanly

Chapter 11: FFI and Interoperability

1. extern “C” Blocks and Calling Conventions
2. Mapping C Types to Rust: Pointers, Structs, and Unions
3. Linking: Static, Dynamic, and Build Scripts
4. Callbacks and Function Pointers Across the Boundary
5. Handling Errors and String Encoding in FFI
6. Pitfalls: ABI Mismatches, Dangling Pointers, and Lifetime Lies

Chapter 12: Custom Allocators and no_std Programming

1. The Global Allocator Trait and Allocation Internals
2. Arena Allocators and Bump Pointers
3. Slab Allocators for Fixed-Size Objects
4. no_std Essentials: Core, Alloc, and Panic Handlers
5. Embedded Rust Patterns: HALs, RTIC, and Cortex-M
6. Pitfalls: Stack Overflow, Allocation Failure, and Missing Panics

Chapter 13: Performance Engineering and Profiling

1. Benchmarking with criterion: Statistical Rigor Over Wall-Clock Time
2. Profiling: From Sampling to Tracing
3. Build Configuration: Optimization Levels, LTO, and Codegen Units
4. Profile-Guided Optimization (PGO)
5. Cache Locality and Branch Prediction
6. Monomorphization Costs and Mitigation Strategies
7. Static Versus Dynamic Dispatch Performance
8. Zero-Cost Abstractions in Practice

Chapter 14: Ecosystem, Architecture, and Production Patterns

1. Error Handling Architecture: anyhow for Applications, thiserror for Libraries
2. Library Design: API Stability, Sealed Traits, and the Orphan Rule
3. Testing Strategies: Property-Based Testing and Fuzzing
4. Documentation Practices for Rust Libraries
5. Advanced Cargo: Workspaces, Features, and Conditional Compilation
6. Production Architectural Patterns

Conclusion: The Path to Rust Mastery

References