CF

Rust Programming: The Complete Developer's Guide

25h 37m 12s
English
Paid
Released
Added to CourseFlix

Rust Programming: The Complete Developer's Guide is a 233-lesson 25 hours 37 minutes self-paced course by Zero To Mastery. Learn the Rust programming language from scratch!

Course facts

Lessons
233
Duration
25 hours 37 minutes
Language
English
Released
August 2021
Added to CourseFlix
September 2025
Instructor
Zero To Mastery
Price
Premium

Learn the Rust programming language from scratch! Learn how to code & build real-world applications using Rust so that you can get hired and be recognized as a top programmer. No previous experience needed.

  • Fundamentals of computer programming concepts such as conditional logic, loops, and data transformations
  • Foundational computer science topics such as computer memory, program logic, and simple data structures
  • Working with data: enums, structs, tuples, expressions, optional data and more
  • Solid understanding of all core concepts of the Rust programming language such as: memory, mutability, traits, slices, and generics
  • Reading and writing application code in the Rust programming language
  • Utilization of the Rust ecosystem to develop applications more efficiently
  • How to translate real-life requirements into working applications to solve real-world problems (and that you can add to your portfolio)
  • How to make your programs reliable through the use of automated testing and by leveraging features of the Rust language

Additional

https://github.com/jayson-lennon/ztm-rust

Who teaches Rust Programming: The Complete Developer's Guide? Zero To Mastery

Zero To Mastery thumbnail

Zero To Mastery (ZTM) is a Toronto-based online coding academy founded by Andrei Neagoie, originally a senior developer at large Canadian tech firms before turning to teaching full-time. The academy's signature is the cohort-based bootcamp track combined with a deep self-paced course library, all aimed at career-changers and self-taught developers preparing to land software-engineering roles at top companies.

The instructor roster has grown well beyond Andrei to include other senior practitioners: Daniel Bourke (machine learning), Aleksa Tešić (DevOps), Jacinto Wong, and others. Courses cover the full software-engineering career path: web development with React and Next.js, Python, machine learning and deep learning, DevOps and cloud, system design, mobile, and the algorithm / data-structure interview prep that gates engineering jobs.

The CourseFlix listing under this source carries over 120 ZTM courses spanning that full range. Material is paid; ZTM itself runs on a monthly / annual membership model. The teaching style favours long-form, project-based courses where students build complete portfolio-quality applications rather than disconnected feature tutorials.

What lessons are included in Rust Programming: The Complete Developer's Guide?

This is a demo lesson (10:00 remaining)

Watch the first 10 minutes free. One payment unlocks all 233 lessons here and every other premium course. No auto-renew.

