CF

Rust Programming: The Complete Developer's Guide

25h 37m 12s
English
Paid

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
Level
All levels
Language
English
Updated
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)

You can watch up to 10 minutes for free. Subscribe to unlock all 233 lessons in this course and access 10,000+ hours of premium content across all courses.

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
Unlock unlimited learning

Get instant access to all 232 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Books

Read Book Rust Programming: The Complete Developer's Guide

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

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.