Mastering Rust

Introduction to Rust

• Overview of Rust and its core principles
• Rust's philosophy, safety, and performance goals
• History and motivation behind the language
• Rust's open-source community and ecosystem
• Using the Rust Playground for experimentation

Environment Setup and Tools

• Installing Rust on macOS, Windows, and Linux
• Using Homebrew and platform-specific installers
• Setting up Visual Studio Code with extensions
• Using Rust Rover and other IDEs
• Debugging Rust applications in VSCode
• Integrating GitHub Copilot into workflows

Getting Started with Rust Projects

• Creating and managing a new Rust project
• Understanding the main function structure
• Printing output to the console
• Writing and managing comments

Cargo and Project Management

• Understanding the purpose of Cargo
• Running, building, and releasing projects
• Installing and managing third-party crates with Cargo

Rust Fundamentals

• Working with scalar types and basic data
• Declaring constants and variables
• Using immutable and mutable variables
• Writing control flow with if, loop, and while
• Defining functions and passing parameters
• Understanding return types and closures

Modules and Code Organization

• Importing standard and third-party modules
• Defining and importing custom modules
• Using built-in macros for formatting and logic
• Common macros like println, format, assert, and vec

Memory Management and Ownership

• Problems with manual and garbage-collected memory models
• Understanding Rust's ownership system
• Using references and understanding borrowing
• Working with lifetimes in functions and structs

Strings and Collections

• Understanding string slices and string objects
• Converting between string types
• Parsing numbers from strings and trimming
• Interpolating strings for output

Tuples and Structs

• Defining and using tuples with heterogeneous data
• Accessing and destructuring tuple values
• Creating and updating struct instances
• Field shorthand, tuple structs, and unit-like structs
• Managing ownership within structs
• Implementing functions and methods on structs
• Using constructor patterns

Enums and Pattern Matching

• Defining enums and working with variants
• Adding methods to enums
• Using enums in pattern matching
• Understanding Result and Option enums
• Comparing enums and structs in data design

Working with Vectors and Collections

• Creating and mutating vectors
• Accessing and slicing vector elements
• Calculating vector length and capacity
• Streaming over elements with iterators
• Using arrays, slices, hash maps, and hash sets

Traits and Generics

• Understanding traits as interfaces
• Defining and implementing traits
• Using default trait methods
• Passing traits as parameters and return types
• Applying trait bounds in generic code
• Working with multiple generics and where clauses

Advanced Pattern Matching

• Using match, if let, and while let expressions
• Destructuring complex structs and tuples
• Applying pattern matching to functions and ownership
• Understanding refutable and irrefutable patterns

Concurrency and Asynchronous Programming

• Writing concurrent code with threads
• Using Mutex, RwLock, and Arc for synchronization
• Message passing using channels
• Understanding Sync and Send traits
• Writing asynchronous code with async and await
• Working with futures and non-blocking patterns

Unsafe Rust and System Access

• Understanding the purpose of unsafe Rust
• Working with raw pointers and unsafe functions
• Using unsafe blocks responsibly
• Creating safe abstractions over unsafe logic
• Defining and using unsafe traits

Macros and Metaprogramming

• Defining macros with macro_rules
• Using pattern matching in macros
• Expanding and invoking custom macros for automation

Testing and Documentation

• Writing unit tests with standard test attributes
• Organizing and running tests in modules
• Using assert macros for validation
• Creating documentation with Rustdoc
• Adding documentation comments
• Generating and linking external documentation

Prerequisite

• Software development experience (this is not a general introduction to programming course).
• Basic understanding of programming concepts such as variables, expressions, functions, and control flow.

Training Materials

All students receive comprehensive courseware covering all topics in the course. We distribute courseware via GitHub in the form of documentation and extensive code samples. Students practice the topics covered through challenging hands-on lab exercises.

Students will need a free, personal GitHub account to access the courseware. Student will need permission to install Rust and Visual Studio Code on their computers. Also, students will need permission to install Rust Crates and Visual Studio Extensions. If students cannot configure a local environment, we can provide a cloud-based environment.