Rust Learning Plan: Overview

This comprehensive 6-month Rust learning curriculum is designed for experienced developers transitioning to Rust, particularly those with a background in JavaScript/Node.js and React. It provides a structured path from beginner to expert level Rust programming.

Learning Path Overview

The curriculum is divided into four main sections:

Phase 1: Beginner (Weeks 1-6)

Week 1: Ecosystem (Beginner)

Day 1-2: Development Environment & Tools
Day 3-4: Package Management & Project Structure
Day 5-7: Tooling & Community

Weeks 2-6: Basics (Beginner)

Week 2: Fundamentals (variables, data types, functions, control flow, ownership)
Week 3: Ownership Deep Dive (references, borrowing, slices, string types)
Week 4: Structs & Enums (custom types, pattern matching, Option/Result)
Week 5: Error Handling & Collections (Vec, HashMap, iterators)
Week 6: Modules & Crates (organization, visibility, documentation)

Phase 2: Intermediate (Weeks 7-12)

Week 7: Generics & Traits (generic types, trait bounds)
Week 8: Advanced Traits & Lifetimes (trait objects, advanced patterns)
Week 9: Concurrency & Parallelism (threads, shared state, message passing)
Week 10: Async Rust (async/await, Tokio)
Week 11: Project Work (CLI app with Clap)
Week 12: Web Development (REST APIs with Axum, SQLx)

Phase 3: Advanced (Weeks 13-23)

Weeks 13-15: Advanced Rust Patterns

Week 13: Advanced Memory Management (allocators, smart pointers, ownership patterns)
Week 14: Unsafe Rust (raw pointers, FFI, safe abstractions)
Week 15: Advanced Design Patterns (type-state programming, zero-sized types, GATs)

Weeks 16-18: Systems Programming

Week 16: FFI and C Interoperability (C bindings, ABI, callbacks)
Week 17: Low-level Programming (memory-mapped I/O, OS interfaces, inline assembly)
Week 18: Embedded Rust (no-std, bare-metal, real-time systems)

Weeks 19-21: Performance and Optimization

Week 19: Performance Analysis (benchmarking, profiling, performance patterns)
Week 20: SIMD and Parallel Computing (vector intrinsics, rayon, lock-free structures)
Week 21: Advanced Optimizations (compiler optimizations, memory layout, allocation)

Weeks 22-23: Specialized Applications

Week 22: WebAssembly with Rust (wasm-bindgen, frontend frameworks)
Week 23: Advanced Concurrency Patterns (custom synchronization, executors, futures)

Phase 4: Expert (Week 24)

Week 24: Capstone Project (combining multiple advanced concepts)

Curriculum Structure

Each week’s plan includes:

Daily topics with progressive complexity
Curated learning resources (official docs, books, videos)
Real-world use cases and applications
Hands-on exercises and projects
Advanced challenges for deeper exploration

How to Use This Plan

Each week has a dedicated markdown file in the corresponding difficulty directory
Files follow the naming pattern: <topic>-week<number>.md
Each file contains:
- Detailed topics to be covered
- Links to resources
- Use cases for each concept
- Exercises and challenges

Time Commitment & Learning Style

This curriculum is designed for approximately 2 hours of daily focused learning, combining:

Conceptual learning from documentation and resources
Practical coding exercises and experiments
Progressive project development
Regular review and practice

Documentation Organization

This learning plan is organized into four main documentation sections:

Overview (this document) - High-level summary and guidance
Rust Ecosystem - Comprehensive guide to Rust tooling, community, and resources
Plan - Detailed week-by-week learning curriculum
Reading Materials - Curated list of learning resources by skill level

Skill Progression

Beginner Phase (Weeks 1-6)

By the end of the beginner phase, you’ll understand:

Rust’s unique ownership model and memory safety guarantees
Basic syntax, control flow, and data types
Structs, enums, and pattern matching
Error handling approaches
Package and module organization

Intermediate Phase (Weeks 7-12)

The intermediate phase builds on fundamentals to cover:

Generics and trait-based programming
Lifetimes and advanced type patterns
Concurrency primitives and parallel execution
Async programming with futures and tasks
Practical application development (CLI, web)

Advanced Phase (Weeks 13-23)

The advanced phase explores systems programming concepts:

Advanced memory management techniques
Unsafe Rust operations with safe abstractions
Advanced design patterns unique to Rust
FFI and interoperability with C code
Low-level systems programming
Embedded development without the standard library
Performance analysis and optimization techniques
SIMD and vectorized computation
WebAssembly development
Advanced concurrency patterns

Expert Phase (Week 24)

The expert phase focuses on:

Capstone project combining multiple advanced concepts
Applying knowledge from all previous weeks to create a complex application

Prerequisites

For Beginner Phase (Weeks 1-6)

Programming experience (ideally JavaScript/TypeScript)
Basic understanding of computer science concepts
Familiarity with command-line tools

For Intermediate Phase (Weeks 7-12)

Solid understanding of Rust fundamentals, including ownership
Experience with basic Rust syntax and concepts
Completion of beginner exercises

For Advanced Phase (Weeks 13-23)

Experience with traits, generics, and lifetimes
Comfort with concurrent and async Rust programming
Completed at least one substantial Rust project

For Expert Phase (Week 24)

Mastery of all previous concepts
Experience with multiple Rust projects
Understanding of systems-level programming concepts

Resources

The plan incorporates various learning resources:

The Rust Book (official documentation)
Rust By Example
Rustlings exercises
Topic-specific books and tutorials
Community resources and blogs
Advanced books like “Rust for Rustaceans” and “The Rustonomicon”

See the reading-materials.md file for a comprehensive list of resources for all skill levels.

Getting Started

Begin with Week 1: Rust Ecosystem to set up your development environment and understand the Rust ecosystem before diving into coding.

For advanced topics (weeks 13-23), it’s essential to have completed or be comfortable with all the beginner and intermediate topics first.

You can use Rust Playground to practice and experiment with Rust code.

Progress Tracking Recommendations

Consider tracking your progress by:

Creating a GitHub repository for your learning journey
Committing code exercises and projects regularly
Maintaining notes on concepts learned and challenges encountered
Creating a learning journal to document your experience
Building a portfolio of Rust projects as you progress

This curriculum provides a structured path to Rust mastery, blending theoretical knowledge with practical application at each stage of the journey.

Getting Started with the Rust Ecosystem

Understanding the ecosystem before diving deep into language details can give you a better foundation, especially with your development experience. Here’s a comprehensive overview of the Rust ecosystem from a practical perspective:

Development Environment Setup

IDE and Editor Support

Zed: A modern, feature-rich IDE, Has built-in Rust support.
VS Code/Cursor + rust-analyzer: Most popular setup with excellent intelligence
IntelliJ IDEA + Rust plugin: Full IDE experience
Vim/Neovim + rust.vim/rust-analyzer: For terminal enthusiasts
Emacs + rust-mode/rustic: Good support for Emacs users

Essential Tools

Rustup: Rust toolchain manager (installer, version manager)
- Manages multiple Rust versions
- Switches between stable/beta/nightly channels
- Adds cross-compilation targets
Cargo: The package manager and build system
- Project initialization: cargo new or cargo init
- Building: cargo build (dev) and cargo build --release (optimized)
- Testing: cargo test
- Documentation: cargo doc

Package Management

Crates and Dependencies

Crates.io: Central repository for Rust packages
Cargo.toml: Project manifest file (similar to package.json)
- Dependencies with semantic versioning
- Development dependencies
- Build dependencies
- Features for conditional compilation

Workspace Management

Cargo Workspaces: Managing multi-package projects
- Shared dependencies
- Cross-package references
- Selective building and testing

Useful Cargo Extensions

cargo-edit: Add/remove dependencies from command line
cargo-watch: Auto-rebuild on file changes
cargo-expand: Show expanded macros
cargo-outdated: Check for outdated dependencies
cargo-audit: Security vulnerability checking

Project Structure

Standard Layout

project/
├── Cargo.toml           # Project manifest
├── Cargo.lock           # Dependency lock file (like package-lock.json)
├── src/
│   ├── main.rs          # Binary entry point
│   ├── lib.rs           # Library entry point
│   └── bin/             # Additional binaries
├── tests/               # Integration tests
├── benches/             # Benchmarks
├── examples/            # Example code
└── docs/                # Documentation

Module System

Modules: Organizing code with mod
Visibility: Public/private items with pub
Imports: Using use statements

Testing and Quality Assurance

Testing Framework

Unit tests: Inside source files with #[cfg(test)]
Integration tests: In the tests/ directory
Doc tests: Executable examples in documentation

Code Quality Tools

Clippy: Extensive linting tool (cargo clippy)
Rustfmt: Code formatter (cargo fmt)
Miri: Undefined behavior detector
Coverage tools: cargo-tarpaulin for test coverage

Building and Deployment

Build Optimization

Profiles: Development vs release builds
LTO (Link-Time Optimization): For maximum performance
Conditional compilation: Feature flags and cfg attributes

Deployment Strategies

Static binaries: Self-contained executables
Docker containers: Multi-stage builds for small images
Cross-compilation: Building for different platforms
- cargo build --target x86_64-unknown-linux-musl

CI/CD Integration

GitHub Actions templates for Rust
GitLab CI configurations
Travis/Circle CI templates

Debugging and Profiling

Debugging

GDB/LLDB integration: Native debugger support
Debug symbols: RUST_BACKTRACE=1 for stack traces
Logging: Using the log crate with various backends

Profiling

Flame graphs: With cargo-flamegraph
Perf integration: System profiler
Memory profiling: Tools like DHAT and Valgrind

Common Ecosystem Components

Async Runtime

Tokio: Most popular async runtime
async-std: Alternative async runtime
smol: Lightweight async runtime

Web Frameworks

Actix Web: High-performance, actor-based
Rocket: Focus on ease-of-use and safety
Axum: Modern, Tower-based framework
warp: Composable web server library

Database Access

Diesel: ORM with compile-time checked queries
SQLx: Async SQL with compile-time verification
rusqlite: SQLite bindings
mongodb: MongoDB driver

Error Handling Libraries

anyhow: For application error handling
thiserror: For library error types
eyre: Enhanced error reporting

Production Considerations

Monitoring and Observability

Prometheus integration: Metrics collection
OpenTelemetry: Distributed tracing
Structured logging: With tracing or slog

Configuration Management

Config: Layered configuration system
Dotenv: Environment variable loading
Clap: Command-line argument parsing

Health Checks and Graceful Shutdown

Signal handling: For clean shutdown
Health check endpoints: In web services

Ecosystem Exploration

Finding Crates

lib.rs: Alternative crate index with better search
crates.io: Official package registry
Blessed crates: Community-recommended libraries at blessed.rs

Staying Updated

This Week in Rust: Weekly newsletter
/r/rust: Reddit community
Rust Blog: Official announcements

