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.
Rust Programming: The Complete Developer's Guide
25h 37m 12s
English
Paid
- 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
About the Author: Zero To Mastery
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.
Watch Online 233 lessons
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
Related courses
-
Updated 3y agoRust for JavaScript Developers
By: Sidhartha ChatterjeeIf 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 Rus -
Updated 1y agoLearn Rust in a Month of Lunches
By: Dave MacLeod"Learn Rust in a Month of Lunches" - just one month and one hour a day to start writing code in Rust!5/5 -
Updated 2y agoUltimate Rust Foundations
By: Ardan LabsUltimate Rust: This course covers many best practices to help you integrate Rust into your workflow, and let Rust’s tooling work for you.17h 53m5/5
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.