Rust Programming Language for Beginners

More effective than C++. Develop your own Rust Programming library and increase your career options.

  • Tim Buchalka's Learn Programming Academy
  • 3.35
  • (385 reviews)
  • 19.5 hrs
  • 192 lectures
  • Udemy
Rust Programming Language for Beginners

What you will learn?

  • Learn how to code in an organized and efficient way using Rust modules
  • Learn how to build bug-free, memory safe applications and programs
  • Develop your own Rust Programming library and store it in the repository
  • Confidently program using Rust - a much sought after program from clients

Your trainer

Tim Buchalka's Learn Programming Academy

The Learn Programming Academy was created by Tim Buchalka, a software developer with 35 years experience, who is also an instructor on Udemy, with over 990K + students in his courses on Java, Python, Android, C# and the Spring framework.

The Academy’s goal in the next three years, is to teach one million people to learn how to program.

Apart from Tim’s own courses, which are all available here, we are working with the very best teachers, creating courses to teach the essential skills required by developers, at all levels.

One other important philosophy is that our courses are taught by real professionals; software developers with real and substantial experience in the industry, who are also great teachers. All our instructors are experienced, software developers!

192 lessons

Easy to follow lectures and videos covering subject details.

19.5 hours

This course includes hours of video material. Watch on-demand, anytime, anywhere.

Certificate of Completion

You will earn a Certificate of Completion at the end of this course.

Course curriculum

