Rust Programming: The Complete Developer's Guide

25h 37m 12s
English
Paid

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.

Read more about the course
  • 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

Watch Online

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

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

Comments

0 comments

Want to join the conversation?

Sign in to comment

Similar courses

Rust for JavaScript Developers

Rust for JavaScript Developers

Sources: Sidhartha Chatterjee
If you're a JavaScript developer like me, you might've been curious about Rust lately. A lot of modern JavaScript tooling (like Rome) is being re-written in Rust. This is becaus...
Ultimate Rust: Foundations - Next Steps

Ultimate Rust: Foundations - Next Steps

Sources: ardanlabs.com
This course offers the next steps not covered in Ultimate Rust: Foundations that expand on and optimize what you’ve already built.
50 minutes 48 seconds
Rust from C/C++

Rust from C/C++

Sources: ardanlabs.com
This course bridges the transition from C and C++ to Rust by highlighting their similarities and differences. Exploring Rust's native compilation, memory manage
5 hours 31 minutes 48 seconds
Transform Your Craft with TDD: Master clean code and testing

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