English | MP4 | AVC 1920×1080 | AAC 44KHz 2ch | 105 Lessons (9h 50m) | 2.90 GB
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. 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 master class
- 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 types!
You will learn:
- How to create structures and enumerations
- How to use implementation blocks
- Pattern matching
- Option and Result enumerations
- Vectors
How to Structure Your Projects in Rust
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
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 type-based procedural macros (Custom Derive)
Insecure 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 unsafe functions are
- 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
Table of Contents
1 Don’t skip this video!
2 How to use this Bootcamp effectively
3 Hello World
4 Variables
5 Data Types
6 Constants & Statics
7 Functions
8 Control Flow
9 Comments
10 Stack, Heap, and Static Memory
11 Memory Management Strategies
12 C++ RAII vs Rust OBRM – Part 1
13 C++ RAII vs Rust OBRM – Part 2
14 Ownership
15 Ownership Continued
16 Borrowing
17 Slices
18 BONUS Masterclass Strings in Rust. PART 1
19 BONUS Masterclass Strings in Rust. PART 2
20 Structs
21 Implementation Blocks
22 Tuple Structs
23 Enums
24 Matching
25 Option
26 Result
27 Vectors
28 Project Structure Overview
29 Modules
30 Modules Continued
31 External Dependencies
32 Publishing Your Package
33 Cargo Features
34 Cargo Workspaces
35 Unit Tests
36 Integration Tests
37 Documentation
38 BONUS Benchmark Testing
39 Generics
40 Traits
41 Trait Bounds
42 Supertraits
43 Trait Objects
44 Deriving Traits
45 The Orphan Rule
46 Concrete Lifetimes
47 Generic Lifetimes
48 Structs & Lifetime Elision
49 Box Smart Pointer
50 Rc Smart Pointer
51 RefCell Smart Pointer
52 Deref Coercion
53 Unrecoverable Errors
54 Recoverable Errors
55 Propagating Errors
56 Result and Option
57 Multiple Error Types
58 Overview of Error Handling
59 Basic Error Handling
60 Custom Errors 1
61 Custom Errors 2
62 Custom Errors 3
63 thiserror & anyhow
64 BONUS error-stack
65 Closures
66 Closures Continued
67 Function Pointers
68 Iterator Pattern
69 Iterator Pattern Continued
70 Iterating Over Collections
71 Combinators
72 Intro to Concurrency
73 Creating Threads
74 Moving Values Into Threads
75 Message Passing Between Threads
76 Sharing State Between Threads
77 Sharing State Between Threads Continued
78 Send & Sync Traits
79 async.await Basics
80 Tokio Tasks
81 CPU Intensive Code
82 Streams
83 Intro to Macros
84 Declarative Macros
85 Declarative Macros Continued
86 Procedural Macros
87 Procedural Macros – Function Like
88 Procedural Macros – Custom Derive
89 Procedural Macros – Attribute Like
90 Procedural Macros – Attribute Continued
91 Unsafe Basics
92 Dereferencing a Raw Pointer
93 Calling an Unsafe Function
94 Implementing an Unsafe Trait
95 Mutable Static Variables
96 Inline Assembly
97 FFI C from Rust
98 FFI Rust from C
99 BONUS FFI Rust from Python
100 What are microservices
101 Why Rust is great for microservices
102 Communication with gRPC
103 Containerization with Docker
104 CICD with GitHub Actions
105 Cloud Providers
Resolve the captcha to access the links!