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

Join premium to watch
Go to premium
# Title Duration
1 Rust Programming: The Complete Developer's Guide 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

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 Best Practices

Ultimate Rust Best Practices

Sources: ardanlabs.com
This course covers many best practices to help you with integrate Rust into your workflow, and let Rust’s tooling work for you. It includes formatting, linting, dependencies, vu...
1 hour 39 minutes 25 seconds
Rust: Building Reusable Code with Rust from Scratch

Rust: Building Reusable Code with Rust from Scratch

Sources: udemy
Rust is a systems programming language with a focus on safety, especially safe concurrency, supporting both functional and imperative paradigms, syntactically similar to C++, bu...
6 hours 17 minutes 32 seconds
Rust: The Complete Developer's Guide

Rust: The Complete Developer's Guide

Sources: udemy, Stephen Grider
Welcome to the most comprehensive and practical course for learning Rust from scratch! Rust is changing the approach to systems programming with its focus on...
9 hours 25 minutes 40 seconds
Rust for Beginners

Rust for Beginners

Sources: zerotomastery.io
Do you want to try Rust but don't know where to start? This course will be your starting point. Whether you have programming experience or not...
3 hours 18 minutes 19 seconds