Free Course Image Rust Programming Masterclass (Beginner to Advanced)

Free online courseRust Programming Masterclass (Beginner to Advanced)

Duration of the online course: 6 hours and 38 minutes

New

Free Rust course from beginner to advanced: ownership, borrowing, traits, generics, iterators, error handling, concurrency, and async await.

In this free course, learn about

  • Getting Started with Rust Basics
  • Core Data Types and Data Structures
  • Control Flow and Program Structure
  • Error Handling with Result and Option
  • Ownership, Borrowing, and Slices
  • Collections in Rust
  • Traits and Polymorphism
  • Generics and Type System Essentials
  • Iterators and Lifetimes
  • Functions, Closures, and Functional Patterns
  • Smart Pointers and Interior Mutability
  • Concurrency and Async Programming

Course Description

Rust Programming Masterclass (Beginner to Advanced) is a free online course designed to take you from the fundamentals of Rust to advanced, production-ready concepts. It starts with the essentials of syntax and core data types, then quickly builds toward writing clear, efficient programs with strong compile-time guarantees.

You will develop a solid understanding of Rust’s unique memory model, including ownership, borrowing, lifetimes, and slices, so you can write safe code without a garbage collector. The course also explores how to model real programs using enums, structs, methods, modules, pattern matching, and idiomatic control flow.

As you progress, you will learn practical error handling with Result, propagation patterns, and strategies for working with multiple error types. You will also gain confidence with collections and iteration, including vectors, hash maps, hash sets, and iterator patterns for transforming and aggregating data efficiently.

Advanced sections cover traits and generics in depth, including trait bounds, associated types, sized vs ?Sized, static vs dynamic dispatch, fully qualified syntax, operator overloading, and conversion traits. You will also explore closures and function pointers, including capture semantics and the differences between Fn, FnMut, and FnOnce.

To round out a modern Rust skill set, the course introduces smart pointers and interior mutability patterns, and then moves into concurrency and async programming. You will learn foundational approaches to threads, synchronization, messaging, and async await, helping you choose the right model for real-world workloads.

