Who is this bootcamp for? Experienced developers looking to transition to Rust.Learn the language of the future. Your time is valuable (literally, $148,688/year). Learn Rust FAST with the bootcamp instead of digging through low quality resources. Students/Graduates looking for jobs. Learning Rust is a great addition to your resume. Stand out among other candidates. Become a competent programmer. Gain access to a community that can help you land your first job. И… You! Rust enthusiast. Rust is an innovative language that will expand your thinking! Cutting-edge technologies are created in Rust.

You’ll learn how to customize your development environment, configure your development environment (IDE), and install the necessary plugins. Then you will create your first project in Rust!

You will learn:

How to customize your development environment
Configuring your IDE and plugins
Creating Rust packages with Cargo
Variables and data types in Rust
Constant and static variables
Functions and runtime management

Understanding memory management is critical when learning Rust! In this section, you’ll learn about memory management from the very beginning!

You will learn:

A Rust-based computer science masterclass
How the ownership mechanism works
How the borrowing mechanism works
What slices are
String types (str, &str and String)

Rust does not use classes or objects! Instead, Rust uses structures (Structs) and enums (Enums) to create custom data types. In this section, you’ll learn how to create your own custom types!

You will learn:

How to create structures and enums
How to use implementation blocks
Pattern matching
Option and Result enumerations
Vectors

How to Structure Your Rust Projects

In this section, I’ll explain how modules work in an understandable way. I’ll also cover structuring larger projects and publishing your work on Crates.io.

You will learn:

An overview of project structure
The module system
External dependencies
Conditional compilation
How to structure large projects
Publishing your projects in Rust

How to Test and Document Your Code

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

You will learn:

How to write unit tests
How to write integration tests
How to structure your tests
Comments on documentation

Polymorphism with Generics and Traits

Rust does not support classical inheritance! Instead, polymorphism is achieved through generics (generalizations) and traits (traits). In this section, you will learn how both of these mechanisms work.

You will learn:

How to define generics
The Trait System
Trait boundaries and trait objects
Supertraits
Static dispatching vs. dynamic dispatching
How to display traits
Traits in the standard library

Advanced Memory Management

Memory management doesn’t end with possession and borrowing mechanisms! In this section, you’ll learn about lifetimes! We’ll also take a look at various smart pointers in Rust.

You will learn about:

Concrete Lifetimes (Concrete Lifetimes)
Generic Lifetimes Annotations (Generic Lifetimes Annotations)
Lifetimes in functions and structures
Smart pointers and why they are useful
Implicit Deref Coercion (Implicit Deref Coercion)

Understanding Error Handling in Rust

Understanding error handling is critical when designing your Rust applications. In this section, we’ll take a look at how error handling works in Rust.

You will learn:

How to generate uncorrectable errors
How to return correctable errors
How to propagate errors
Result and Option enumerations
How to handle multiple error types
How to use anyhow and thiserror

Functional Features in Rust

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

You will learn:

Closures and function pointers
Iterator pattern in Rust
Implementing the iterator pattern
How to iterate over collections
Combinators and how to use them

Parallelism and async/.await

This is probably the MOST IMPORTANT section. Understanding parallelism is critical, especially when using Rust for web projects.

You will learn:

The basic concepts of parallelism
Creating threads
Messaging using channels
Sharing state using Mutex
The async/.await model
How Futures work (future results)
What is asynchronous execution
What is Tokio and how it is used
What are Tokio tasks
Executing CPU-blocking code
Data Streams

The Powerful Macro System in Rust

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 very beginning!

The compilation process
What are macros
How to create declarative macros
How to create procedural macros
Function-like procedural macros
Attribute-like procedural macros
Custom Derive-based procedural macros (Custom Derive)

Unsafe Rust and FFI (Foreign Function Interface)

One of the great advantages of Rust is its ability to interact with other languages through the Foreign Function Interface. In this section, you will learn about insecure Rust and FFI!

You will learn about:

Unsafe Rust and when to use it
How to dereference raw pointers
What are unsafe functions
What unsafe traits are
How to modify static variables
How to write built-in assembly commands in Rust
How to call C code from Rust
How to call Rust code from C