Overview

Dive into the World of Rust Programming Whether you are new to programming or looking to expand your knowledge, this Rust programming course helps you build safe, practical code with one of today’s most respected systems programming languages. You’ll start by setting up Rust with rustup, rustc, and Cargo, then write your first programs using variables, data types, constants, macros, and control flow. As you progress, you’ll learn how Rust handles memory safety through ownership, borrowing, references, and slices. You’ll also work with functions, structs, enums, vectors, HashMaps, Result, Option, custom error types, packages, modules, and crates. Hands-on labs, Role Play activities, practice assignments, and tests help you apply each concept as you learn. You’ll also build command-line tools, parse arguments with clap, work with file I/O, complete a Docker client CLI project, and debug Rust code using compiler messages, logging macros, rust-gdb, and rust-lldb. By the end, you’ll have the foundation to write clearer Rust programs and troubleshoot them with more confidence. View the course introduction here: https://vimeo.com/1174658256

Syllabus

Getting Started with Rust

This module introduces the Rust programming language, its history, and why it is a top choice for performance and safety. You will set up your local development environment, install the necessary toolchains, and run your first "Hello, World!" program using the Rust compiler and Cargo.

Rust Basics

Build a strong foundation by learning the fundamental syntax and rules that govern Rust code. This module covers how to store data using variables, how the strict type system works, and how to control the flow of your program using loops and conditional logic.

Functions

Learn how to write modular, reusable code by mastering Rust functions. You will explore how to pass data into functions via parameters and how to return values safely, while understanding the impact of type annotations on function definitions.

Ownership

Master Rust’s most unique and powerful feature: the Ownership system. This module explains how Rust manages memory at compile time, teaching you the rules of moving, borrowing, and referencing data to prevent common bugs like data races and null pointers.

Collections & Error handling

Discover how to store multiple values using dynamic collections and how to write robust code that handles failure gracefully. You will learn to use Vectors and HashMaps while mastering the Result and Option types to eliminate runtime crashes.

Packages, Modules and Crates

Learn how to organize large-scale projects using Rust’s module system. This module covers how to split code across multiple files, manage internal visibility of functions, and pull in external libraries (crates) to extend your application’s functionality.

Building Command-Line Tools

Put your skills into practice by developing functional CLI (Command Line Interface) applications. You will learn how to accept user input, parse command-line arguments, and interact with the file system to create useful, high-performance tools.

Debugging in Rust

Master the art of troubleshooting Rust code. This module introduces the tools and techniques needed to find and fix bugs, from interpreting verbose compiler errors to using logging macros and specialized debugging tools to inspect your program's state.