Introduction To Rust01:34:28

  • Introduction to Rust Programming03:09
  • Installing Rust in Windows08:10
  • Installing Rust in Linux05:00
  • Installing Rust in Mac05:36
  • Understanding Our First Program04:25
  • Datatypes in Rust16:15
  • Mutability and Intro to Strings17:13
  • Operators in Rust09:59
  • Comments in Rust01:45
  • Shadowing07:05
  • Typecasting05:50
  • Taking Input From User10:01

  • Introduction to Section00:39
  • Introduction to IF-Else01:42
  • Programs Based on If Else20:16
  • Else If Ladder04:34
  • Assignment If Else01:16
  • Assignment Solution14:29
  • Using If in Let11:10

  • Introduction to Section00:41
  • Introduction to Loops01:47
  • Loops Syntax in Rust09:47
  • Assignment Loops01:30
  • Assignment Solution Loops10:52

  • Introduction to Section01:06
  • Introduction to Functions03:30
  • Function Syntax in Rust05:54
  • Function Basic Program13:00
  • Assignment Function00:28
  • Assignment Solution Function07:16

  • Introduction to Section01:09
  • Tuple in Rust09:37
  • Array in Rust09:19

  • Introdution to Section01:12
  • Memory Allocation Techniques in Rust06:51
  • Ownership in Rust15:09
  • Ownership and Functions07:33
  • References and Borrowing13:18
  • Rules of References12:25
  • Dangle References04:18
  • Slices in Rust08:05

  • Introduction to Cargo17:21
  • Using Crates from Crates.io07:48
  • Coding Guessing Game Tutorial07:40

  • Introduction to Section02:31
  • Defining Struct10:29
  • Using Dot Notation05:50
  • Returning Instances of Struct07:35
  • Using Struct Update Syntax07:09
  • Methods08:42
  • Methods Continued08:19
  • Associated Function06:12
  • Assignment Structure01:36
  • Assignment Solution Structure06:33

  • Introduction to Section01:08
  • Introduction to Enums14:15
  • Enum Values17:03
  • Option Enum11:21
  • Match Control Flow Operator09:28
  • Patterns that Bind to Values08:46
  • Matching Option Enum04:39
  • "_" The PlaceHolder03:01
  • Control Flow Using If Let03:40

  • Introduction to Section01:26
  • Introduction to Modules05:59
  • Moving Modules to Files06:29
  • Controlling Visibility with Pub05:06
  • Reffering Names to Different Modules04:58
  • Assignment Modules01:19
  • Assignment Solution Modules08:47

  • Introduction to Section01:25
  • Introduction to Vectors05:09
  • Reading Data from Vector03:13
  • Reading Data from Vector Using for03:59
  • Storing Multiple Types in Vector03:02
  • String Basic Functions03:30
  • Plus Operator and Format! Macro06:31
  • chars() Method03:44
  • Introduction to HashMap04:38
  • Using collect() Method04:52
  • Using get() Method05:41
  • Updating HashMap04:42
  • Assignment Collections00:34
  • Assignment Collections Solution11:08

  • Introduction to Section01:31
  • Unrecoverable Error with Panic!04:16
  • Recoverable Errors with Result06:54
  • Matching on Different Errors06:01
  • Unwrap and Expect02:43
  • Propagating Errors06:27
  • Propagating Errors Using Question Mark02:45
  • Assignment Error Handling02:25
  • Assignment Solution Error Handling12:23

  • Introduction to Section01:48
  • Removing Duplication05:57
  • Fixing Largest Function03:06
  • Generics in Structure Definition03:49
  • Generics in Enums and Methods Definition03:56
  • Using Concrete Types in Generics04:08
  • Performance of Code Using Generics02:35
  • Defining Traits08:54
  • Default Implementation05:19
  • Fixing Largest Function with Traits02:32
  • Validating References with Lifetime04:21
  • Generic Lifetime in Function03:11
  • Lifetime-Annotation-Syntax04:28
  • Different Concrete Lifetime04:59
  • Lifetime Ellision06:15
  • Lifetime in Struct03:17
  • Assignment Generics00:48
  • Assignment Generics Solution04:07

  • Introduction to Section01:23
  • Introduction to Testing05:52
  • Using assert Macro04:57
  • Using assert_eq and asser_ne macro04:39
  • Custom Error Messages04:20
  • Using should_panic06:50
  • Running Test07:19
  • Unit Testing03:43
  • Integration Testing03:19

  • Introduction to Section02:10
  • Setting Up Our Project05:18
  • Reading File04:31
  • Refactoring to Improve Modularity10:55
  • Fixing Error Handling11:20
  • Extracting Logic from Main05:42
  • Splitting Code Into Library Crate03:19
  • Developing Library Functionality12:27
  • Working with Environment Variables14:14
  • Writing Error Messages to Standard Error05:09

  • Introduction to Section01:17
  • Introduction to Closures05:01
  • Writing Logic of Program05:02
  • Refactoring Using Functions04:13
  • Refactoring Using Closures05:08
  • Closure Type Inference and Annotation09:41
  • Storing Closures in Structure14:15
  • Limitation of Cacher Implementation03:47
  • Capturing the Environment with Closures06:55
  • Introduction to Iterators12:52
  • Methods that Produce Iterators05:20
  • Closure that Capture Environment10:44
  • Creating Our Own Iterator with Iterator Trait07:26
  • Using Iterator Trait Methods03:30
  • Improving our IO Project09:31

  • Introduction to Section00:45
  • Customizing Builds with Release Profiles04:09
  • Making Useful Documentation09:49
  • Exporting Public API with Pub Use10:18
  • Publishing on Crates.io08:24
  • Cargo Workspaces09:05
  • Adding Test to Workspace02:34
  • Installing Binaries from Crates.io01:34

  • Introduction to Section03:05
  • Introduction to Box03:20
  • Understanding Cons List05:32
  • Fixing Cons List06:49
  • Accessing Value with Dereference03:58
  • Implementing Deref Trait05:23
  • Implementing Deref Coercions04:10
  • Introduction to Drop Trait05:50
  • Dropping a Value Early04:24
  • Reference Count10:52
  • Introduction to Refcell03:48
  • Using Interior Mutability17:45
  • Refcell Borrow Checker04:29
  • Multiple Owners by Rc and RefCell03:38

  • Introduction to Section02:31
  • Concurrency and Parallelism05:04
  • Using Threads09:22
  • Using Join Handles03:07
  • Using Move Closure with Threads05:13
  • Message Passing Between Threads05:43
  • Sending Multiple Values04:32
  • Multiple Producer by Cloning Transmitter02:55
  • Passing Channel to Function04:49
  • Cold Drink Manufacturing09:35
  • Assignment Channels01:58
  • Assignment Solution Channels19:18
  • Introduction to Mutex04:55
  • Sharing Mutex Between Multiple Threads09:24
  • Movie Ticket Booking System09:07
  • Assignment Cab Booking System00:40
  • Assignment Solution Cab Booking System05:40

  • Introduction to Section01:40
  • Match and If let07:28
  • while let and for let Patterns06:18
  • Refutable and Irrefutable Patterns04:28
  • Pattern Syntax04:57
  • Ref and Ref mut03:09

  • Source Codes02:26
  • Bonus Lecture and Information04:49
Enroll now
Online Courses

Learning Rust doesn't have to be hard. Here is our curated list of recommended online courses that will guide you step-by-step in the learning process.

Learn more
Books

Are you an avid book reader? Do you prefer paperback, or maybe Kindle version? Take a look at our curated list of Rust related books and take yourskills to the next level.

Learn more
YouTube videos

The number of high-quality and free Rust video tutorials is growing fast. Check this curated list of recommended videos - there is no excuse to stop learning.

Learn more