View Pricing
0:00
/
#1: Rust Programming: The Complete Developer's Guide
All Course Lessons (233)
#Lesson TitleDurationAccess
1
Rust Programming: The Complete Developer's Guide Demo
05:02
2
Intro
02:27
3
Data Types
05:02
4
Variables
06:36
5
Functions
08:13
6
println!
03:05
7
Control Flow with If
08:39
8
Repetition
06:31
9
Setup Rust: Toolchain
04:50
10
Setup Rust: rust-analyzer
04:19
11
Setup Rust: clippy
02:32
12
Setup Rust: error-lens
01:28
13
Comments
03:37
14
Activity: Functions
07:09
15
Numeric Types & Basic Arithmetic
03:37
16
Activity: Basic Math
05:28
17
Control Flow: If & Else
02:34
18
Activity: Logic with If & Else
04:00
19
Activity: Logic with If & Else
05:01
20
Match Expression
04:26
21
Demo: Basic Match
03:12
22
Activity: Basic Match 1
04:04
23
Activity: Basic Match 2
05:12
24
The Loop Expression
04:49
25
Activity: Loops
04:59
26
The While Loop
03:23
27
Activity: While Loops
04:46
28
Enums
03:12
29
Demo: Enums
03:44
30
Activity: Enums
06:10
31
Structs
02:48
32
Demo: Structs
02:52
33
Activity: Structs
09:28
34
Tuples
03:32
35
Demo: Tuples
05:50
36
Activity: Tuples
05:56
37
Expressions
03:50
38
Demo: Expressions
05:10
39
Activity: Expressions
07:12
40
Intermediate Memory Concepts
03:35
41
Ownership
06:18
42
Demo: Ownership
06:08
43
Activity: Ownership
04:58
44
Implementing Functionality
09:21
45
Activity: Implementing Functionality
16:31
46
The Vector Data Structure
04:54
47
Vector Basics & For Loops
02:29
48
Activity: Vectors & For Loops
06:49
49
About Strings
04:01
50
Demo: Strings
04:29
51
Activity: Strings
07:24
52
Deriving Functionality
06:09
53
Type Annotations
04:08
54
Enums Revisited
04:00
55
Demo: Advanced Match
07:58
56
Activity: Advanced match
10:43
57
The Option Type
06:27
58
Demo: Option
04:27
59
Activity: Option
05:02
60
Generating Documentation
02:25
61
Standard Library API docs
03:34
62
Activity: Standard Library API docs
03:47
63
The Result Type
04:41
64
Demo: Result
14:17
65
Activity: Result
06:41
66
Activity: Result & The Question Mark Operator
07:52
67
The HashMap Data Structure
04:21
68
Working With HashMaps
05:33
69
Activity: HashMap Basics
08:27
70
Basic Closures
04:42
71
Map Combinator
05:02
72
Activity: Map Combinator
08:08
73
Option Combinator Pattern
07:50
74
Activity: Option Combinators
04:24
75
Using Iterators
09:13
76
Activity: Using Iterators
05:15
77
Ranges
01:59
78
If..let..else
02:59
79
while..let
02:07
80
Inline Modules
04:03
81
Activity: Inline Modules
10:19
82
Testing
06:53
83
Activity: Testing
07:43
84
External Crates
06:29
85
Activity: Adding an External Crate
04:46
86
External Modules
10:28
87
Activity: External Modules
09:55
88
Gathering User Input
14:22
89
Activity: Gathering User Input
22:48
90
Mini Project: Introduction
02:45
91
Retrieve User Input
03:17
92
Creating The Main Menu Loop
07:15
93
Required Data Structures
04:11
94
Implementation: Adding & Viewing Bills
13:01
95
Implementation: Removing Bills
06:51
96
Implementation: Editing Bills
09:16
97
Traits
04:55
98
Demo: Traits
04:59
99
Activity: Traits
05:59
100
Implementing The "Default" Trait
02:29
101
Generics & Functions
13:55
102
Demo: Generics & Functions
06:23
103
Activity: Generics & Functions
05:53
104
Generic Structures
10:07
105
Generic Structures & impl Blocks
07:59
106
Demo: Generics & Structures
06:39
107
Activity: Generics & Structures
10:19
108
Advanced Memory Concepts
08:51
109
Trait Objects
11:36
110
Demo: Trait Objects
07:27
111
Activity: Trait Objects
08:36
112
Ownership & Lifetimes
09:04
113
Demo: Lifetimes
08:33
114
Activity: Lifetimes & Structures
10:50
115
Activity: Lifetimes & Functions
04:48
116
Custom Error Types
08:52
117
Demo: Custom Error Types
08:54
118
Activity: Creating a Custom Error
09:02
119
const
02:21
120
New Type Pattern
05:08
121
Activity: Utilizing The New Type Pattern
08:09
122
TypeState Pattern
04:14
123
Demo: TypeState Pattern
11:49
124
Activity: TypeState Pattern
07:42
125
Demo: Match Guards & Binding
06:23
126
Activity: Match Guards & Binding
08:46
127
Arrays & Slices
07:49
128
Slice Patterns
05:54
129
Activity: Slices
05:42
130
Type Aliases
05:23
131
Exercise: Imposter Syndrome
02:56
132
From/Into
08:18
133
TryFrom/TryInto
03:57
134
Demo: From/Into
07:59
135
Activity: TryFrom/TryInto
10:16
136
Numeric Limits & Numeric Type Casting
08:00
137
Effective Trait Usage
10:01
138
Demo: Abstract Network Request
12:07
139
Activity: Abstract Data Storage
17:55
140
Demo: Proxy / Delegate
10:18
141
Activity: Implement a proxy structure
08:50
142
Demo: Extension traits
03:32
143
Demo: Blanket implementations
05:40
144
Activity: Extension traits & blanket implementations
03:31
145
Test-Driven Development (TDD)
11:34
146
TDD Demo: Standalone function 1
06:51
147
TDD Demo: Standalone function 2
06:35
148
TDD Demo: struct methods
13:56
149
Red-Green-Refactor
05:16
150
TDD Demo: Maintainable tests 1
08:44
151
TDD Demo: Maintainable tests 2
09:34
152
TDD Demo: Maintainable tests 3
12:31
153
Activity: Applying TDD
14:37
154
Project overview
00:58
155
Creating a new project
02:34
156
Project structure
03:34
157
Dependencies
01:32
158
Error configuration
10:16
159
Tracing configuration
05:28
160
Initial testing setup
09:29
161
CLI Parsing module
09:46
162
Parsing with Clap
06:07
163
Tracker module
08:03
164
Starting & stopping the tracker
11:21
165
Time records setup
11:42
166
TIme records implementation
13:56
167
Tracker behavior test
05:14
168
Tracker behavior test implementation
02:17
169
Extract tracker interface
05:41
170
Reporting setup
15:36
171
Calculating elapsed duration
05:20
172
Report formatter setup
04:20
173
Report formatter implementation
01:56
174
CLI: start command test setup
08:34
175
CLI: start & stop command implementation
10:50
176
CLI: generating reports & cleanup
11:38
177
Passing Closures to Functions
10:54
178
Threads
06:45
179
Demo: Threads
07:40
180
Activity: Threads
04:30
181
Channels
08:14
182
Demo: Channels
05:05
183
Demo: Bidirectional Threaded Communication
07:29
184
Activity: Channels
09:24
185
Smart Pointers
05:14
186
Interior Mutability: Cell & RefCell
02:52
187
Demo: Smart Pointers & RefCell
04:48
188
Activity: Smart Pointers & RefCell
06:32
189
Arc/Mutex
05:23
190
Threading: Deadlocks
02:35
191
Demo: Arc/Mutex
05:46
192
Activity: Arc/Mutex
09:15
193
Enum Equality & Ordering
04:12
194
Struct Equality & Ordering
08:39
195
Operator Overloading
04:17
196
Iterators: Implementing Iterator for a Struct
07:32
197
Implement IntoIterator
04:16
198
Demo: Implementing IntoIterator
04:16
199
Activity: Implementing Iterator
13:19
200
Iterators: Custom Iteration Logic
06:39
201
Helpful Macros
09:24
202
Managing Integer Overflow
06:41
203
Turbofish
03:15
204
Loop Labels
07:50
205
Loop Expressions
08:53
206
Struct Update Syntax
06:33
207
Escape Sequences & Raw Strings
15:40
208
dotenvy
02:33
209
serde
03:43
210
rand
04:18
211
cached
07:49
212
regex
07:59
213
chrono
08:07
214
strum
08:08
215
derive_more
03:32
216
rayon
02:35
217
tracing
02:45
218
color-eyre
05:40
219
Overview
07:25
220
Detail
06:55
221
Demo: impl Blocks
04:21
222
Activity: Control Flow
04:01
223
Activity: impl Blocks
05:18
224
Repetitions
08:48
225
Demo: Repetitions
03:57
226
Activity: HashMap
04:08
227
Demo: Syntax Extension
04:24
228
Activity: Syntax Extension
02:48
229
Activity: Generating Tests
04:25
230
Activity: Function Tracer
01:18
231
Demo: Checked Config
06:28
232
Demo: Recursive tt Muncher
06:30
233
Thank You!
02:30
Watch the other 232 lessons