Starting Your First Project

Once you’re comfortable with the ecosystem, consider starting with:

A CLI tool using clap
A simple web API with actix-web or axum
A library that solves a specific problem

This approach will let you focus on the practical aspects of using Rust in a real development workflow before diving deep into language specifics, which should make the learning curve smoother given your existing programming experience.

Rust Learning Resources: Beginner to Expert

This document provides a curated list of reading materials and resources for learning Rust at all levels. Resources are organized by skill level and topic to help you find the right materials for your current learning phase.

Beginner Level Resources

Official Documentation

The Rust Book - The primary learning resource for Rust beginners
Rust by Example - Learn Rust through annotated examples
Rustlings - Small exercises to get you used to reading and writing Rust code

Interactive Learning

Exercism Rust Track - Coding exercises with mentorship
LeetCode - Practice algorithmic problems in Rust
Rust Playground - Experiment with Rust code in the browser

Video Courses

Rust Crash Course by Traversy Media
Rust for JavaScript Developers - Great for JS devs transitioning to Rust
Intro to Rust by Tensor Programming

Books for Beginners

“The Rust Programming Language” by Steve Klabnik and Carol Nichols - Official book
“Programming Rust: Fast, Safe Systems Development” by Jim Blandy, Jason Orendorff, and Leonora Tindall
“Rust in Action” by Tim McNamara
“Hands-on Rust” by Herbert Wolverson - Game development focused

Intermediate Level Resources

Official Documentation

Cargo Book - All about using Cargo effectively
Rust API Guidelines - Best practices for API design
Rust Design Patterns - Common patterns and idioms

Topic-Specific Learning

Command Line Applications in Rust - Guide for CLI apps
The Async Book - Asynchronous programming
Cookin’ with Rust - Practical examples for common tasks
Error Handling in Rust - Comprehensive guide by BurntSushi

Intermediate Books

“Rust for Rustaceans” by Jon Gjengset - Intermediate level Rust
“Zero To Production In Rust” by Luca Palmieri - Building a web application
“Black Hat Rust” by Sylvain Kerkour - Security-focused Rust

Videos & Talks

Crust of Rust by Jon Gjengset
RustConf talks - Annual conference presentations
Rust at Speed - Performance-focused overview

Advanced Level Resources

Official Documentation

The Rustonomicon - The dark arts of unsafe Rust
Rust Reference - Technical reference for the language
Rust Unstable Book - Unstable features

Advanced Topics

Pin and Suffering - Deep dive into Pin
Rust Atomics and Locks - Low-level concurrency by Mara Bos
Understanding Rust Futures by Going Way Too Deep
SIMD in Rust - Vectorization and SIMD optimization

Systems Programming

Writing an OS in Rust - Philipp Oppermann’s blog
Embedded Rust Book - Embedded systems programming
rustc Dev Guide - Compiler internals
inside.rust-lang.org - Rust team’s internal blog

Advanced Books

“Rust Atomics and Locks” by Mara Bos
“Rust for Rustaceans: Idiomatic Programming for Experienced Developers” by Jon Gjengset
“Hands-On Concurrency with Rust” by Brian L. Troutwine

Expert Level Resources

Language Deep Dives

MIR in Rustc - Mid-level IR in the compiler
Unsafe Code Guidelines - Expert-level unsafe Rust
Polonius - The next-gen borrow checker
Chalk - Rust’s trait system reimagined

Performance & Optimization

Compile-time Evaluation - Compile-time execution
LTO, PGO, and other Optimizations
Optimizing Rust - Advanced optimization guide

Specialty Topics

Source Code Study

Studying well-architected Rust codebases:

Rust standard library
Tokio - Async runtime
Serde - Serialization framework
Bevy - Game engine
ripgrep - Fast search tool

Community Resources

Reddit /r/rust
Rust users forum
Rust Discord
This Week in Rust - Weekly newsletter
URLO (Users) & IRLO (Internals) - Official forums
Rust Analyzer Blog - IDE implementation insights

Interactive Learning

Rust Quiz - Test your Rust knowledge
Rustlings Advanced - Advanced exercises
Advent of Code - Annual programming puzzles

Specialized Areas

Game Development

Web Development

Embedded Systems

Cryptography

RustCrypto - Collection of cryptographic algorithms
Dalek Cryptography - Cryptographic library implementations

Remember that the best way to learn is by doing. Combine these resources with practical projects to solidify your understanding.

Beginner Level

This section covers the fundamental concepts of Rust programming language that every beginner should know. The topics are structured to build your knowledge progressively from weeks 1-6.

Topics Covered

Ecosystem (Week 1): Introduction to Rust ecosystem, tools, and community
Fundamentals (Week 2): Basic syntax, data types, functions, and control flow
Ownership (Week 3): Rust’s unique ownership system, borrowing, and references
Structs & Enums (Week 4): Working with custom data types
Errors & Collections (Week 5): Error handling and using common collections
Modules & Crates (Week 6): Organizing code and using external libraries

By completing these modules, you’ll have a solid foundation in Rust programming and be ready to tackle intermediate concepts.

Week 1: Rust Ecosystem (Beginner)

Overview

This week focuses on getting familiar with the Rust ecosystem before diving into coding. Understanding the tooling, community resources, and project structure will give you a solid foundation.

Day 1-2: Development Environment & Tools

Topics

Installing Rust via rustup
Understanding rustup’s channel system (stable/beta/nightly)
Configuring VS Code with rust-analyzer
Basic Cargo commands (new, init, build, run, check, test)
Cargo.toml structure

Resources

Use Cases

Setup for all future Rust development
Understanding how to manage Rust versions and toolchains
Creating new projects efficiently
Running and testing code during development

Day 3-4: Package Management & Project Structure

Topics

Understanding the standard project structure
Cargo.toml vs Cargo.lock
Adding, updating, and removing dependencies
Semantic versioning in Rust
Exploring crates.io and lib.rs
Binary vs library crates
Basic module organization

Resources

Cargo Book
Crates.io
Lib.rs (Alternative crate registry with better search)
Package Layout Convention

Use Cases

Managing project dependencies
Organizing code in a maintainable way
Publishing packages to crates.io
Working with complex project structures

Day 5-7: Tooling & Community

Topics

Essential Cargo extensions:
- cargo-edit: Add/remove dependencies from command line
- cargo-watch: Auto-rebuild on file changes
- cargo-expand: Show expanded macros
- cargo-outdated: Check for outdated dependencies
- cargo-audit: Security vulnerability checking
Code quality tools:
- Clippy (linting)
- Rustfmt (formatting)
Documentation:
- rustdoc
- Generating and viewing docs with cargo doc --open
Community resources:
- Reddit r/rust
- This Week in Rust newsletter
- Rust users forum

Resources

Clippy Documentation
Rustfmt Documentation
This Week in Rust
Blessed.rs (Community-recommended libraries)
Rust Users Forum

Use Cases

Maintaining high-quality code
Finding solutions to common problems
Staying up-to-date with Rust developments
Leveraging community knowledge and best practices

Exercises

Set up your development environment with VS Code and rust-analyzer
Create a new project with cargo new and explore its structure
Add and use a simple dependency like colored or chrono
Run Clippy and Rustfmt on your code
Generate documentation for your project with cargo doc
Explore crates.io to find useful libraries for common tasks

Next Steps

After completing this week, you’ll have a solid understanding of the Rust ecosystem and tooling, preparing you for the syntax and concepts in the upcoming weeks.

Week 2: Rust Fundamentals (Beginner)

Overview

This week introduces the core language fundamentals and starts exploring Rust’s unique ownership system. You’ll learn basic syntax, variable handling, and control flow patterns that form the foundation of Rust programming.

Day 1-2: Variables, Data Types, and Functions

Topics

Variables and mutability
Constants
Shadowing
Basic data types:
- Integers (i8, i16, i32, i64, i128, isize)
- Unsigned integers (u8, u16, u32, u64, u128, usize)
- Floating-point (f32, f64)
- Booleans
- Characters
- Tuples
- Arrays
Type annotations and inference
Basic functions:
- Parameters and return values
- Statements vs expressions

Resources

Use Cases

Understanding Rust’s type system compared to JavaScript’s dynamic typing
Building blocks for more complex data structures
Writing reusable code with functions
Managing memory efficiently with appropriate data types

Day 3-4: Control Flow and Loops

Topics

If expressions
Loops:
- loop
- while
- for
Loop labels and breaking to labels
Returning values from loops
Match expressions (basic pattern matching)
If let expressions

Resources

Use Cases

Controlling program execution flow
Iterating over collections
Pattern matching for cleaner code (compared to switch/case)
Early returns from loops

Day 5-7: Ownership Basics

Topics

What is ownership?
Stack vs heap memory
Move semantics:
- Variable scope
- Memory allocation and freeing
- Moving ownership between variables
Clone and Copy traits
Introduction to borrowing
Comparing with JavaScript’s reference model

Resources

Use Cases

Memory safety without garbage collection
Preventing data races at compile time
Resource management beyond memory (file handles, network connections)
Efficient memory usage without manual management

Exercises

Create a program that converts between temperature scales (F/C)
Write a function that calculates factorial using different loop types
Implement a simple calculator using match expressions
Create a function that works with a vector and demonstrates ownership principles
Compare similar code in JavaScript and Rust, noting differences in memory handling

Next Steps

After completing Week 2, you’ll understand Rust’s fundamental syntax and have started exploring its unique ownership system. Week 3 will build on this by diving deeper into references, borrowing, and Rust’s string types.

Week 3: Ownership Deep Dive (Beginner)

Overview

Week 3 focuses on mastering Rust’s ownership system, which is the most distinctive feature of the language. You’ll explore references, borrowing rules, and how Rust handles string types - concepts that are fundamental for writing safe and efficient Rust code.

Day 1-3: References and Borrowing

Topics

References and borrowing
Immutable references (&T)
Mutable references (&mut T)
The borrowing rules:
- One mutable reference OR any number of immutable references
- References must always be valid
Dangling references and how Rust prevents them
Reference lifetimes (introduction)
The Deref trait basics

Resources

Use Cases

Avoiding ownership transfer when unnecessary
Safely allowing multiple parts of code to access data
Preventing data races at compile time
Modifying values in place without taking ownership

Day 4-7: Slices and String Types

Topics

What are slices?
String slices (&str)
Other slice types (&[T])
String vs &str:
- String: owned, growable UTF-8 text
- &str: borrowed view of UTF-8 text
Working with strings:
- Creation and manipulation
- Concatenation
- Indexing and slicing (and why UTF-8 makes this complex)
Converting between string types
Comparison with JavaScript strings

Resources

Use Cases

Efficiently working with text in Rust
Safe handling of text encodings (UTF-8)
Viewing portions of collections without copying
Performance optimization through borrowing

Exercises

