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
Watch Online Rust Programming: The Complete Developer's Guide
0:00
/ #1: Rust Programming: The Complete Developer's Guide
All Course Lessons (233)
| # | Lesson Title | Duration | Access |
|---|---|---|---|
| 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 subscriptionBooks
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 commentsSimilar courses

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

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

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
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
Want to join the conversation?
Sign in to comment