$12,390/mo * 9  = $111,516 (extra paycheck)

See What's Inside!

Beginner Module

🏃‍♂️

Get Up And Running FAST!

📹 Videos  💻 Code   📝 Quiz

You'll learn how to setup your development environment, configure your IDE and install the right plugins. Then you'll create your first Rust project!

You'll Learn:

✅ How to Setup Your Environment

✅ Setting Up Your IDE & Plugins

✅ Creating Rust Packages With Cargo

✅ Variables & Data Types in Rust

✅ Constant & Static Variables

✅ Functions and Control Flow

⚠️

Memory Safety In Rust

📹 Videos  💻 Code   📝 Quiz

Understanding memory management is critical when learning Rust! In this section you'll learn about memory management from the ground up!

You'll Learn:

✅ CS Basics (Stack, Heap, Pointers, etc.)

✅ Memory Management Strategies

✅ How Ownership & Borrowing Works

✅ What Slices Are

✅ String Types (str, &str, and String)

🔨

Building Your Own Data Types

📹 Videos  💻 Code   📝 Quiz

Rust doesn't have classes or objects! Instead, Rust uses Structs and Enums for custom data types. In this section you will learn about creating your own types!

You'll Learn:

✅ How To Create Structs & Enums

✅ How To Use Implementation Blocks

✅ Pattern Matching

✅ The Option and Result Enum

✅ Vectors

📦

How To Structure

Your Rust Projects

📹 Videos  💻 Code   📝 Quiz

 In this section I will explain how modules work in an easy to understand way. I'll also go over structuring larger projects and publishing your work to Crates.io.

You'll Learn:

✅ Project Structure Overview

✅ The Module System

✅ External Dependencies

✅ Conditional Compilation

✅ How to Structure Larger Projects

✅ Publishing Your Rust Projects

🧪

How Test & Document

Your Code

📹 Videos  💻 Code   📝 Quiz

Tests are a critical part of writing robust code. In this section you'll learn how to write and structure unit & integration tests in Rust. We'll also cover documentation.

You'll Learn:

✅ How To Write Unit Tests

✅ How to Write Integration Tests

✅ How To Structure Your Tests

✅ Documentation Comments

Intermediate Module

Polymorphism With

Generics & Traits

📹 Videos  💻 Code   📝 Quiz

Rust does not support classical inheritance! Instead, polymorphism is achieved through generics and traits. In this section you'll learn how both work!

You'll Learn:

✅ How To Define Generics

✅ The Trait System

✅ Traits Bounds & Trait Objects

✅ Supertraits

✅ Static Dispatch vs Dynamic Dispatch

✅ How To Derive Traits

✅ Traits in the Standard Library

⚡

Advanced Memory

Management

📹 Videos  💻 Code   📝 Quiz

Memory management doesn't end with ownership and borrowing! In this section you'll learn about lifetimes! We'll also cover various smart pointers in Rust.

You'll Learn:

✅ Concrete Lifetimes

✅ Generic Lifetimes Anotations

✅ Liftimes in Functions And Structs

✅ Smart Pointers & Why They Are Useful

✅ Implicit Deref Coericon

🛑

Understanding Error Handling

In Rust

📹 Videos  💻 Code   📝 Quiz

Understanding error handling is critical when designing your Rust applications. In this section we will cover how error handling works in Rust.

You'll Learn:

✅ How To Throw Unrecoverable Errors

✅ How To Return Recoverable Errors

✅ How To Propagate Errors

✅ The Result And Option Enums

✅ How To Handle Multiple Error Types

✅ How To Use anyhow & thiserror

Functional Features In Rust

📹 Videos  💻 Code   📝 Quiz

One of the most powerful things about Rust is its functional features. In this section we will cover closures, function pointers, iterators, and more!

You'll Learn:

✅ Closures & Function Pointers

✅ The Iterator Pattern In Rust

✅ Implementing The Iterator Pattern

✅ How To Iterate Over Collections

✅ Combinators And How To Use Them

Advanced Module

🚀

Concurrency & async/.await

📹 Videos  💻 Code   📝 Quiz

This is probably the MOST IMPOTANT section. Understanding concurrency is critical, especially when using rust for web related projects.

You'll Learn:

✅ Basic Concurrency Concepts

✅ Creating  Threads

✅ Message Passing With Channels

✅ Sharing State With Mutex

✅ The async/.await Model

✅ How Futures Work

✅ What Is An Async Runtime

✅ What Is Tokio And How Is It Used

✅ What Are Tokio Tasks

✅ Running CPU Blocking Code

✅ Streams

Rust's Powerful Macro System

📹 Videos  💻 Code   📝 Quiz

Macros are an extremely powerful way to extend the syntax of a language.  In this section you'll learn about the Macro system in Rust from the ground up!

You'll Learn:

✅ The Compilation Process

✅ What Macros Are

✅ How To Create Declarative Macros

✅ How To Create Precedural Macros

✅ Function-Like Procedural Macros

✅ Attribute-Like Procedural Macros

✅ Custom Derive Procedural Macros

Unsafe Rust & FFI

📹 Videos  💻 Code   📝 Quiz

One huge benefit of Rust is its ability to interface with other languages through a foreign function interface. In this section you'll learn about unsafe Rust and the FFI!

You'll Learn:

✅ Unsafe Rust And When To Use It

✅ How To Dereference Raw Pointers

✅ What Are Unsafe Functions

✅ What Are Unsafe Traits

✅ How To Mutate Static Variables

✅ How To Write Inline Assembly In Rust

✅ How To Call C Code From Rust

✅ How To Call Rust Code From C

🔬

Microservices

Masterclass

Rust is used for highly performant microservices. In this masterclass, you will learn how to build microservices in Rust & with the most popular adjacent technologies.

✅ Microservices Overview

✅ Creating Microservices with Rust

✅ Creating Microservices with gRPC & Protobuf

✅ Build & Deployment

🔥  Hands-on Project

🏗️

Rust-based CS

Masterclass

Many people struggle with the computer science behind Rust. This has hindered many to understand Rust at a deep level and become the Rust expert they aspire to become.

✅ Memory Regions (Stack, Heap, Static Memory)

✅ Manual Memory Management

✅ Garbage Collectors & Reference Counting

🔥 Hands-on Project

See what our Bootcamp students have to say...