One payment unlocks this course and every other premium course. No auto-renew.

See plans

Books

Read Book Rust Programming: The Complete Developer's Guide

#TitleTypeOpen
100-intro —Unlock
201-fundamentals-data-types —Unlock
302-fundamentals-variables —Unlock
403-fundamentals-functions —Unlock
504-fundamentals-println —Unlock
605-fundamentals-control-flow —Unlock
706-fundamentals-repetition —Unlock
807-fundamentals-match —Unlock
908-working-with-data-enums —Unlock
1009-working-with-data-structs —Unlock
1110-working-with-data-tuples —Unlock
1211-fundamentals-expressions —Unlock
1312-fundamentals-intermediate-memory —Unlock
1413-fundamentals-ownership —Unlock
1514-data-structures-vectors —Unlock
1615-data-types-strings —Unlock
1716-fundamentals-type-annotations —Unlock
1817-working-with-data-enum-revisited —Unlock
1918-working-with-data-option —Unlock
2019-working-with-data-result —Unlock
2120-data-structures-hashmaps —Unlock
2221-managing-code-external-modules —Unlock
2322-mini-project-billing —Unlock
2423-traits —Unlock
2524-generics-and-functions —Unlock
2625-generic-structures —Unlock
2726-generic-structures-and-impl-blocks —Unlock
2827-fundamentals-advanced-memory —Unlock
2928-trait-objects —Unlock
3029-ownership-and-lifetimes —Unlock
3130-fundamentals-custom-error-types —Unlock
3231-typestate-pattern —Unlock
3332-arrays-and-slices —Unlock
3433-slice-patterns —Unlock
3534-type-aliases —Unlock
3635-type-conversion-from-into —Unlock
3736-type-conversion-tryfrom-tryinto —Unlock
3837-numeric-limits-and-type-conversion —Unlock
3938-parallel-execution-threads —Unlock
4039-parallel-execution-channels —Unlock
4140-smart-pointers —Unlock
4241-interior-mutability-cell-refcell —Unlock
4342-arc-mutex —Unlock
4443-threading-deadlocks —Unlock
4544-enum-equality-and-ordering —Unlock
4645-struct-equality-and-ordering —Unlock
4746-operator-overloading —Unlock
4847-iterators-implement-iterator-for-a-struct —Unlock
4948-iterators-implement-intoiterator —Unlock
5049-iterators-custom-iteration-logic —Unlock
5150-helpful-macros —Unlock
5251-managing-integer-overflow —Unlock
5352-turbofish —Unlock
5453-loop-labels —Unlock
5554-loop-expressions —Unlock
5655-struct-update-syntax —Unlock
5756-escape-sequences-and-raw-strings —Unlock
5857-declarative-macros-detail —Unlock
5958-declarative-macros-overview —Unlock
6059-declarative-macros-repetitions —Unlock
61a01-effective-trait-usage —Unlock
62a02-test-driven-development —Unlock
63a03-red-green-refactor —Unlock
64crate-roundup-cached —Unlock
65crate-roundup-chrono —Unlock
66crate-roundup-color-eyre —Unlock
67crate-roundup-derive-more —Unlock
68crate-roundup-dotenvy —Unlock
69crate-roundup-rand —Unlock
70crate-roundup-rayon —Unlock
71crate-roundup-regex —Unlock
72crate-roundup-serde —Unlock
73crate-roundup-strum —Unlock
74crate-roundup-tracing —Unlock
75installation —Unlock

