Rust Programming: The Complete Developer's Guide

Name: Rust Programming: The Complete Developer's Guide
Price: 9 USD
Availability: InStock

25h 37m 12s

English

Paid

September 19, 2025

Course description

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.

Watch Online

0:00

#1: Rust Programming: The Complete Developer's Guide

All Course Lessons (233)

#	Lesson Title	Duration
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

#	Title
1	00-intro
2	01-fundamentals-data-types
3	02-fundamentals-variables
4	03-fundamentals-functions
5	04-fundamentals-println
6	05-fundamentals-control-flow
7	06-fundamentals-repetition
8	07-fundamentals-match
9	08-working-with-data-enums
10	09-working-with-data-structs
11	10-working-with-data-tuples
12	11-fundamentals-expressions
13	12-fundamentals-intermediate-memory
14	13-fundamentals-ownership
15	14-data-structures-vectors
16	15-data-types-strings
17	16-fundamentals-type-annotations
18	17-working-with-data-enum-revisited
19	18-working-with-data-option
20	19-working-with-data-result
21	20-data-structures-hashmaps
22	21-managing-code-external-modules
23	22-mini-project-billing
24	23-traits
25	24-generics-and-functions
26	25-generic-structures
27	26-generic-structures-and-impl-blocks
28	27-fundamentals-advanced-memory
29	28-trait-objects
30	29-ownership-and-lifetimes
31	30-fundamentals-custom-error-types
32	31-typestate-pattern
33	32-arrays-and-slices
34	33-slice-patterns
35	34-type-aliases
36	35-type-conversion-from-into
37	36-type-conversion-tryfrom-tryinto
38	37-numeric-limits-and-type-conversion
39	38-parallel-execution-threads
40	39-parallel-execution-channels
41	40-smart-pointers
42	41-interior-mutability-cell-refcell
43	42-arc-mutex
44	43-threading-deadlocks
45	44-enum-equality-and-ordering
46	45-struct-equality-and-ordering
47	46-operator-overloading
48	47-iterators-implement-iterator-for-a-struct
49	48-iterators-implement-intoiterator
50	49-iterators-custom-iteration-logic
51	50-helpful-macros
52	51-managing-integer-overflow
53	52-turbofish
54	53-loop-labels
55	54-loop-expressions
56	55-struct-update-syntax
57	56-escape-sequences-and-raw-strings
58	57-declarative-macros-detail
59	58-declarative-macros-overview
60	59-declarative-macros-repetitions
61	a01-effective-trait-usage
62	a02-test-driven-development
63	a03-red-green-refactor
64	crate-roundup-cached
65	crate-roundup-chrono
66	crate-roundup-color-eyre
67	crate-roundup-derive-more
68	crate-roundup-dotenvy
69	crate-roundup-rand
70	crate-roundup-rayon
71	crate-roundup-regex
72	crate-roundup-serde
73	crate-roundup-strum
74	crate-roundup-tracing
75	installation

Comments

0 comments

Want to join the conversation?

Similar courses

Rust Developer Bootcamp

Sources: letsgetrusty.com

Who is this Bootcamp for? Experienced Developers trying to switch to Rust. Learn the language of the future. Your time is valuable (literally, $148,688/yr). Learn Rust FAST wit...

9 hours 50 minutes 20 seconds

Ultimate Rust 2: Intermediate Concepts

Sources: ardanlabs.com

Master the Rust language: delve into variables, functions, and memory structure. For system developers looking to create safe and fast code.

5 hours 1 minute 56 seconds

Let’s Rust

Sources: Pau Labarta Bajo

Take the Let's Rust course and develop an ML service in Rust. Train the model, create a REST API for predictions, and deploy the service in Kubernetes.

12 hours 40 minutes 9 seconds

Transform Your Craft with TDD: Master clean code and testing

Sources: Daniel Moka

Do you want to learn TDD but don't know where to start? "Прокачай свой код с TDD" (Enhance Your Code with TDD) is a beginner-friendly e-book and video...

4 hours 7 minutes 36 seconds

Ultimate Rust Crash Course