Rust Fundamentals 

Meet your Course Instructor: Alfredo Deza

About This Course

Overview of Installing Rust

Demo: Installing Rust

Demo: Visual Studio Code

Demo: Enabling the Rust Analyzer

Demo: Using the Rust Analyzer

Demo: Synchronizing your settings

Summary of Installing Rust and Visual Studio Code

Overview of AI Pair Programming with Github Copilot

Demo: Signing up for GitHub Copilot

Demo: Installing and enabling Copilot on Visual Studio Code

Demo: Programming with suggestions

Demo: Using prompts with Copilot

Demo: Copilot X and chat-based learning

Summary of AI Pair Programming

Overview of Codespaces

Demo: Fundamentals of Codespaces

Demo: Understanding usage and quotas

Demo: Basics of dev containers

Demo: Customizing the editor

Demo: Customizing the environment

Summary of Codespaces

Course Structure and Discussion Etiquette

Getting Started: Visual Studio Code, Github Codespaces, and Rust

Practice External Lab: Install Rust with Visual Studio Code

Optional: Quickstart for GitHub Copilot

Optional: Setting up your Student Account with GitHub

Practice External Lab: Enabling GitHub Copilot

GitHub Codespaces for Students

Optimizing Codespaces

External Lab: Using GitHub Codespaces with Copilot

Your Development Environment

Meet and Greet (optional)

Introduction to Rust

Demo: Create a new Rust project

Demo: Overview of project files

Demo: Basic components of Rust code

Demo: Variable assignment and immutability

Demo: Basics of control flow

Demo: Shadowing variables

Summary of Introduction to Rust

Introduction to Loops and Control Flow

Demo: Introduction to Loops in Rust

Demo: Conditional Statements in Rust

Demo: The while Loop in Rust

Demo: The for Loop in Rust

Demo: The break and continue statements in Rust

Demo: The match Control Flow Statement in Rust

Summary of Loops and Control Flow

Introduction to Function Basics

Demo: Simple unit functions

Demo: Return values

Demo: Using arguments

Demo: The borrowing concept

Demo: Using panic to stop a program

Demo: Basic error handling with match

Summary of Function Basics

Optional: What is Rust? Microsoft Learn Module

Optional: Setup the Rust Development Environment Microsoft Learn Module

Optional: Rust Loops Expressions Microsoft Learn Module

Optional: Rust if/else Expressions Microsoft Learn Module

Optional: Create your first Rust Program Microsoft Learn Module

Optional: Understanding Rust memory management Microsoft Learn Module

External Lab: Create a File Reader Application

Basics of Rust programming

Practice Internal Lab: Create a new Rust project

Practice Internal Lab: Use the Basics of Control flow

Practice Internal Lab: Conditional statements

Practice Internal Lab: Match control flow statements

Practice Internal Lab: Using arguments in functions

Practice Internal Lab: Using the borrowing concept

Practice Internal Lab: Basic error handling with match

Introduction to Structured Data

Demo: Defining structs

Demo: Creating struct instances

Demo: Associated functions and constructors

Demo: Other struct uses

Summary of Structured Data

Introduction to Strings and Vectors

Demo: Understanding String and str

Demo: Getting Started with Rust String Manipulation

Demo: Basics of Vectors

Demo: Retrieving values from Vectors

Demo: Adding elements to Vectors

Summary of Strings and Vectors

Introduction to Enums and Variants

Demo: Defining an Enum

Demo: Using Enum as a Type

Demo: The Option Enum

Demo: Applied Enums

Demo: Using Vectors with Enums

Demo: Exhaustive matches

Summary of Enums and Variants

Optional: Using Loops to Iterate Over Data Microsoft Learn Module

Optional: Handling Errors in Rust Microsoft Learn Module

External Lab: Create a File Size formatter

Organizing Data in Rust: Structs, Enums, and Types

Practice Internal Lab: Defining structs

Practice Internal Labs: Associated functions and constructors

Practice Internal Lab: Getting started with string manipulation

Practice Internal Lab: Retrieve values from Vectors

Practice Internal Lab: Adding elements to Vectors

Practice Internal Lab: Using Enum as a type

Practice Internal Lab: Applied Enums

Practice Internal Lab: Using Vectors with Enums

Introduction to Libraries and Cargo

Demo: Creating the library with Cargo

Demo: Adding code to lib

Demo: Documenting your code

Demo: Using a debugger

Demo: Using a Makefile

Summary of Libraries and Cargo

Introduction to Modules

Demo: Using Cargo for dependencies

Demo: Extending with modules

Demo: Verify code with doctest

Demo: Defining Public and Private modules

Demo: Private and public fields in Structs

Summary of Modules

Introduction to Testing

Demo: Organizing test files

Demo: Introduction to testing in Rust

Demo: Writing tests for your code

Demo: Testing private code

Demo: Using test failure messages

Summary of Testing

Course Summary

Optional: Create Your First Rust Program Microsoft Learn Module

Optional: Debugging in Visual Studio Code

Optional: Managing growing projects in Rust

Optional: Explore Modules, Packages, and Third-party Crates Microsoft Learn Module

Optional: Write Automated Tests Microsoft Learn Module

Optional: Test Organization

External Lab: Create a Rust library

Rust Components and Patterns

Practice Internal Lab: Create a library with Cargo

Practice Internal Lab: Document your code

Practice Internal Lab: Use a Makefile

Practice Internal Lab: Verify code with Doctest

Practice Internal Lab: Define Public and Private modules

Practice Internal Lab: Use Private and public fields in Structs

Practice Internal Lab: Write tests for your code

Practice Internal Lab: Test private code