Implement a function that takes a string slice and returns the first word
Create a program that counts characters, bytes, and grapheme clusters in a string
Write a function that safely handles mutable and immutable references
Implement a function that takes a slice of a collection and processes it
Create a program that demonstrates the difference between deep and shallow copying
Refactor a program that uses excessive clone() calls to use references instead

Advanced Challenges

Implement a simple text processing tool that efficiently handles large strings
Build a function that analyzes text and extracts statistics (word count, etc.)
Create a data structure that maintains references to external data safely

Next Steps

After completing Week 3, you’ll have a strong grasp of Rust’s ownership system - the feature that most distinguishes it from languages like JavaScript. Week 4 will build on this foundation by introducing structs and enums, Rust’s primary tools for creating custom data types.

Week 4: Structs and Enums (Beginner)

Overview

Week 4 introduces Rust’s custom data types: structs and enums. These are Rust’s building blocks for creating rich, type-safe data structures and are comparable to classes and interfaces in JavaScript/TypeScript, but with Rust’s safety guarantees.

Day 1-3: Structs and Methods

Topics

Defining and instantiating structs
Field init shorthand
Struct update syntax
Tuple structs
Unit-like structs
Methods with impl blocks
Associated functions (like static methods)
Builder pattern in Rust
Deriving traits (Debug, Clone, etc.)
Memory layout of structs

Resources

Use Cases

Creating domain-specific data types
Grouping related data together
Encapsulating data and behavior
Implementing object-oriented patterns in Rust
Building reusable components

Day 4-7: Enums, Pattern Matching, Option/Result

Topics

Defining enums
Enum variants with data
Methods on enums
The Option enum:
- Some and None variants
- Replacing null values
The Result enum:
- Ok and Err variants
- Error handling
Pattern matching with match
Advanced pattern matching:
- Destructuring
- Guards
- Binding
The if let syntax
The while let syntax
Comparing with TypeScript union types

Resources

Use Cases

Representing states and variants
Handling nullable values safely without null references
Error handling without exceptions
Creating type-safe state machines
Domain modeling with exhaustive pattern matching

Exercises

Create a Rectangle struct with width and height fields and methods to calculate area and perimeter
Implement a simple Shape enum with variants for different shapes and a method to calculate area
Build a simple address book using structs and enums
Implement error handling using the Result type
Create a program that safely handles optional values using Option
Design a state machine using enums and pattern matching

Advanced Challenges

Implement a simple vector library with structs and methods
Build a configuration parser that handles errors gracefully with Result
Create a command-line parser using enums for different commands
Design a simplified JSON representation using Rust enums and structs

Next Steps

After completing Week 4, you’ll be able to design custom data types in Rust and handle errors safely using the Option and Result types. Week 5 will expand on error handling and introduce Rust’s collection types.

Week 5: Error Handling & Collections (Beginner)

Overview

Week 5 focuses on two critical aspects of Rust programming: robust error handling and working with collections. You’ll learn idiomatic error handling patterns and how to effectively use Rust’s built-in collection types.

Day 1-3: Error Handling

Topics

Error handling philosophy in Rust
Using Result<T, E> for recoverable errors
The ? operator for error propagation
Creating custom error types
Using thiserror for deriving error types
Using anyhow for application error handling
panic! and unrecoverable errors
When to use unwrap() and expect()
unwrap_or(), unwrap_or_else(), and unwrap_or_default()
Error conversion and the From trait
Comparing with JavaScript/TypeScript error handling

Resources

Use Cases

Building robust applications that handle errors gracefully
Creating libraries with clear error reporting
Propagating errors up the call stack
Avoiding exception-like control flow
Making impossible states impossible through the type system

Day 4-7: Collections and Iterators

Topics

Vectors (Vec<T>):
- Creating and updating
- Reading elements
- Iterating over values
HashMaps:
- Creating and inserting
- Accessing values
- Updating based on existing values
- Ownership with hash maps
Other collections:
- VecDeque
- LinkedList
- HashSet
- BTreeMap/BTreeSet
The Iterator trait:
- Creating iterators
- Common methods (map, filter, fold)
- Collecting results
- Iterator adaptors (chain, zip, etc.)
Comparing with JavaScript arrays and objects

Resources

Use Cases

Managing groups of data efficiently
Choosing the right collection for performance needs
Transforming data with iterators
Building data processing pipelines
Working with complex data structures

Exercises

Create a program that reads a file and handles potential errors with custom error types
Build a function that processes data from a vector and propagates errors using ?
Implement a simple key-value store using HashMap
Create a program that uses iterators to process data from multiple sources
Build a CLI app that demonstrates proper error handling and reporting
Implement a function that processes collections with different iterator adaptors

Advanced Challenges

Create a custom collection type that implements the Iterator trait
Build an error type hierarchy for a multi-layered application
Implement a simple data processing pipeline with iterators and error handling
Create a configuration system that validates input and reports helpful errors

Next Steps

After completing Week 5, you’ll have a solid understanding of error handling patterns and collection usage in Rust. Week 6 will focus on organizing your code with Rust’s module system and creating reusable libraries.

Week 6: Modules & Crates (Beginner)

Overview

Week 6 focuses on organizing code in Rust using modules, packages, and crates. You’ll learn how to structure larger projects, create reusable libraries, and document your code. This is the last week covering beginner concepts before moving to intermediate Rust topics.

Day 1-3: Modules and Visibility

Topics

The module system:
- Creating modules with mod
- Module hierarchies
- Inline modules vs separate files
Visibility rules:
- Public (pub) items
- Private items (default)
- Restricted visibility (pub(crate), pub(super), etc.)
Paths and imports:
- Absolute and relative paths
- Using use statements
- Re-exporting with pub use
- Import grouping and nesting
The super and crate keywords
The 2018 module system
Comparing with JavaScript/TypeScript modules

Resources

Use Cases

Organizing code in a logical manner
Controlling the public API of your code
Preventing access to implementation details
Creating maintainable project structures
Managing code dependencies

Day 4-7: Creating Libraries and Documentation

Topics