Course content

  • Video class: Hello Rust | Learn Rust part 1 02m
  • Video class: Print | Learn Rust part 2 05m
  • Video class: Variables | Learn Rust part 3 04m
  • Exercise: In Rust, how do you allow a variable’s value to be changed after it is declared?
  • Video class: Scalar Types | Learn Rust part 4 08m
  • Video class: Tuples | Learn Rust part 5 05m
  • Video class: Arrays | Learn Rust part 6 05m
  • Video class: String and 08m
  • Exercise: Which guideline best describes when to use String vs &str in Rust?
  • Video class: Enum | Learn Rust part 8 08m
  • Video class: Struct | Learn Rust part 9 07m
  • Exercise: In Rust, how do you access the fields of a tuple struct like `struct Point3D(f32, f32, f32);`?
  • Video class: Struct method | Learn Rust part 10 04m
  • Video class: Operators | Learn Rust part 11 06m
  • Exercise: When dividing integers in Rust (e.g., 1 / 2), what happens to the fractional part?
  • Video class: If Else Statement | Learn Rust part 12 02m
  • Video class: Loop | Learn Rust part 13 07m
  • Exercise: When looping through a vector twice in Rust, what approach avoids the use of moved value error?
  • Video class: Match statement | Learn Rust part 14 05m
  • Video class: If let statement | Learn Rust part 15 02m
  • Exercise: In Rust, what is a key requirement of the code inside a let ... else block when the pattern does not match?
  • Video class: Function | Learn Rust part 16 03m
  • Video class: Module | Learn Rust part 17 09m
  • Exercise: In Rust, why might calling a nested module function like m::a::print() from main fail even if print() is marked pub?
  • Video class: Handle Error | Learn Rust part 18 05m
  • Video class: Unwrap | Learn Rust part 19 04m
  • Exercise: What is the key difference between Rust’s unwrap() and expect() when handling Option or Result?
  • Video class: Question operator | Learn Rust part 20 09m
  • Video class: Return different error types from a Result | Learn Rust part 21 07m
  • Exercise: In Rust, how can a function use the ? operator when calling other functions that return Result with different error types (e.g., MathError and ParseError)?
  • Video class: Ownership rules | Learn Rust part 22 07m
  • Video class: Borrow rules | Learn Rust part 23 08m
  • Exercise: Which Rust borrowing rule explains why code fails when you create immutable references to a value and then also create a mutable reference to that same value while the immutable references are still used?
  • Video class: How borrow rules apply to functions | Learn Rust part 24 06m
  • Video class: Examples of borrow rules with slices | Learn Rust part 25 03m
  • Exercise: When a slice is passed into a function in Rust, what happens regarding ownership?
  • Video class: When to use String and 08m
  • Video class: Dereference | Learn Rust part 27 03m
  • Exercise: When a function takes a mutable reference (&mut String) and dereferences it to modify the string, what happens to ownership?
  • Video class: Vector | Learn Rust part 28 06m
  • Video class: Hash map | Learn Rust part 29 05m
  • Exercise: In Rust, which method combination is used to upsert (insert if missing, otherwise update) a value in a HashMap?
  • Video class: Hash set | Learn Rust part 30 03m
  • Video class: Trait | Learn Rust part 31 06m
  • Exercise: In Rust, what is the best way to let a function accept either of two different structs (e.g., Solidity and Viper) as long as they share the same behavior (like a compile method)?
  • Video class: Trait as function input and output | Learn Rust part 32 09m
  • Video class: Super trait | Learn Rust part 33 04m
  • Exercise: In Rust, how do you declare that a trait requires implementors to also implement two other traits (a supertrait relationship)?
  • Video class: Fully qualified syntax | Learn Rust part 34 02m
  • Video class: Generic data type | Learn Rust part 35 04m
  • Exercise: What is the main benefit of using a generic data type like Option instead of separate Option types for each concrete type?
  • Video class: Generic function | Learn Rust part 36 05m
  • Video class: How is generics compiled? Monomorphization | Learn Rust part 37 04m
  • Exercise: What does monomorphisation do to generic code in Rust during compilation?
  • Video class: Generic methods | Learn Rust part 38 02m
  • Video class: Generic trait | Learn Rust part 39 05m
  • Exercise: How do you convert a trait that uses a concrete type (like u32) into a generic trait in Rust?
  • Video class: From and Into traits | Learn Rust part 40 03m
  • Video class: Trait bounds | Learn Rust part 41 06m
  • Exercise: What is the key difference between using `impl Trait` in function parameters versus using a single generic type with a trait bound (e.g., `fn g(x: T, y: T)`)?
  • Video class: Sized and ?Sized | Learn Rust part 42 06m
  • Video class: Static and dynamic dispatch | Learn Rust part 43 07m
  • Exercise: Which statement best describes Rust dynamic dispatch compared to static dispatch?
  • Video class: Associated types | Learn Rust part 44 06m
  • Video class: Operator overload | Learn Rust part 45 04m
  • Exercise: How do you overload the + operator for a custom Point type in Rust?
  • Video class: Difference between iter, into_iter and iter_mut | Learn Rust part 46 05m
  • Video class: Iterator adaptors map, filter, collect, zip and fold | Learn Rust part 47 11m
  • Exercise: When using Rust iterators, what does the adapter zip do when two collections have different lengths?
  • Video class: Lifetimes | Learn Rust part 48 03m
  • Video class: Function pointer | Learn Rust part 49 04m
  • Exercise: How do you declare a variable in Rust that can store a function pointer taking two u32 values and returning a u32?
  • Video class: Closure | Learn Rust part 50 06m
  • Video class: Closure, ownership and move | Learn Rust part 51 04m
  • Exercise: In Rust, what does adding the move keyword to a closure do when it captures a variable like a String?
  • Video class: Fn, FnMut and FnOnce | Learn Rust part 52 09m
  • Video class: Return closure as function output | Learn Rust part 53 08m
  • Video class: Box | Learn Rust part 54 06m
  • Video class: Rc | Learn Rust part 55 11m
  • Exercise: Why is Rust’s smart pointer Rc used when building a shared list structure (e.g., two lists sharing the same tail)?
  • Video class: RefCell | Learn Rust part 56 07m
  • Video class: Weak reference | Learn Rust part 57 12m
  • Exercise: Why can using Rc in a reference cycle (like two graph nodes pointing to each other) cause a memory leak?
  • Video class: Thread | Learn Rust part 58 06m
  • Video class: Scoped thread | Learn Rust part 59 04m
  • Exercise: What is a key advantage of using scoped threads (thread::scope) in Rust?
  • Video class: Channel | Learn Rust part 60 11m
  • Video class: Mutex | Learn Rust part 61 06m
  • Exercise: In Rust, which combination is recommended for sharing and mutating data safely across multiple threads?
  • Video class: Arc | Learn Rust part 62 04m
  • Video class: Async / Await | Learn Rust part 63 08m
  • Exercise: In Rust, what happens when you call an async function without using await?
  • Video class: Async or native thread? | Learn Rust part 64 07m

This free course includes:

6 hours and 38 minutes of online video course

Digital certificate of course completion (Free)

Exercises to train your knowledge

100% free, from content to certificate

Ready to get started?Download the app and get started today.

Install the app now

to access the course
Icon representing technology and business courses

Over 5,000 free courses

Programming, English, Digital Marketing and much more! Learn whatever you want, for free.

Calendar icon with target representing study planning

Study plan with AI

Our app's Artificial Intelligence can create a study schedule for the course you choose.

Professional icon representing career and business

From zero to professional success

Improve your resume with our free Certificate and then use our Artificial Intelligence to find your dream job.

You can also use the QR Code or the links below.

QR Code - Download Cursa - Online Courses

More free courses at Programming Languages ( Python, Ruby, Java, C )

Free Ebook + Audiobooks! Learn by listening or reading!

Download the App now to have access to + 5000 free courses, exercises, certificates and lots of content without paying anything!

  • 100% free online courses from start to finish

    Thousands of online courses in video, ebooks and audiobooks.

  • More than 60 thousand free exercises

    To test your knowledge during online courses

  • Valid free Digital Certificate with QR Code

    Generated directly from your cell phone's photo gallery and sent to your email

Cursa app on the ebook screen, the video course screen and the course exercises screen, plus the course completion certificate