What courses are similar to Rust Programming: The Complete Developer's Guide?

More courses by Zero To Mastery

Frequently asked questions

What are the prerequisites for enrolling in this Rust programming course?
The course is designed for complete beginners, with no previous programming experience required. It starts with basic concepts such as data types, variables, and functions, making it accessible to those new to programming.
What kind of projects will I be able to build by the end of the course?
By the end of the course, you will have hands-on experience with real-world applications of Rust. You will build projects that involve control flow, loops, enums, structs, and more advanced concepts like ownership and type annotations.
Who is the target audience for this Rust programming course?
The course is ideal for aspiring programmers who want to learn Rust from scratch. It's also suitable for developers who want to expand their skill set with a focus on systems programming using Rust.
How does the depth of this course compare to other programming language courses?
The course provides a comprehensive introduction to Rust, covering fundamental topics such as data types and control flow, and progresses to intermediate concepts like ownership and vectors. It is designed to provide a solid foundation in Rust programming.
Which specific tools and platforms are covered in the course?
The course includes setup instructions for Rust toolchain, rust-analyzer, clippy, and error-lens. These tools help streamline development and ensure code quality in Rust projects.
What topics are not covered in this Rust programming course?
The course does not cover advanced topics such as asynchronous programming, unsafe code, or in-depth concurrency models. It focuses on foundational and intermediate Rust concepts.
How much time should I expect to commit to complete this course?
The course consists of 233 lessons. While the total runtime is not specified, students should expect to dedicate several weeks to complete the course, depending on their individual pace and prior knowledge.