Professional Training

Objectives

Participants will learn how to:
Master Rust Syntax and Semantics: Get comfortable writing and understanding Rust code, including how to use control flow, functions, and module imports.
Implement Memory Management: Learn to manage memory effectively in Rust by mastering concepts like ownership, borrowing, and lifetimes to ensure your code is both safe and efficient.
Leverage Cargo and Crates: Become adept at using Cargo to manage Rust projects and dependencies, and explore how to integrate popular crates like Serde, Tokio, and SQLx to add powerful features to your applications.
Utilize Rust's Concurrency Model: Discover how to write efficient and concurrent programs using Rust's concurrency tools, such as threads, Mutex, RwLock, and async/await.
Employ Pattern Matching and Generics: Understand and apply pattern matching with enums and functions, and use generics to create flexible and reusable code.
Create and Test Rust Applications: Develop complete Rust applications, including writing tests with Rust's testing framework and generating clear, comprehensive documentation using Rustdoc.

Pre-requisites

Proficiency in C++ Programming: A strong understanding of C++ syntax, functions, and modules
Basic Knowledge of Programming Concepts: Familiarity with variables, expressions, control flow (loops and conditionals), and basic data structures.
Experience with Version Control Systems: Basic experience using Git for version control, including committing, branching, and merging code.
Understanding of Software Development Practices: Familiarity with project management tools and practices - virtual environments, dependency management, and code testing.

Who should attend

This course is designed for C++ developers looking to expand their programming skills with Rust. It is ideal for software engineers, system programmers, and developers interested in performance-critical and concurrent applications. Whether in a new or existing role, this course provides the knowledge and skills to excel in Rust programming.

Getting Started with Rust

What is Rust?
Philosophy and Goals
History and Motivation
Rust Community and Ecosystem
Exploring the Rust Playground

Rust Editors

Setting up VSCode with Rust Extensions
Using Rust Rover IDE
Debugging Rust Code in VSCode
Integrating GitHub Copilot for Rust

Hello World

Creating a New Rust Project
Writing the Main Function
Printing to the Console
Adding Comments to Code

Cargo

What is Cargo?
Run Command
Build Command
Build Release Command
Install Third-Party Crates

Scalar Types and Data

Comparing Rust Types with Python Types
Defining Constants in Rust
Using Immutable Variables
Utilizing Mutable Variables

Code Logic

Writing If Statements
Using Loops with Break
Implementing While Loops

Functions

Defining and Calling Functions
Specifying Parameter and Return Types
Creating and Using Closure Functions

Modules

Importing Modules from the Standard Library
Importing Modules from Third-Party Crates
Defining Custom Modules
Importing and Using Custom Modules

Built-In Macros

print! and println!
format!
assert!, assert_eq!, and assert_ne!
vec!
include_str! and include_bytes!

Memory Management

Problems with Manual Management
Problems with Garbage Collection
Ownership & Borrowing
References
Lifetimes

Strings and String Slices

What is a String and a String Slice?
String Slices
String Objects
Convert Between Slices and Strings
Print Strings with Interpolation

Tuples

Understanding What a Tuple Is
Using Heterogeneous Elements
Accessing and Destructuring Tuple Elements
Immutability of Tuples

Enums

Defining and Using Enums
Exploring Enum Variants and Methods
Pattern Matching with Enums
Working with Result and Option Enums

Structs

What is a Struct?
Create Instance
Field Init Shorthand
Struct Methods
Constructor Pattern

Vectors

Creating and Managing Vectors
Adding and Removing Elements
Accessing and Iterating Over Elements
Slicing, Checking Length, and Capacity

Collections and Iterators

What is a Vector?
Create a Vector
Add and Remove Elements
Access Elements
Iterate over Elements

Traits

Defining and Implementing Traits
Using Default Trait Implementations
Passing Traits as Parameters and Return Types

Generics

Defining and Implementing Generics in Rust
Using Generic Bounds and Multiple Types
Writing Where Clauses for Generics

Pattern Matching

What is Pattern Matching?
Match Statement
If Let Statement
While Let Statement
Pattern Matching with Enums

Concurrent Programming

Introduction to Concurrent Programming Concepts
Using Multiple Threads in Rust
Working with Mutex, RwLock, and Arc
Message Passing with Channels
Futures and Async/Await for Concurrency

Unsafe Rust

Understanding the Need for Unsafe Rust
Working with Raw Pointers and Dereferencing
Calling Unsafe Functions and Creating Safe Abstractions
Using Unsafe Traits and Blocks

Macros and Metaprogramming

Defining and Using Macros with macro_rules!
Pattern Matching in Macros
Defining and Expanding Custom Macros
Tests
Writing and Organizing Test Functions
Using Test Attributes and Coverage Tools
Assertions with assert!, assert_eq!, and assert_ne!

Tests

What is a Test?
Test Functions
Test Organization
Test Attributes
Test Coverage

Memory-Safe Programming

How Memory is Managed on a Computer
How the Operating System Views Memory
How Memory is Allocated in a Process
Pitfalls with manual memory management
Rust's Approach to Safe Memory Management

Memory Management

Variables and their Data
Variable Addresses and Data Addresses
Mutability of Variables and their Data
Variable and Data Ownership
Rust's Approach to Variables and their Data

Rust Memory Model

Ownership and Borrowing
References and Mutability
Stack Allocation vs Heap Allocation
Smart Pointers
Thread Safety through Atomics and Locks

Smart Pointers

What are Smart Pointers?
When to use Smart Pointers?
Unknown Size at Compile Time
Self-Referential Structures
Interior Mutability

Smart Pointer Types

Box
Rc, Weak, and Arc
Cell and RefCell
RwLock and Mutex

C++ and Rust Interoperability

Challenges and Concerns
Calling Rust from C++
Calling C++ from Rus

Documentation with Rustdoc

Generating Documentation with Rustdoc
Adding Triple-Slash Comments and #[doc] Attributes
Linking and Cross-Referencing Documentation