Library crates vs binary crates
Creating a library crate
Publishing to crates.io:
- Package metadata
- Versioning
- Documentation
- License
Documentation comments:
- Inner documentation (//!)
- Outer documentation (///)
- Markdown in documentation
- Doc tests
- Example code
Workspace management:
- Setting up a workspace
- Sharing dependencies
Testing:
- Unit tests
- Integration tests
- Organizing test code

Resources

Use Cases

Creating reusable components
Building and sharing libraries
Documenting code for others (and future you)
Setting up large multi-package projects
Testing code effectively

Exercises

Refactor a simple program into multiple modules
Create a small library crate with a well-defined API
Document a library using doc comments and generate documentation
Set up a workspace with multiple related crates
Write both unit and integration tests for a library
Create a binary that uses your library crate

Advanced Challenges

Design and implement a library with a well-thought-out API
Create a workspace with shared code between a library and binary
Implement comprehensive documentation with examples and doc tests
Prepare a crate for publishing (without actually publishing)

Next Steps

After completing Week 6, you’ll have mastered the basics of Rust and be ready to move to intermediate topics. Week 7 will begin the intermediate phase by exploring generics and traits, which are the foundation of Rust’s powerful type system.

Intermediate Level

This section builds on the fundamentals to explore more advanced concepts in Rust programming. These topics (weeks 7-12) will deepen your understanding of Rust’s powerful features.

Topics Covered

Generics & Traits (Week 7): Creating flexible and reusable code with generics and traits
Advanced Traits & Lifetimes (Week 8): Deeper exploration of Rust’s trait system and lifetime annotations
Concurrency (Week 9): Multi-threaded programming in Rust
Async (Week 10): Asynchronous programming patterns and the async/await syntax
CLI Project (Week 11): Building command-line applications with Rust
Web Development (Week 12): Creating web applications with Rust frameworks

By mastering these intermediate topics, you’ll be equipped to build substantial Rust applications and be prepared for advanced concepts.

Week 7: Generics & Traits (Intermediate)

Overview

Week 7 marks the beginning of intermediate Rust concepts. This week focuses on generics and traits, which form the foundation of Rust’s powerful abstraction system. These concepts are similar to generics and interfaces in TypeScript, but with additional compile-time guarantees and zero-cost abstractions.

Day 1-4: Generic Types and Functions

Topics

Generic data types:
- Generic structs
- Generic enums
- Generic methods
Generic functions
Performance of generics (monomorphization)
Type parameters and constraints
Generic implementations
Multiple type parameters
Default type parameters
Zero-cost abstractions
Comparing with TypeScript generics

Resources

Use Cases

Writing code that works with multiple types
Creating reusable data structures
Building type-safe containers
Avoiding code duplication
Maintaining performance while achieving abstraction

Day 5-7: Traits and Trait Bounds

Topics

Defining traits
Implementing traits
Default implementations
Trait parameters
Trait bounds:
- Basic trait bounds
- Multiple trait bounds
- Where clauses
Returning types that implement traits
The impl Trait syntax
Operator overloading with traits
Important standard library traits:
- Debug, Display, Clone, Copy
- PartialEq, Eq, PartialOrd, Ord
- Default, From, Into, TryFrom, TryInto
Conditional trait implementations

Resources

Use Cases

Defining shared behavior
Creating flexible interfaces
Implementing polymorphism
Constraining generic types
Building extensible libraries
Customizing behavior for types

Exercises

Create a generic data structure (e.g., a binary tree or linked list)
Implement a function that works with any type implementing a custom trait
Create a utility function with multiple trait bounds
Implement several standard library traits for a custom type
Build a simple collection type with generic elements
Create a trait with default methods and implement it for various types

Advanced Challenges

Implement a generic algorithm (e.g., sorting or searching)
Create a type-safe event system using traits
Build a generic data structure with conditional trait implementations
Design an extensible plugin system using traits
Implement operator overloading for a custom numeric type

Next Steps

After completing Week 7, you’ll understand how to use generics and traits to create flexible, reusable code. Week 8 will build on this foundation by exploring advanced trait patterns and lifetime annotations.

Week 8: Advanced Traits & Lifetimes (Intermediate)

Overview

Week 8 explores advanced trait patterns and deepens your understanding of Rust’s lifetime system. These concepts enable you to create sophisticated abstractions while maintaining Rust’s memory safety guarantees without a garbage collector.

Day 1-4: Advanced Trait Patterns

Topics

Trait objects and dynamic dispatch:
- dyn Trait syntax
- Object safety
- Performance implications
Associated types vs generic parameters
Generic traits vs associated types
Supertraits (trait inheritance)
Marker traits (e.g., Send, Sync)
The Newtype pattern
Type erasure
Blanket implementations
Orphan rule and workarounds
Specialization (unstable feature)
Extension traits
Trait aliases (unstable feature)
Interior mutability traits:
- Cell and RefCell
- Mutex and RwLock

Resources

Use Cases

Creating heterogeneous collections
Building plugin architectures
Implementing dynamic behavior
Working around trait coherence rules
Providing flexible APIs
Safe concurrent data access
Creating extensible frameworks

Day 5-7: Lifetime Annotations and Advanced Lifetimes

Topics

Lifetime syntax refresher
Generic lifetime parameters
Lifetime elision rules
Lifetime bounds
Advanced lifetime patterns:
- Multiple lifetime parameters
- Lifetime subtyping
- Higher-ranked trait bounds (HRTB)
- Self in traits with lifetimes
Static lifetimes
Lifetime in closures
Reference-counted types:
- Rc and Arc
PhantomData for lifetime reasoning
Variance and phantom types

Resources

Use Cases

Working with complex data structures
Managing reference lifetimes in APIs
Creating safe APIs that work with borrowed data
Building self-referential structures
Understanding compiler lifetime errors
Defining complex relationships between data

Exercises

Implement a plugin system using trait objects
Create a data structure with associated types
Develop a trait that uses multiple lifetime parameters
Build a simple framework that uses trait objects for extensibility
Write a function using higher-ranked trait bounds
Implement the Newtype pattern to add functionality to an existing type

Advanced Challenges

Create a data structure with complex lifetime relationships
Implement a type-safe event system using dynamic dispatch
Build a small Entity-Component-System using traits
Create a heterogeneous collection with type erasure
Implement a custom smart pointer with appropriate lifetimes

Next Steps

After completing Week 8, you’ll have a deeper understanding of Rust’s type system and memory model. Week 9 will introduce concurrent programming in Rust using threads and shared state.

Week 9: Concurrency & Parallelism (Intermediate)

Overview

Week 9 introduces concurrent and parallel programming in Rust. You’ll learn how Rust’s ownership and type system guarantees thread safety, eliminating entire classes of bugs common in other languages. This week covers both thread-based concurrency and message passing, providing a strong foundation for high-performance, safe concurrent code.

Day 1-4: Threading and Shared State

Topics

Creating threads with std::thread
Thread lifecycle management
Join handles and blocking
Thread-local storage
Shared state concurrency:
- Mutex and interior mutability
- RwLock for multiple readers
- Arc for thread-safe reference counting
Poisoning and recovery
Thread safety traits:
- Send and Sync
- Auto traits and marker traits
- Thread bounds on generic types
Atomic types in std::sync::atomic
Memory ordering
Barriers and thread coordination
Thread pools and work stealing

Resources

Rust Book Ch 16.1-16.3
Rust Atomics and Locks (free online book)
Fearless Concurrency
Rust Concurrency Explained
Thread documentation
Sync documentation

Use Cases

Multi-threaded data processing
Parallelizing CPU-intensive tasks
Managing shared resources safely
Building thread-safe data structures
Implementing concurrent algorithms
Utilizing multi-core processors effectively

Day 5-7: Message Passing and Channels

Topics

Message passing concurrency
Channels in std::sync::mpsc:
- Single-producer, multi-consumer
- Bounded vs unbounded channels
- Synchronous vs asynchronous channels
Channel ownership and borrowing
Producer and consumer patterns
Fan-out and fan-in designs
Implementing worker pools
Error handling in concurrent contexts
Actor pattern basics
Synchronization primitives:
- Barrier
- Condvar (condition variables)
- Semaphore (from third-party crates)
Comparing with JavaScript’s approach (Workers, Promises)

Resources

Use Cases

Event-driven architectures
Pipeline processing models
Task distribution systems
Producer-consumer scenarios
Backpressure handling
Building responsive applications

Exercises

Create a multi-threaded application that processes data in parallel
Implement a thread-safe cache with Mutex and Arc
Build a pipeline using channels for data processing
Create a thread pool with work distribution via channels
Develop a simple map-reduce pattern using threads
Implement a concurrent counter with atomic types

Advanced Challenges

Build a multi-threaded web crawler
Implement a thread-safe data structure (e.g., concurrent HashMap)
Create a work-stealing thread pool
Develop an actor system for message passing
Build a parallel image processing tool

Next Steps

After completing Week 9, you’ll understand how to write safe, concurrent code in Rust. Week 10 will build on this foundation by introducing asynchronous programming with Rust’s async/await system.

Week 10: Async Rust (Intermediate)

Overview

Week 10 explores asynchronous programming in Rust using the async/await syntax. You’ll learn how Rust’s approach to async programming enables highly concurrent, non-blocking code without sacrificing safety or performance. This week forms a critical foundation for modern Rust server-side development.

Day 1-4: Intro to Async/Await

Topics

Async programming fundamentals:
- Blocking vs non-blocking I/O
- Concurrency vs parallelism
- Event loops and polling
The Future trait
Async/await syntax:
- async fn and async blocks
- The .await operator
Understanding zero-cost futures
Pinning and self-referential structs
Async lifecycle and state machines
Cancellation and dropping futures
Common async patterns:
- Sequential execution
- Concurrent execution (join!)
- Select and race (select!)
Task spawning and executors
Async closures (unstable feature)
Comparing with JavaScript’s Promises and async/await

Resources

Use Cases

Non-blocking I/O operations
Handling many concurrent connections
Building responsive UIs
Creating highly scalable services
Processing streams of data
Implementing timeouts and cancellation

Day 5-7: Tokio Runtime and Futures

Topics

Async runtimes in Rust:
- Tokio
- async-std
- smol
Tokio runtime features:
- Multi-threaded scheduler
- I/O driver
- Timer system
tokio::spawn and task management
Synchronization primitives:
- Mutex
- RwLock
- Semaphore
- Notify
Streams and async iterators
Backpressure handling
Channel types in Tokio:
- mpsc
- oneshot
- broadcast
- watch
Resource management in async code
Error handling in async contexts
Testing async code
Tracing and debugging async workflows
Performance considerations

Resources

Use Cases

Building high-performance network services
Creating async APIs and libraries
Implementing complex concurrent workflows
Handling real-time data processing
Building web servers and APIs
Creating resilient distributed systems

Exercises

Convert a synchronous file processing program to use async I/O
Build a concurrent TCP server with Tokio
Implement a rate-limited API client using async/await
Create an async data processing pipeline with backpressure
Develop a simple chat server using Tokio channels
Implement timeouts and cancellation for async operations

Advanced Challenges

Build an async web crawler with concurrent requests
Implement a simple HTTP server from scratch using async Rust
Create a distributed task processing system with Tokio
Develop an async stream processing library
Build a real-time notification system using broadcast channels

Next Steps

After completing Week 10, you’ll have a strong foundation in async Rust programming. Week 11 will apply these skills to build a complete command-line application using the Clap library.

Week 11: CLI Project Work (Intermediate)

Overview

Week 11 is dedicated to building a complete command-line application using Clap for argument parsing. You’ll apply the Rust skills you’ve learned so far to create a practical, feature-rich CLI tool.

Project Goals

By the end of this week, you’ll have built a fully functional CLI application with:

Robust command-line argument parsing
Multiple subcommands and options
Configuration management
Error handling and reporting
File I/O operations
Unit and integration tests
Documentation and help text

Day 1-3: Project Setup and Clap Basics

Topics

CLI application fundamentals
Clap basics:
- Defining commands and subcommands
- Adding arguments and options
- Validation rules
- Environment variable integration
- Help text generation
Project structure for CLI apps
Error handling in CLI contexts
CLI application testing strategies

Resources

Implementation Steps

Initialize a new project with cargo new <project-name> --bin
Add Clap as a dependency in Cargo.toml
Define the basic command structure
Implement help text and documentation
Create a basic error handling strategy
Set up tests for CLI arguments

Day 4-7: Implementing Core Functionality

Topics

Building modular CLI code
Implementing subcommands
Handling user input/output:
- Reading from stdin
- Writing to stdout/stderr
- Colorized output
Working with files and paths
Configuration management:
- Config files
- Environment variables
- Default settings
Progress reporting
Logging and tracing

Resources

Implementation Steps

Implement the core logic for each subcommand
Add file operations and data processing
Implement configuration management
Add progress reporting for long-running operations
Create a robust error reporting system
Implement logging for debugging

Project Ideas (Choose One)

File System Utility

Description: A tool for bulk file operations with advanced filtering
Features:
- Recursive search with regex patterns
- Batch renaming with templates
- File deduplication
- Content searching
- File metadata extraction

Data Processor

Description: A tool to transform data between different formats
Features:
- Convert between JSON, CSV, YAML, TOML
- Data validation and schema checking
- Data transformation with templates
- Data filtering and querying
- Batch processing

Developer Productivity Tool

Description: A utility to automate common development tasks
Features:
- Project templating
- Dependency analysis
- Code statistics
- Git operations automation
- Local environment checks

Network Utility

Description: A tool for network diagnostics and testing
Features:
- HTTP request testing
- DNS lookups
- Port scanning
- Network speed testing
- API endpoint testing

Advanced Extensions (Optional)

Add async capabilities with Tokio
Implement a TUI (Terminal User Interface) with crossterm or tui-rs
Add plugin architecture using dynamic loading
Implement shell completions generation
Create a configuration wizard for first-time users

Learning Outcomes

By the end of this project week, you’ll be able to:

Design and implement a complete CLI application
Use Clap for robust argument parsing
Handle errors appropriately in a CLI context
Write documentation for CLI tools
Test command-line applications
Apply multiple Rust concepts in a practical project

Next Steps

After completing Week 11, you’ll have a solid understanding of building CLI applications in Rust. Week 12 will focus on web development with Rust, exploring how to build APIs with frameworks like Axum or Actix Web.

Week 12: Web Development (Intermediate)

Overview

Week 12 explores web development with Rust, focusing on building APIs with modern web frameworks. You’ll learn how to create high-performance, type-safe web services and connect to databases - skills that are directly applicable to your experience as a Node.js developer.

Day 1-4: Web Frameworks and REST APIs

Topics

Overview of Rust web frameworks:
- Axum (focus)
- Actix Web
- Rocket
- Warp
Common components:
- Routing
- Middleware
- Request handlers
- Response types
- State management
- Error handling
Building REST APIs:
- Resource design
- CRUD operations
- Query parameters
- JSON handling with Serde
- Content negotiation
- Status codes and errors
Request validation and sanitization
Authentication and authorization basics
Testing HTTP services

Resources

Use Cases

Building microservices
RESTful APIs
JSON-based web services
Backend for web/mobile applications
Service integration
API gateways

Day 5-8: Database Integration with SQLx

Topics

Overview of Rust database libraries:
- SQLx (focus)
- Diesel
- rusqlite
- Postgres drivers
SQLx features:
- Compile-time query checking
- Async database access
- Macro-based query interface
- Transaction management
- Migrations
Database patterns in Rust:
- Repositories
- Connection pooling
- Error handling
- Type mapping
Implementing CRUD operations
Transaction management
Integration with web frameworks
Testing database code

Resources

Use Cases

Persistent data storage
Data access layers
Microservice backing stores
Type-safe data management
Database migration strategies
Query optimization

Day 9-13: Building a Complete Web Service

Topics

Project structure for web services
Configuration management
Environment variables and secrets
Logging and monitoring
Error handling strategies
Performance optimization
Containerization and deployment
Security best practices
Documentation with OpenAPI/Swagger
Health checks and graceful shutdown

Resources

Implementation Project

Build a RESTful API with the following features:

User authentication
CRUD operations on resources
Database integration
Error handling
Input validation
Logging and telemetry
Documentation
Tests (unit and integration)

Project Ideas (Choose One)

Task Management API

Description: A RESTful API for managing tasks and to-dos
Features:
- User registration and authentication
- Task CRUD operations
- Task categorization and tagging
- Due dates and reminders
- Task assignment
- Activity history

Content Management API

Description: A headless CMS API
Features:
- Content type definition
- Content CRUD operations
- Media handling
- Versioning
- Publishing workflow
- User roles and permissions

E-commerce API

Description: A backend for a simple e-commerce platform
Features:
- Product catalog
- Shopping cart management
- Order processing
- User accounts
- Product search and filtering
- Basic payment integration

Advanced Extensions (Optional)

Add OpenAPI documentation
Implement GraphQL with Async-GraphQL
Add WebSocket support
Implement rate limiting
Add a caching layer
Set up CI/CD pipeline

Learning Outcomes

By the end of this week, you’ll be able to:

Build web APIs with Rust web frameworks
Connect to databases using SQLx
Implement common web patterns in Rust
Structure a complete web application
Apply best practices for production web services
Compare Rust web development to Node.js

Next Steps

Congratulations on completing the 3-month Rust learning journey! You’ve progressed from complete beginner to an intermediate level, with the skills to build real-world applications. To continue your Rust journey, consider:

Contributing to open-source Rust projects
Building more complex applications
Exploring specialized areas like embedded Rust, WebAssembly, or systems programming
Participating in the Rust community
Implementing Rust in your professional work where appropriate

Advanced Level

This section covers sophisticated Rust programming concepts for experienced developers. These topics (weeks 13-23) explore the depths of Rust’s capabilities and specialized applications.

Topics Covered

Memory Management (Week 13): Deep dive into Rust’s memory model and management
Unsafe Rust (Week 14): Understanding and safely using unsafe Rust features
Advanced Design Patterns (Week 15): Implementing complex design patterns in Rust
FFI & C Interop (Week 16): Interfacing with C and other languages
Low-Level Programming (Week 17): Systems programming and low-level control
Embedded Rust (Week 18): Programming for embedded systems
Performance Analysis (Week 19): Profiling and optimizing Rust code
SIMD & Parallel Computing (Week 20): Using SIMD instructions and parallel computing
Advanced Optimizations (Week 21): Advanced techniques for maximizing performance
WebAssembly (Week 22): Compiling Rust to WebAssembly
Advanced Concurrency (Week 23): Advanced concurrency patterns and lock-free programming

These advanced topics will prepare you for expert-level Rust development and specialization in systems programming.

Week 13: Advanced Memory Management (Advanced)

Overview

Week 13 begins the advanced phase of the Rust learning journey, focusing on sophisticated memory management techniques. You’ll explore allocators, advanced smart pointer implementations, and complex ownership patterns that push the boundaries of Rust’s memory model while maintaining safety.

Day 1-2: The Allocator Interface

Topics

Global allocator and the GlobalAlloc trait
std::alloc module in depth
Custom allocator implementations
Allocator API and alignment requirements
Layout calculations and optimizations
Porting allocators from C/C++
Using existing allocator libraries:
- bumpalo
- mimalloc
- jemalloc
Measuring allocator performance

Resources

Use Cases

High-performance applications needing custom memory management
Embedded systems with specialized allocation needs
Gamedev with frame-based allocation strategies
Memory-constrained environments
Performance-critical applications

Day 3-4: Smart Pointers Deep Dive

Topics

Implementing custom smart pointers
Interior mutability patterns
Shared ownership with Rc<T> and Arc<T>:
- Implementation details
- Memory layout
- Reference counting mechanics
Handling weak references with Weak<T>
Breaking reference cycles
Custom Deref and DerefMut implementations
Smart pointer ergonomics and optimizations
GC-like patterns in Rust

Resources

Use Cases

Building complex data structures (graphs, trees)
Caching systems with weak references
Reference-counted resource management
Shared state in concurrent applications
Custom containers with specific memory characteristics

Day 5-7: Advanced Ownership Patterns

Topics

Self-referential structures:
- Challenges and approaches
- Using the Pin API
- std::pin module in depth
Ghost types and phantom data
Borrowed and owned handles
The Cow<T> (Clone on Write) pattern
Arena allocation patterns:
- Using crates like typed-arena
- Region-based memory management
Ownership in non-lexical contexts
The ouroboros crate for safe self-referential types
Working with uninitialized memory safely
Advanced lifetime management

Resources

Use Cases

Creating async state machines
Building self-referential data structures
Managing complex object graphs
Zero-copy deserialization
High-performance data processing
Memory-efficient data manipulation

Exercises

Implement a custom allocator that tracks memory usage
Create a self-referential struct using the Pin API
Build a simple reference-counting smart pointer
Implement a memory pool/arena for object allocation
Create a data structure that uses Cow<T> for efficient cloning
Benchmark different allocator implementations for a specific use case

Advanced Challenges

Implement a slab allocator for fixed-size objects
Create a safe abstraction for a self-referential structure without external crates
Build a custom Rc<T> implementation with different trade-offs
Design a memory-efficient graph data structure
Implement a custom allocator that works in no_std environments

Next Steps

After completing Week 13, you’ll have a deep understanding of Rust’s memory management capabilities. Week 14 will build on this knowledge by exploring unsafe Rust and the foundational abstractions that make it safe.

Week 14: Unsafe Rust (Advanced)

Overview

Week 14 explores the unsafe side of Rust, teaching you when and how to use unsafe code responsibly. You’ll learn to work with raw pointers, interface with foreign code, and build safe abstractions over unsafe implementations. This knowledge is crucial for systems programming and performance-critical code.

Day 1-2: Understanding Unsafe Fundamentals

Topics

The unsafe keyword and its scope
Unsafe blocks, functions, traits, and impls
The five unsafe superpowers:
- Dereferencing raw pointers
- Calling unsafe functions
- Implementing unsafe traits
- Accessing/modifying mutable static variables
- Accessing union fields
Safety invariants and contracts
Undefined behavior (UB) in Rust
Common unsafe patterns and anti-patterns
Tools for detecting UB:
- MIRI (Mid-level IR Interpreter)
- Address Sanitizer (ASAN)
- Valgrind

Resources

The Rustonomicon - The dark arts of unsafe Rust
Unsafe Code Guidelines
Understanding Undefined Behavior
MIRI Documentation
What Is Rust’s Unsafe? - Video explanation

Use Cases

Building safe abstractions over low-level operations
Performance-critical code where safety checks are too costly
Implementing data structures with complex invariants
Interoperating with non-Rust code
Bypassing compiler limitations in safe code

Day 3-4: Raw Pointers and Memory Manipulation

Topics

Raw pointer types: *const T and *mut T
Pointer creation and dereferencing
Pointer arithmetic and alignment
Null pointers and validity checks
Converting between references and raw pointers
Working with uninitialized memory:
- The deprecated std::mem::uninitialized
- Using MaybeUninit<T>
- Initialization patterns
Byte manipulation with std::ptr functions
Memory mapped I/O
Bit manipulation and direct memory access
Custom Drop implementations with raw pointers

Resources

Rustonomicon: Raw Pointers
std::ptr Documentation
MaybeUninit Documentation
Memory Alignment in Rust
Crust of Rust: Raw Pointers by Jon Gjengset

Use Cases

Custom allocators and memory pools
Zero-copy data processing
Hardware device access
Implementing complex data structures (linked lists, trees)
Low-level optimization of algorithms
Working with memory-mapped files

Day 5-7: Safe Abstractions Over Unsafe Code

Topics

Designing safe APIs that use unsafe internally
Encapsulating unsafe code
Proving correctness of unsafe code
Documentation practices for unsafe code
Safety invariants:
- Establishing and maintaining invariants
- Documenting invariants
Testing unsafe code:
- Fuzz testing
- Property-based testing
- MIRI-based testing
Wrapper types and abstraction techniques
Case studies of unsafe in standard library:
- Vec<T> implementation
- String implementation
- Smart pointers
Auditing unsafe code
The unsafe_op_in_unsafe_fn lint

Resources

Use Cases

Building foundational libraries
Creating data structures with complex internal representations
Performance optimization of critical paths
Interfacing with hardware or other languages
Framework development
Systems programming

Exercises

Implement a basic intrusive linked list using raw pointers
Create a safe abstraction over an unsafe memory buffer
Build a simple arena allocator using unsafe code
Implement a custom slice type with different safety guarantees
Use raw pointers to implement a non-standard collection
Create a safe wrapper around a C library function

Advanced Challenges

Implement a thread-safe buffer with lockless operations
Build a custom smart pointer with specialized memory management
Implement a memory-efficient B-tree using raw pointers
Create a zero-copy parser for a binary format
Design and implement a safe API for memory-mapped I/O operations

Next Steps

After completing Week 14, you’ll understand how to work with unsafe Rust responsibly. Week 15 will build on this foundation to explore advanced design patterns that leverage Rust’s type system for maximum safety and expressiveness.

Week 15: Advanced Design Patterns (Advanced)

Overview

Week 15 explores sophisticated design patterns that leverage Rust’s powerful type system. You’ll learn how to use advanced type-level programming techniques, zero-sized types, and state machines to create expressive, type-safe APIs. These patterns enable you to push more guarantees to compile time and reduce runtime errors.

Day 1-3: Rust-specific Design Patterns

Topics

RAII (Resource Acquisition Is Initialization) beyond basics:
- Scoped resources
- Nested RAII patterns
- Cleanup guards
Type-state programming:
- Encoding state in types
- State transitions as type transformations
- Preventing invalid states at compile time
Compile-time state machines:
- Encoding state machines in the type system
- Ensuring valid transitions at compile time
- Using generics to model state transitions
The builder pattern in depth:
- Required vs optional parameters
- Type-safe builders
- Validating configurations at compile time
The visitor pattern:
- Implementing visitors with traits
- Recursive visitors
- Performance considerations
Composition over inheritance patterns
Function objects and higher-order functions
Type erasure techniques

Resources

Use Cases

API design for complex libraries
Creating foolproof interfaces
Building robust state machines
Resource management
Domain-specific languages (DSLs)
Configuration management
Ensuring invariants at compile time

Day 4-7: Advanced Type System Techniques

Topics

Zero-sized types (ZSTs):
- Creating and using marker types
- Optimizations with ZSTs
- Type-level state with ZSTs
Phantom data and type markers:
- Using PhantomData<T>
- Type-level state tracking
- Variance annotations
Type-level programming:
- Type-level integers
- Const generics
- Type families
- Leveraging the trait system for type-level computation
Generic Associated Types (GATs):
- Using associated types with lifetime parameters
- Higher-kinded types in Rust
- Applications of GATs
Opaque types and impl Trait:
- Return position impl Trait
- Argument position impl Trait
- type_alias_impl_trait feature
Advanced trait bounds:
- Higher-ranked trait bounds (HRTB)
- Negative trait bounds
- Specialization (unstable)
Type-level macros and derive macros
The newtype pattern for type safety

Resources

Use Cases

Creating highly expressive APIs
Compile-time checked domain-specific languages
Implementing complex type-safe abstractions
Ensuring correctness at compile time
Creating deeply embedded domain models
Type-safe protocol implementations
Building self-documenting libraries

Exercises

Implement a type-state builder pattern that prevents invalid object construction
Create a compile-time state machine for a simple protocol
Build a type-safe database query builder using advanced type techniques
Implement a resource management system using RAII and cleanup guards
Create a type-safe units library using type-level programming
Build a type-safe task scheduler using GATs

Advanced Challenges

Design and implement a type-safe parser combinator library
Build a compile-time checked finite state machine
Create a type-safe SQL query builder that prevents SQL injection
Implement a session type system for enforcing protocol correctness
Design a workflow engine with compile-time validation of workflow steps

Next Steps

After completing Week 15, you’ll have a deep understanding of advanced Rust design patterns and type-level programming. Week 16 will shift focus to systems programming by exploring FFI and C interoperability, allowing you to interface Rust with existing codebases and systems.

Week 16: FFI and C Interoperability (Advanced)

Overview

Week 16 focuses on Rust’s Foreign Function Interface (FFI) capabilities, allowing seamless integration with C and other languages. You’ll learn how to create and consume C-compatible APIs, manage memory safely across language boundaries, and build reliable bindings to existing libraries. These skills are essential for systems programming and leveraging existing code ecosystems.

Day 1-3: Rust to C and C to Rust

Topics

Understanding C ABI (Application Binary Interface)
extern blocks and functions
Creating C-compatible Rust APIs:
- #[no_mangle] attribute
- extern "C" function declaration
- C-compatible types
- Proper error handling
Using C libraries from Rust:
- Declaring external functions
- Type mappings between Rust and C
- Handling C error patterns
The libc crate and platform types
Linking with C code:
- Static vs dynamic linking
- Build systems integration
- Conditional compilation
Exposing Rust to C/C++:
- Creating C-compatible libraries
- Header file generation
- Packaging for consumption by C/C++
cbindgen and bindgen tools

Resources

Use Cases

Integrating with existing C/C++ codebases
Creating Rust libraries usable from C/C++
Interacting with system libraries
Performance-critical code using C libraries
Gradual migration from C/C++ to Rust
Cross-language library development

Day 4-7: Advanced FFI Techniques

Topics

Memory management across boundaries:
- Ownership transfer between languages
- Safe memory handling practices
- Dealing with malloc/free vs Rust allocators
Managing C strings and raw pointers:
- CStr and CString types
- String conversion strategies
- Null termination and safety
Working with callbacks:
- Function pointers in FFI
- Safety considerations with callbacks
- Closures and FFI
- Lifetime issues with callbacks
Handling complex data structures:
- Slices and arrays
- Structs with special layout
- Enums and unions
- Generic types in FFI
Async Rust and C interop
Error handling across FFI boundaries
Threading and synchronization issues
Panics and unwinding across language boundaries
Creating comprehensive bindings with multiple tools

Resources

Use Cases

Audio/video processing with C libraries
Game engine integration
Operating system interfaces
Hardware acceleration via C libraries
Plugin systems across language boundaries
Embedded systems with mixed codebases

Exercises

Create a simple Rust function that can be called from C
Write Rust bindings for a small C library
Implement a callback system where C code calls into Rust functions
Create a wrapper around a C API that provides a safe Rust interface
Build a Rust library that can be used from both Rust and C
Develop a memory management strategy for resources shared between Rust and C

Advanced Challenges

Create bindings for a complex C library with many types and functions
Implement a bidirectional callback system between Rust and C
Build a plugin system where C plugins can be loaded into a Rust application
Create a safe Rust wrapper for a complex C API with numerous safety concerns
Develop a zero-copy data exchange mechanism between Rust and C

Next Steps

After completing Week 16, you’ll be able to confidently integrate Rust with C and other languages through FFI. Week 17 will build on this foundation by exploring low-level programming, including memory-mapped I/O, OS interfaces, and even inline assembly for direct hardware interaction.

Week 17: Low-level Programming (Advanced)

Overview

Week 17 dives into low-level programming with Rust, exploring direct hardware interaction, operating system interfaces, and performance optimization through inline assembly. You’ll learn techniques for building systems software, direct memory manipulation, and how to leverage platform-specific features while maintaining Rust’s safety guarantees where possible.

Day 1-2: Memory-mapped I/O

Topics

Memory-mapped I/O (MMIO) concepts:
- Memory-mapped vs port-mapped I/O
- Virtual memory and physical memory mapping
- Page tables and memory protection
Memory mapping in Rust:
- Using mmap via libc
- Safe abstractions with the memmap crate
- Memory-mapped files
- Shared memory between processes
Direct hardware access:
- Memory-mapped registers
- Device drivers fundamentals
- Volatile operations
- Memory barriers and cache control
- DMA (Direct Memory Access) concepts
Platform-specific considerations:
- Memory ordering
- Alignment requirements
- Atomic operations on MMIO regions

Resources

Use Cases

Device drivers
Embedded systems programming
High-performance file I/O
Inter-process communication
Graphics programming
Operating system development
Direct hardware manipulation

Day 3-5: Operating System Interfaces

Topics

System calls in Rust:
- The nix crate for Unix-like systems
- The winapi crate for Windows
- Platform-specific abstractions
File descriptors and I/O management:
- Low-level file operations
- Non-blocking I/O
- Event-driven I/O (epoll, kqueue, IOCP)
Building a custom async executor:
- Event loops from scratch
- Waker implementation
- Task scheduling
- Integrating with OS primitives
Process and thread management:
- Creating and managing processes
- Signals and interrupts
- Inter-process communication
- Thread scheduling and priorities
Security considerations:
- Capabilities and privileges
- Sandboxing
- Seccomp filters (Linux)

Resources

Use Cases

Custom runtime development
High-performance servers
Operating system components
File systems
Process monitoring tools
Network programming
Security-critical applications

Day 6-7: Inline Assembly

Topics

Rust’s inline assembly syntax:
- Basic syntax and usage
- The asm! macro
- The global_asm! macro
- Register constraints
- Memory constraints
- Clobbered registers
Platform-specific assembly:
- x86/x86_64 specifics
- ARM/AArch64 specifics
- RISC-V specifics
Common use cases:
- Performance optimization
- CPU-specific instructions
- Low-level algorithms
- Atomics and synchronization primitives
Safe abstractions over assembly:
- Encapsulating assembly in safe APIs
- Testing assembly code
- Portability considerations
SIMD intrinsics vs assembly

Resources

Use Cases

Cryptographic algorithms
Performance-critical code paths
Direct hardware manipulation
CPU feature detection
Custom synchronization primitives
Implementing missing instructions
Low-level operations not exposed in Rust

Exercises

Create a memory-mapped file utility for fast file access
Implement a basic device driver using memory-mapped I/O
Build a simple event loop using platform-specific system calls
Create a custom executor for async tasks
Implement a performance-critical algorithm using inline assembly
Build a safe abstraction over a system call that isn’t exposed in the standard library

Advanced Challenges

Implement a shared memory IPC mechanism with synchronization
Create a cross-platform memory-mapped ring buffer
Build a custom scheduler for specialized workloads
Implement CPU-specific optimizations using inline assembly
Develop a safe wrapper for a complex system call interface

Next Steps

After completing Week 17, you’ll have a solid foundation in low-level programming with Rust. Week 18 will focus on embedded Rust, where you’ll apply these low-level skills to resource-constrained environments without the standard library.

Week 18: Embedded Rust (Advanced)

Overview

Week 18 introduces embedded systems programming with Rust. You’ll learn how to work without the standard library, interact directly with hardware, and build applications for resource-constrained environments. This week combines systems programming knowledge with embedded-specific techniques to create reliable, efficient firmware.

Day 1-3: Bare-metal Programming

Topics

No-std development:
- Understanding no_std attribute
- Core library vs standard library
- Minimizing binary size
- Alternative allocators for embedded
- Panic handling in no_std environments
Embedded development workflow:
- Target-specific toolchains
- Cross-compilation setup
- Cargo configuration for embedded targets
- Linker scripts and memory layout
- Flashing and debugging tools
Microcontroller programming:
- Register access patterns
- Peripheral Access Crates (PACs)
- Hardware Abstraction Layers (HALs)
- Device initialization and configuration
- Memory-mapped registers
Embedded-HAL ecosystem:
- The embedded-hal traits
- Driver implementation and usage
- Platform-agnostic drivers
- Common peripherals (GPIO, UART, SPI, I2C)

Resources

Use Cases

Microcontroller firmware
IoT devices
Real-time systems
Sensor interfaces
Motor control
Wearable devices
Smart appliances
Low-power applications

Day 4-7: Real-time Considerations

Topics

Interrupt handling:
- Interrupt vectors and controllers
- Safe interrupt management in Rust
- Critical sections
- Shared resources in interrupt context
- Interrupt priorities and nesting
Real-time scheduling:
- Task prioritization
- Preemption
- Deterministic timing
- Real-time Operating Systems (RTOS) integration
- Deadline scheduling
Resource management:
- Static allocation strategies
- Stack usage optimization
- Power management
- Memory constraints
- Fixed-point arithmetic
Concurrency patterns for embedded:
- Mutex and critical section abstractions
- Message passing for embedded
- Actor frameworks
- State machine implementations
- Non-blocking algorithms
Hardware timer management:
- Precise timing operations
- PWM generation
- Timer interrupts
- Watchdog timers

Resources

Use Cases

Safety-critical systems
Industrial control
Medical devices
Automotive systems
Robotics
Aviation electronics
High-reliability devices
Low-latency applications

Exercises

Set up a no_std project for a microcontroller target
Implement a simple LED blink program using direct register manipulation
Create a HAL driver for a sensor using embedded-hal traits
Develop an interrupt-based UART communication interface
Build a simple real-time scheduler for embedded tasks
Create a power-efficient state machine for a battery-powered device

Advanced Challenges

Implement a no_std asynchronous executor for embedded systems
Build a feature-complete driver for a complex peripheral (e.g., display, Ethernet)
Create a preemptive multi-tasking system for a microcontroller
Develop a memory-safe DMA controller interface
Implement a real-time control system (e.g., PID controller for motor)

Next Steps

After completing Week 18, you’ll have the skills to develop embedded applications with Rust. Week 19 will shift focus to performance analysis and benchmarking, teaching you how to measure and optimize your Rust code for maximum efficiency.

Week 19: Performance Analysis and Benchmarking (Advanced)

Overview

Week 19 focuses on measuring, analyzing, and optimizing Rust code performance. You’ll learn how to use benchmarking frameworks, profiling tools, and performance analysis techniques to identify bottlenecks and improve efficiency. These skills are crucial for developing high-performance systems and applications.

Day 1-3: Benchmarking Frameworks

Topics

Introduction to benchmarking:
- Methodology and best practices
- Common pitfalls in benchmarking
- Micro vs macro benchmarks
- Statistical significance
The benchmark ecosystem:
- Standard library benchmarks (unstable)
- Criterion.rs
- Iai (performance regression testing)
- Bencher crate
- Benchmark harness alternatives
Designing meaningful benchmarks:
- Isolating performance factors
- Controlling environmental variables
- Avoiding measurement bias
- Realistic workloads
- Reproducible results
Statistical analysis of benchmarks:
- Interpreting benchmark results
- Variance and outliers
- Comparing performance between versions
- Throughput vs latency measurements
- Parameterized benchmarks
Continuous benchmarking:
- Setting up CI for performance testing
- Detecting performance regressions
- Reporting and visualization
- GitHub Actions for benchmarking

Resources

Use Cases

Performance regression testing
Algorithm comparison
Library optimization
Hardware selection
Resource scaling planning
Comparing implementation strategies
Performance budgeting

Day 4-7: Profiling Tools and Techniques

Topics

CPU profiling:
- Sampling vs instrumentation profiling
- Perf on Linux
- DTrace on macOS
- ETW on Windows
- Flamegraphs for visualization
- Call graph analysis
Memory profiling:
- Allocation tracking
- Heap profiling
- Cache behavior analysis
- DHAT (Dynamic Heap Analysis Tool)
- Valgrind tools
Platform-specific profiling:
- CPU performance counters
- Branch prediction analysis
- Instruction-level profiling
- Cache miss analysis
- Hardware performance events
Profiling specialized workloads:
- I/O-bound applications
- Networking performance
- Multi-threaded code
- GPU utilization
- Energy profiling
Interpreting profiling data:
- Identifying hot spots
- Recognizing patterns
- Common performance issues
- Correlating profiles with code

Resources

Use Cases

Finding performance bottlenecks
Optimizing memory usage
Reducing CPU consumption
Improving I/O performance
Identifying lock contention
Cache optimization
Reducing energy consumption

Exercises

Set up Criterion.rs to benchmark a set of algorithms with statistical analysis
Create a benchmark suite for a data structure implementation
Generate and analyze flamegraphs for a CPU-bound application
Profile memory usage patterns and optimize allocations
Set up continuous benchmarking in CI for a project
Use performance counters to analyze cache behavior of different algorithms

Advanced Challenges

Implement a custom benchmarking harness for a specialized workload
Create a profiling tool that integrates with Rust’s compiler to identify optimization opportunities
Develop a performance visualization tool for Rust applications
Benchmark and optimize a complex algorithm across multiple platforms
Create a comprehensive performance regression testing suite for a library

Next Steps

After completing Week 19, you’ll have the skills to analyze and optimize the performance of your Rust code systematically. Week 20 will build on this foundation by exploring SIMD and parallel computing for maximum computational throughput.

Week 20: SIMD and Parallel Computing (Advanced)

Overview

Week 20 explores advanced performance optimization techniques using Single Instruction Multiple Data (SIMD) and parallel computing. You’ll learn how to leverage SIMD instructions for data parallelism and develop sophisticated parallel algorithms to fully utilize modern multi-core processors.

Day 1-3: SIMD Programming

Topics

SIMD fundamentals:
- Vector processing concepts
- CPU architectures and SIMD extensions
- Data parallelism vs task parallelism
- SIMD registers and operations
- Limitations and considerations
Using SIMD in Rust:
- The std::simd module (unstable)
- Portable SIMD with packed_simd
- Platform-specific intrinsics
- Cross-platform abstractions
- Feature detection and runtime dispatch
SIMD programming patterns:
- Data layout optimization
- Vectorizable algorithms
- Loop vectorization
- Gather/scatter operations
- Masking and conditional execution
Auto-vectorization:
- Compiler optimizations
- Assisting the compiler
- Verifying vectorization
- Common obstacles
- LLVM vectorization passes

Resources

Use Cases

Image and video processing
Scientific computing
Cryptography
3D graphics and physics
Audio processing
Machine learning
Data compression
Text processing

Day 4-7: Advanced Parallel Algorithms

Topics

Thread pools and work stealing:
- The Rayon library in depth
- Work stealing scheduler internals
- Fork-join parallelism
- Task granularity optimization
- Custom schedulers
Lock-free data structures:
- Atomic operations
- Memory ordering
- ABA problem
- Lock-free queues, stacks, and hash maps
- Wait-free algorithms
Parallel iterators:
- Rayon parallel iterators
- Custom parallel iterators
- Execution policies
- Adaptive parallelism
- Parallel reduction algorithms
Parallel patterns and algorithms:
- Map-reduce
- Parallel scan and prefix sum
- Divide and conquer
- Pipeline parallelism
- Parallel sorting algorithms
Synchronization and coordination:
- Barriers
- Latches
- Phasers
- Thread coordination patterns
- Avoiding false sharing

Resources

Use Cases

Big data processing
Scientific simulations
Parallel compilation
Search algorithms
Database operations
Graph algorithms
Real-time data processing
Web servers and services

Exercises

Implement a vectorized image processing algorithm using SIMD
Create a portable SIMD implementation of a mathematical function
Build a parallel sorting algorithm with Rayon
Implement a lock-free concurrent data structure
Optimize a data processing pipeline using parallel iterators
Create a work-stealing thread pool from scratch

Advanced Challenges

Implement an optimized SIMD-accelerated string search algorithm
Create a parallel graph processing framework
Build a high-performance parallel hash map implementation
Develop a vectorized compression algorithm
Implement a parallel machine learning algorithm

Next Steps

After completing Week 20, you’ll be able to optimize computationally intensive code using both data and task parallelism. Week 21 will build on this by exploring advanced compiler and memory optimizations to squeeze the most performance out of your Rust code.

Week 21: Advanced Optimizations (Advanced)

Overview

Week 21 focuses on squeezing maximum performance out of Rust code through compiler optimizations and memory-level optimizations. You’ll learn how to leverage LLVM’s optimization capabilities, optimize memory layout and access patterns, and reduce allocation pressure for peak efficiency and throughput.

Day 1-3: Compiler Optimizations

Topics

The Rust compilation process:
- Rustc frontend
- MIR (Mid-level Intermediate Representation)
- LLVM backend
- Optimization passes
- Code generation
LLVM optimization passes:
- Understanding -C opt-level options
- Function inlining
- Loop optimizations
- Constant propagation and folding
- Dead code elimination
- LLVM optimization flags
Link-time optimization (LTO):
- Thin LTO vs full LTO
- Cross-module optimization
- Setting up LTO in Cargo.toml
- Trade-offs and build time impact
- Measuring LTO effectiveness
Profile-guided optimization (PGO):
- Creating performance profiles
- Instrumentation builds
- Feed-forward optimization
- Combined LTO+PGO approach
- AutoFDO (Automatic Feedback-Directed Optimization)
Rust-specific optimizations:
- Monomorphization
- Trait optimizations
- Iterator optimizations
- Bounds check elimination
- Const evaluation and propagation

Resources

Use Cases

Performance-critical applications
Reducing binary size
Embedded systems optimization
Game engines
Real-time processing systems
High-frequency trading
Computational libraries

Day 4-7: Memory Optimizations

Topics

Cache-friendly data structures:
- CPU cache hierarchy
- Cache line optimization
- Spatial and temporal locality
- Structure of Arrays (SoA) vs Array of Structures (AoS)
- False sharing avoidance
Memory layout optimization:
- Structure packing and alignment
- Field ordering for size reduction
- Enum optimization
- Zero-sized type optimization
- Custom DSTs (Dynamically Sized Types)
Allocation strategies:
- Stack vs heap allocation tradeoffs
- Pre-allocation and capacity management
- Object pooling
- Arena allocation patterns
- Small string/vector optimizations
Reducing allocation pressure:
- In-place operations
- Reusing allocations
- Custom allocators
- Bump allocators for short-lived objects
- Preventing heap fragmentation
Advanced techniques:
- Bit packing and compression
- Memory mapping for large datasets
- Custom slicing and chunking
- Memory prefetching
- Non-temporal stores

Resources

Use Cases

Memory-constrained environments
High-throughput data processing
Real-time systems with strict latency requirements
Large data structures
High-frequency event handling
Long-running applications
Embedded systems

Exercises

Use LLVM optimization flags to improve performance of a computationally intensive function
Implement LTO and PGO for a Rust application and measure the performance improvement
Redesign a data structure for better cache locality and measure the impact
Create a custom allocator optimized for a specific workload
Implement an object pool pattern for frequently allocated/deallocated objects
Optimize a struct’s memory layout by reordering fields and using appropriate types

Advanced Challenges

Create a benchmark comparing different memory layout strategies for a specific algorithm
Implement a LLVM optimization pass targeting a specific Rust pattern
Build a high-performance, cache-optimized data structure for a specialized use case
Create a memory profiler that suggests layout optimizations
Develop a custom PGO workflow for a complex application

Next Steps

After completing Week 21, you’ll have a deep understanding of performance optimization techniques at both the compiler and memory level. Week 22 will shift focus to WebAssembly, exploring how to use Rust to build high-performance web applications.

Week 22: WebAssembly with Rust (Advanced)

Overview

Week 22 explores WebAssembly (Wasm) development with Rust, teaching you how to build high-performance web applications using Rust compiled to WebAssembly. You’ll learn about Wasm fundamentals, JavaScript interop, and how to build full-stack Rust applications that run in the browser.

Day 1-3: Wasm Fundamentals

Topics

WebAssembly introduction:
- Wasm virtual machine architecture
- Linear memory model
- Execution model
- Security model
- Browser support and limitations
Building for the Wasm target:
- Setting up the wasm32 target
- Using wasm-pack
- Cargo configuration for Wasm
- Size optimization techniques
- Debug symbols and source maps
wasm-bindgen deep dive:
- JavaScript/Rust FFI
- Type conversions
- Memory management
- Async support
- Function exports/imports
- WebIDL bindings
- Custom sections
Rust core libraries in Wasm:
- std vs no_std in Wasm
- Available APIs in Wasm
- Working with the web platform
- Using non-browser Wasm runtimes
Optimizing Wasm performance:
- Size optimization
- Speed optimization
- Memory usage patterns
- Threading with Web Workers
- SIMD support in Wasm

Resources

Use Cases

Browser-based applications
Web games
Image/video processing in the browser
Data visualization
Browser extensions
Progressive web apps
Edge computing
Serverless functions

Day 4-7: Full-stack Rust with WebAssembly

Topics

Frontend frameworks:
- Yew: Virtual DOM-based framework
- Leptos: Fine-grained reactivity
- Dioxus: React-like API
- Seed: Elm-inspired framework
- Component patterns and state management
WebGPU integration:
- wgpu-rs in WebAssembly
- GPU-accelerated rendering
- Compute shaders
- 3D graphics programming
- Interaction with Canvas API
Server-side rendering:
- Isomorphic Rust applications
- Hydration patterns
- SSR with Wasm
- Performance considerations
Advanced JS interoperability:
- Web APIs integration
- Custom event handling
- DOM manipulation
- Working with browser APIs
- Web components
Testing and deployment:
- Unit testing Wasm modules
- Integration testing with headless browsers
- CI/CD for Wasm projects
- Bundling and deployment strategies
- Content delivery optimization

Resources

Use Cases

Single-page applications (SPAs)
Interactive data visualizations
Web-based games and simulations
Cross-platform applications
High-performance web components
WebGL/WebGPU applications
WebXR (VR/AR) experiences
Advanced interactive websites

Exercises

Create a simple Rust library compiled to WebAssembly and call it from JavaScript
Build a to-do application using Yew or Leptos
Implement a WebAssembly-powered image processing function
Create a custom WebAssembly component that interacts with the DOM
Build a data visualization using Rust, WebAssembly, and Canvas/SVG
Implement server-side rendering for a Rust frontend framework

Advanced Challenges

Create a browser-based game using Rust, WebAssembly, and WebGL/WebGPU
Build a full-stack application with Rust on both frontend and backend
Implement a WebAssembly-powered machine learning model that runs in the browser
Create a custom Rust/WebAssembly framework for a specific domain
Build a real-time collaborative application using WebAssembly and WebSockets

Next Steps

After completing Week 22, you’ll be able to build sophisticated web applications using Rust and WebAssembly. Week 23 will focus on advanced concurrency patterns, exploring custom synchronization primitives and executors to master Rust’s concurrency capabilities.

Week 23: Advanced Concurrency Patterns (Advanced)

Overview

Week 23 dives deep into advanced concurrency patterns in Rust, focusing on building custom synchronization primitives and understanding the internals of Rust’s async system. You’ll learn how to design sophisticated concurrent systems, implement your own executor, and master low-level concurrency techniques.

Day 1-3: Custom Synchronization Primitives

Topics

Building custom locks and mutexes:
- Understanding the std::sync primitives internals
- Implementing custom Mutex from scratch
- Specialized lock implementations
- Biased locking techniques
- Reader-writer lock optimizations
Wait-free algorithms:
- Lock-free vs wait-free algorithms
- Hazard pointers
- Memory reclamation techniques
- Epoch-based reclamation
- Wait-free data structures
- Non-blocking algorithms
Memory ordering models:
- Atomic operations in depth
- Memory barriers
- Acquire/release semantics
- Relaxed, Acquire, Release, SeqCst ordering
- Happens-before relationships
- The C++/Rust memory model
- Hardware memory models
Low-level synchronization:
- Futexes on Linux
- Event objects on Windows
- Park/unpark mechanics
- Condition variables
- Barriers and latches
- Semaphores

Resources

Use Cases

High-performance concurrent systems
Real-time applications
Low-latency trading systems
Operating system components
Database engines
Thread synchronization libraries
Lock-free data structures
High-throughput message passing

Day 4-7: Advanced Async Patterns

Topics

Building custom executors:
- Future internals
- Waker implementation
- Task scheduling
- Executor design patterns
- Work-stealing executors
- Integration with I/O
- Single-threaded vs multi-threaded executors
Futures implementation details:
- State machines
- Generator/coroutine theory
- MIR desugaring of async/await
- Stack unwinding in async context
- Async drop and the Drop trait
- The Pin API and self-referential futures
Advanced async patterns:
- Cancellation
- Timeouts and deadlines
- Backpressure management
- Resource management
- Graceful shutdown
- Error propagation patterns
- Stream processing patterns
Structured concurrency:
- Task spawning and lifetime management
- Scoped tasks
- JoinSet and JoinHandle
- Select statements
- Racing futures
- Cooperative task management
- Async function in traits

Resources

Use Cases

Custom async runtimes
Specialized task schedulers
High-performance network services
Event-driven architectures
Stream processing systems
Distributed systems
Reactive programming frameworks
Real-time communication systems

Exercises

Implement a custom Mutex with different fairness guarantees
Create a wait-free queue implementation
Build a simple thread pool with work stealing
Implement a basic Future executor from scratch
Create a custom synchronization primitive for a specific use case
Develop an advanced backpressure mechanism for async streams

Advanced Challenges

Build a lock-free concurrent hash map
Implement a custom async executor with novel scheduling properties
Create a structured concurrency library with advanced cancellation
Develop a benchmark suite comparing different synchronization primitives
Implement a custom async I/O system integrated with OS primitives

Next Steps

After completing Week 23, you’ll have mastered advanced concurrency patterns in Rust. Week 24 will bring together all the knowledge you’ve gained in a capstone project, allowing you to build a sophisticated system that demonstrates your expert-level Rust skills.

Expert Level

This final section represents the culmination of your Rust learning journey, where you’ll apply all your knowledge to create a substantial project.

Capstone Project (Week 24)

The capstone project is a comprehensive, real-world application that demonstrates mastery of Rust programming. This project will integrate multiple advanced concepts and techniques learned throughout the course.

By completing this expert-level project, you’ll demonstrate your proficiency in Rust and your ability to architect and implement complex systems using Rust’s powerful features.

Week 24: Capstone Project (Expert)

Overview

Week 24 is dedicated to building a comprehensive capstone project that integrates multiple advanced Rust concepts you’ve learned throughout the course. This project-focused week allows you to apply your expertise in a realistic, complex system that demonstrates your mastery of Rust at an expert level.

Project Options

Option 1: High-performance Distributed Database

Description: Build a distributed key-value store with strong consistency guarantees, focusing on performance, reliability, and scalability.

Key Features:

Distributed consensus (Raft or Paxos algorithm)
Custom storage engine with memory-optimized data structures
Lock-free concurrent access patterns
Network protocol with efficient serialization
Async I/O for maximum throughput
Configurable consistency levels
Automatic sharding and replication
Fault tolerance and recovery mechanisms
Monitoring and observability

Technologies and Concepts:

Advanced concurrency (Week 23)
Custom synchronization primitives
Lock-free data structures
Async runtime (Tokio)
Memory optimization techniques (Week 21)
SIMD acceleration for specific operations (Week 20)
WebAssembly for admin interface (Week 22)
Benchmarking and profiling (Week 19)

Option 2: Real-time Data Processing Pipeline

Description: Create a high-throughput, low-latency data processing system capable of ingesting, transforming, and analyzing streaming data in real-time.

Key Features:

Pluggable sources and sinks
Stream processing operators
Windowing and aggregations
Backpressure management
Exactly-once processing semantics
Fault tolerance with checkpointing
Custom memory management for data buffers
Dynamic scaling capabilities
Processing graph visualization

Technologies and Concepts:

Stream processing patterns
Memory-mapped I/O (Week 17)
Custom allocators (Week 13)
Parallel computation with Rayon (Week 20)
Lock-free data structures
Async processing for I/O bound operations
Profiling and optimization techniques
Type state programming for pipeline configuration

Option 3: Embedded Real-time Operating System

Description: Develop a minimal, real-time operating system for embedded devices with predictable scheduling, memory management, and device drivers.

Key Features:

Task scheduler with priority-based preemption
Memory allocator for constrained environments
Device driver framework
Interrupt handling
Inter-process communication
Power management
File system support
Networking stack (optional)
Shell interface

Technologies and Concepts:

No-std Rust (Week 18)
Low-level programming (Week 17)
Custom synchronization primitives
Memory management (Week 13)
FFI for hardware access (Week 16)
Inline assembly for critical sections (Week 17)
Type-level state machines (Week 15)
Advanced optimization techniques (Week 21)

Option 4: WebAssembly-based Collaborative Application

Description: Build a collaborative application (document editor, whiteboard, etc.) that runs in the browser using Rust compiled to WebAssembly, with real-time synchronization and offline capabilities.

Key Features:

Real-time collaboration with CRDT data structures
Offline-first capabilities with local-first data
Responsive UI with a Rust frontend framework
Rust backend for API and synchronization
End-to-end encryption
Optimistic UI updates
History and versioning
Rich media support

Technologies and Concepts:

WebAssembly and wasm-bindgen (Week 22)
Full-stack Rust development
Custom CRDT implementation
Advanced concurrency patterns
Memory optimization for browser environment
Lock-free data structures
WebAssembly threading (if supported)
SIMD acceleration for specific operations

Project Development Timeline

Days 1-2: Project Planning and Setup

Choose one project option or propose your own
Define detailed requirements and specifications
Design system architecture
Create technical design documents
Set up project repository
Configure CI/CD pipeline
Create initial project structure
Define interfaces between components

Days 3-6: Core Implementation

Implement the fundamental components
Develop core algorithms and data structures
Build out the primary functionality
Implement any custom memory management
Create concurrent/parallel processing mechanisms
Establish error handling and logging
Implement initial testing framework
Design benchmarking approach

Day 7: Integration, Testing, and Documentation

Integrate all components
Comprehensive testing
Performance benchmarking
Documentation
Deployment strategy
Final presentation of project

Evaluation Criteria

Your capstone project will be evaluated based on:

Technical Depth - Appropriate use of advanced Rust features and patterns
Code Quality - Clean, maintainable, and well-structured code
Performance - Efficient resource usage and appropriate optimizations
Robustness - Error handling, edge cases, and graceful degradation
Documentation - Clear explanations of design decisions and usage
Testing - Comprehensive test coverage with unit and integration tests
Innovation - Creative solutions to complex problems

Resources

Conclusion

This capstone project represents the culmination of your Rust learning journey. By successfully completing it, you’ll demonstrate expert-level Rust skills and create a substantial portfolio piece that showcases your ability to design and implement complex systems in Rust. The project should integrate multiple advanced concepts from the course and solve real-world problems with elegant, efficient Rust code.

Contributors

Ganapati V S