Rust Programming: Beginner to Advanced

Course details

Designed to take you from beginner to advanced levels, this Rust programming course highlights the core features and capabilities of Rust, setting up your development environment, and mastering the language's robust memory management. Explore essential data structures like structs, enums, and vectors. Hone your error management with custom error types and best practices in logging. Build your skills in concurrency and asynchronous programming, leveraging Rust's powerful threads, message passing, and futures implementation. Discover advanced Rust features, including traits, smart pointers, and network programming, so you can build performance-intensive web applications using WebAssembly. Engage with practical labs and projects to apply your learning effectively. Ideal for programmers, developers, and newcomers, this course empowers you with the expertise to undertake complex Rust projects and efficiently manage system resources.

Concepts

Introduction

Introduction

Getting Started with Rust

Introduction to Rust
Overview of Rust's key features
Setting up the development environment
Introduction to Cargo

Rust Basics

Writing and running your first Rust program
Comments
Variables and mutability
Scalar and compound data types
Constants
Shadows
Macros
Control flow - if, else-if, else
Control flow - loop and labels
Control flow - for and while
Control flow - Pattern matching with `match`

Functions

What are functions
Parameters
Return values
Statements and expressions

Ownership

Introduction
Stack and heap
The string type and ownership
Scope and ownership
Variables and data interacting with move
Variables and data interacting with clone
Ownership and functions
References and borrowing
Immutable and mutable references
Rules of references
The slice type
Rules for slices

Collections and Error Handling

Structs
Methods
Enums
Vectors
Hashmaps
Unrecoverable errors
Recoverable errors
Creating custom error types
Logging libraries
Logging - Best practices

Packages, Modules, and Crates

Introduction to crates
Introduction to packages
Introduction to modules
Bringing paths into scope
Separating modules into files

Building Command-Line Tools

Introduction to CLI tools and importance in DevOps
Parsing command-line args with `clap`
Project - Manage Docker containers using Docker clients in Rust

Debugging in Rust

Debugging tools
Using println and logging
Rust-specific tools - rust-gdb, rust-lldb

Advanced Rust Concepts

Generic types
Traits - Shared behavior
Validating references with lifetimes

Dynamic Memory and Smart Pointers

Introduction to smart pointers
Box T - Single ownership and heap allocation
Rc T - Reference counting and shared ownership
RefCell T and interior mutability
Weak T - Breaking reference cycles
Implementing your own smart pointer

Closures and Iterators

Closures
Rust's iterator ecosystem and custom iterators

Fearless Concurrency

Threads
Message passing
Shared-state concurrency - Mutex, Arc T
Send and Sync traits

Asynchronous Programming

Concurrent programming
Async, await and futures
Building a concurrent URL pinger

Testing and Continuous Integration

Introduction to testing in Rust
Organizing tests in Rust
Mocking dependencies in Rust
Managing and running tests in Rust
Building and deploying with CI CD

Advanced Features

Advanced traits
Default generic type parameters
Fully qualified syntax
Advanced types
Advanced functions and closures

Network Programming and File Handling

Introduction to network programming in Rust
Building TCP clients and servers
Building UDP clients and servers
Introduction to file handling in Rust
Performing common filesystem operations
Project - Networked file transfer application (key concepts - TCP communication, file reading writing, error handling)

WebAssembly with Rust

Introduction to WebAssembly and why Rust
Setting up your Rust and WebAssembly development environment
Interacting with WebAssembly from JavaScript
Accessing WebAssembly memory from JavaScript
Building a mini project - Log analyzer

Conclusion

Final capstone project