30 Days of Rust

Start your Rust journey with Day 1: Learn to declare variables, understand basic types, and use println! macro for output.

Master Rust's fundamental types in Day 2: integers, floats, tuples, and basic arithmetic operations.

Learn Rust functions in Day 3: parameters, return types, expressions vs statements, and function composition.

Master Rust control flow in Day 4: if/else expressions, match patterns, and loops (loop, while, for).

Understand Rust's ownership system in Day 5: the core concept that makes Rust memory-safe without garbage collection.

Learn Rust borrowing and references in Day 6: immutable and mutable borrows, reference rules, and avoiding ownership transfer.

Master Rust slices in Day 7: string slices, array slices, and working with contiguous sequences.

Create custom data types with Rust structs in Day 8: define fields, implement methods, and model complex data.

Master Rust enums and Option type in Day 9: define variants, pattern match, and handle null-safety elegantly.

Add behavior to types with impl blocks in Day 10: methods, associated functions, and self parameter.

Handle errors gracefully in Day 11: Result type, the ? operator, and error propagation patterns.

Master Vec<T> in Day 12: Rust's growable, heap-allocated array.

Understand String vs &str in Day 13: owned strings, string slices, and manipulation methods.

Store key-value pairs with HashMap in Day 14: insertion, lookup, iteration, and common patterns.

Write flexible code with generics in Day 15: generic functions, structs, and type parameters.

Define shared behavior with traits in Day 16: Rust's approach to interfaces.

Use dyn Trait for runtime polymorphism in Day 17: trait objects and heterogeneous collections.

Master lifetime annotations in Day 18: Rust's way of ensuring reference validity.

Master Rust iterators in Day 19: functional data processing with map, filter, fold, and collect.

Capture environment with closures in Day 20: anonymous functions with superpowers.

Organize code with modules in Day 21: visibility, pub keyword, and clean API design.

Explore smart pointers in Day 22: Box, Rc, and RefCell for advanced memory management.

Auto-implement traits with #[derive] in Day 23: Debug, Clone, Copy, PartialEq, and more.

Control compilation with attributes in Day 24: #[repr], #[allow], and memory layout control.

Manually serialize data to bytes in Day 25: the foundation for understanding Borsh serialization used throughout Solana development.

Build a Pubkey-like struct in Day 26: implement a 32-byte public key type similar to Solana's.

Implement type conversions in Day 27: From/Into traits used everywhere in Solana for seamless type transformations.

Create Solana-style error enums in Day 28: numeric error codes, error messages, and the patterns used in production Solana programs.

Implement account validation in Day 29: discriminators, type checking, and the security patterns that protect Solana programs.

Build a complete escrow state machine in Day 30: your capstone project combining all Rust concepts for a production-ready Solana pattern.