Rust Programming Language

Location: On-Site or Online
Pricing: $1,250 per seat (6-seat minimum)
Length: 4 Days

Course Summary

Rust is a practical, hands-on course designed to teach students how to build safe, fast, and reliable software using the Rust programming language.

Students learn Rust from a systems and production mindset—focusing on memory safety without garbage collection, ownership and borrowing, explicit error handling, and fearless concurrency. The course emphasizes how Rust enforces correctness at compile time and how those guarantees translate into robust real-world applications.

By the end of the course, students are comfortable reading, writing, and debugging Rust programs and understand how Rust is used in systems programming, backend services, CLI tools, networking software, and performance-critical applications.

Course Outline

Day 1 – Rust Fundamentals and Tooling

• 💬 Lecture: Why Rust exists and what problems it solves

• 💬 Lecture: Rust vs C/C++ vs Go (design tradeoffs)

• 💬 Lecture: Rust toolchain (rustc, cargo, rustup)

• 💬 Lecture: Project structure and Cargo.toml

• ⚙️ Lab: Installing Rust and validating the environment

• ⚙️ Lab: Creating a new Rust project with Cargo

• ⚙️ Lab: Building and running a Rust program

• ⚙️ Lab: Exploring compiler errors and warnings

• 💬 Lecture: Variables, mutability, and shadowing

• 💬 Lecture: Basic types and control flow

• ⚙️ Lab: Writing simple Rust programs

• ⚙️ Lab: Using if, loop, while, and match

Day 2 – Ownership, Borrowing, and Data Modeling

• 💬 Lecture: Ownership model and move semantics

• 💬 Lecture: Borrowing rules and references

• ⚙️ Lab: Identifying moves vs borrows

• ⚙️ Lab: Fixing borrow checker errors

• 💬 Lecture: Lifetimes (conceptual model)

• ⚙️ Lab: Adding explicit lifetimes to functions

• ⚙️ Lab: Refactoring code to satisfy lifetime rules

• 💬 Lecture: Structs, enums, and pattern matching

• ⚙️ Lab: Defining structs and enums

• ⚙️ Lab: Modeling real-world data with enums

• ⚙️ Lab: Using match exhaustively

• 💬 Lecture: Option and Result types

• ⚙️ Lab: Handling optional values safely

• ⚙️ Lab: Propagating errors with ?

Day 3 – Traits, Generics, and Concurrency

• 💬 Lecture: Traits and shared behavior

• 💬 Lecture: Generics and type parameters

• ⚙️ Lab: Implementing traits for custom types

• ⚙️ Lab: Writing generic functions and structs

• 💬 Lecture: Error handling patterns and custom errors

• ⚙️ Lab: Creating custom error types

• ⚙️ Lab: Converting and handling multiple error types

• 💬 Lecture: Concurrency in Rust

• 💬 Lecture: Threads, ownership, and safety

• ⚙️ Lab: Spawning threads safely

• ⚙️ Lab: Sharing data with Arc and Mutex

• 💬 Lecture: Message passing and channels

• ⚙️ Lab: Communicating between threads with channels

• ⚙️ Lab: Avoiding data races at compile time

Day 4 – Real-World Rust Applications and Best Practices

• 💬 Lecture: Building command-line tools in Rust

• 💬 Lecture: Working with files, JSON, and external crates

• ⚙️ Lab: Parsing command-line arguments

• ⚙️ Lab: Reading and writing files

• ⚙️ Lab: Serializing and deserializing JSON

• 💬 Lecture: Writing networked and service-oriented Rust code

• 💬 Lecture: Async Rust fundamentals (async / await)

• ⚙️ Lab: Writing an asynchronous Rust program

• ⚙️ Lab: Making HTTP requests asynchronously

• 💬 Lecture: Testing, documentation, and linting

• 💬 Lecture: Rust best practices and common pitfalls

• ⚙️ Lab: Writing unit tests in Rust

• ⚙️ Lab: Using cargo fmt and cargo clippy

• ⚙️ Lab: Building and running a complete Rust application

• ⚙️ Lab: Debugging and performance profiling basics

Outcomes

Students who complete Rust will be able to:

• Write safe, idiomatic Rust programs

• Understand and apply ownership, borrowing, and lifetimes

• Handle errors explicitly and correctly

• Build concurrent programs without data races

• Use Cargo and the Rust ecosystem effectively

• Apply Rust best practices in real production environments