English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 121 lectures (9h 49m) | 2.11 GB
Become a Rust engineer. Understand ownership, lifetimes, traits, generics, and much more through practical projects
Welcome to the most comprehensive and hands-on course for learning Rust from the ground up!
Rust is revolutionizing systems programming with its focus on memory safety, concurrency, and performance. But with its unique concepts and syntax, many find Rust challenging to learn. That’s where this course comes in – providing you with a clear, structured path to Rust mastery.
What sets this course apart? We focus on building a rock-solid foundation in Rust’s core concepts. No fluff, no skipping steps – just pure, essential Rust knowledge that will set you up for success in any Rust project.
Rust’s most challenging concepts are covered:
- Rust’s ownership model? Explained in great detail!
- Lifetimes and borrowing? Its here!
- Traits and generics? You’ll use them to write flexible code
This course is designed for developers who want to truly understand Rust, not just copy-paste code. Whether you’re coming from Javascript, Python, or any other language, you’ll find a welcoming introduction to Rust’s unique paradigms.
Rust has been voted the “most loved programming language” in the Stack Overflow Developer Survey for seven consecutive years. It’s not just hype – major companies like Microsoft, Google, and Amazon are increasingly adopting Rust for critical systems. By mastering Rust, you’re not just learning a language; you’re future-proofing your career.
Here’s a (partial) list of what you’ll learn:
- Dive deep into Rust’s type system and how it ensures memory safety
- Master pattern matching and destructuring for elegant, expressive code
- Harness the power of Rust’s error handling with Result and Option types
- Explore Rust’s module system to organize and scale your projects
- Implement common data structures and algorithms the Rust way
- Use cargo to manage dependencies and build your projects with ease
- A solid grasp of Rust’s syntax and core concepts
- The ability to write safe, efficient, and idiomatic Rust code
- Confidence to tackle real-world Rust projects and contribute to the ecosystem
- A deep and fundamental understanding of error handling
- The skills to optimize code for performance and memory usage
- And much more!
How This Course Works:
This isn’t just another “follow along” coding course. We’ve structured the learning experience to ensure you truly internalize Rust’s concepts:
- Concept Introduction: Clear, concise explanations of each Rust feature
- Live Coding: Watch as we implement concepts in real-time, explaining our thought process
- Challenges: Test your understanding with carefully crafted coding exercises
- Project Work: Apply your skills to build progressively complex projects
- Best Practices: Learn idiomatic Rust and industry-standard coding patterns
This is the course I wish I had when I was learning Rust. A course that focuses on the hardest parts, gives clear explanations, and discusses the pros and cons of different design options. Sign up today and join me in mastering Rust!
Table of Contents
Foundations of Rust Setup and First Steps
1 Introduction
2 Rust Installation
3 Local Rust Install
4 Creating and Running Rust Projects
5 Disabling Inlay Type Hints
6 Course Resources
Core Concepts The Building Blocks of Rust
7 Representing Data with Structs
8 Adding Functionality to Structs
9 Arrays vs Vectors
10 Mutable vs Immutable Bindings
11 Implementations and Methods
12 Implicit Returns
13 Installing External Crates
14 Using Code from Crates
15 Shuffling a Slice
16 Splitting a Vector
17 Project Review
18 A Taste of Rust
Ownership and Borrowing Rust’s Unique Memory System
19 Project Overview
20 Defining Structs
21 Adding Inherent Implementations
22 A Mysterious Error
23 Unexpected Value Updates
24 The Goal of Ownership and Borrowing
25 The Basics of Ownership
26 Owning and Moving Values
27 Visualizing Ownership and Moves
28 More on Owning and Moving
29 Exercise Overview
30 Exercise Solution
31 Another Quick Exercise
32 A Quick Exercise Solution
33 Writing Useful Code with Ownership
34 Working Around Ownership
35 Introducing the Borrow System
36 Immutable References
37 Working with References
38 Exercise On References
39 References Exercise Solution
40 Mutable References
41 Handling Mutable References
42 Exercise on Mutable Refs
43 Solution on Mutable Refs
44 Copy-able Values
45 Understanding Copies vs Moves
Lifetimes Explored Understanding Memory Management
46 Basics of Lifetimes
47 Lifetimes
48 Deciding on Argument Types
49 Back to the Bank Impl
50 Implementing Deposits and Withdrawals
51 Accounts and Bank Implementation
52 Project Wrapup
Enums Unleashed Pattern Matching and Options
53 Project Overview
54 Defining Enums
55 Declaring Enum Values
56 Adding Implementations to Enums
57 Pattern Matching with Enums
58 When to Use Structs vs Enums
59 Adding Catalog Items
60 Unlabeled Fields
61 Enums
62 The Option Enum
63 Option From Another Perspective
64 Replacing Our Custom Enum with Option
65 Other Ways of Handling Options
66 The Option Enum
67 Excercise Overview
68 Exercise Solution
Project Architecture Mastering Modules in Rust
69 Modules Overview
70 Rules of Modules
71 Refactoring with Multiple Modules
Handling the Unexpected Errors and Results
72 Project Overview
73 Reading a File
74 The Result Enum
75 The Result Enum in Action
76 Types of Errors
77 Matching on Results
78 Empty OK Variants
79 Exercise Around the Result Enum
80 Exercise Solution
81 Using a Result When Reading Files
82 Tricky Strings
83 The Stack and Heap
84 Strings, String Refs, and String Slices
85 When to Use Which String
86 Strings
87 Finding Error Logs
88 Understanding the Issue
89 Fixing Errors Around String Slices
90 Writing Data to a File
91 Alternatives to Nested Matches
92 The Try Operator
93 When to Use Each Technique
Iterator Deep Dive Efficient Data Processing
94 Project Overview
95 Basics of Iterators
96 Using For Loops with Iterators
97 Iterator Consumers
98 Iterator Adaptors
99 Vector Slices
100 Reminder on Ownership and Borrowing
101 Iterators with Mutable Refs
102 Mutable Vector Slices
103 Collecting Elements from an Iterator
104 How Collect Works
105 Moving Ownership With Into_Iter
106 Inner Maps
107 Reminder on Lifetimes
108 Iterators Wrapup
109 Collect Excercise
110 Exercise Solution
111 The Filter Method
112 Filter Solution
Advanced Lifetimes Mastering Rust’s Memory Model
113 Lifetime Annotations
114 A Missing Annotation
115 A Review of Borrowing Rules
116 What Lifetime Annotation Are All About
117 Common Questions Around Lifetimes
118 Lifetime Elision
119 Common Lifetimes
Generics and Traits Writing Flexible, Reusable Code
120 Project Setup
121 Issues with Number Types
122 The Basics of Generics
123 Trait Bounds
124 Multiple Generic Types
125 Super Solve Flexibility
126 App Overview
127 Building the Basket
128 Generic Structs
129 More on Generic Structs
130 Implementing a trait
131 Generic Trait Bounds
Bonus!
132 Bonus!
Resolve the captcha to access the links!