Rust Programming Language for Beginners

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

mm
Diwakar Singh
(72 reviews)
Take this course
1747516_5bc7.jpg

Why learn Rust?

Firstly, Rust is hot.  Clients are screaming for Rust developers, so if you learn this language there is little doubt you will have increased career options.  

Rust is a simple, efficient and time-saving application that has been designed from the ground-up to prevent faults and keep data secure. This reduces the amount of code you need to write, freeing up time to work on other projects.

But lets not forget one incredibly important feature.  Rust is fun to program in.  In fact it’s regularly voted as one of the most fun languages to develop in.

In this Rust Programming Language for Beginners course, you’ll see real-life examples that can be applied to personal or corporate programs.

One of the many benefits that Rust has is an ownership system, eliminating bugs that crash your apps and programs.  It works just fine in Windows, Mac and Linux.

You can also develop your own libraries and publish them on the Rust repository. Sharing these with other programmers quickly broadens your experience and puts you at the head of the pack.

By the end of this course you’ll have a solid understanding of the Rust language, and  will be able to code in an organised yet fast way through rust modules.

Finally, discover trait-based generics and then you will develop your own grep tool in Rust.

Course topics include: 

If – Else in Rust

Loops in Rust

Functions in Rust

Tuple and Array in Rust

Ownership in Rust

Guessing Game Using Cargo

Structure in Rust

Enums and Pattern Matching

Using Modules to Re-use and Organize Code

Common Collections

Error Handling

Generic Types, Traits & Lifetimes

Testing

An IO Project- Building a Command Line Program

Iterators & Closures

Cargo and Crates .io

Smart Pointer

Fearless Concurrency

Patterns and Matching

As you can see, this course is packed with value to teach you to confidently program in one of the languages that developers love and clients seek help for!

The ideal student would be a someone with a basic knowledge of C,C++ (or another language) who is ready to master an empowering programming language.  But note that it’s not essential to have this knowledge.

Requirements

  • Knowledge in C or C++ or some other language is desirable, however no prior experience is required for this course
  • Enthusiasm and a willingness to take your Rust Programming skills to the next level

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

Who should attend

  • This course is suitable for both beginners and intermediates, who wish to become an expert in using the Rust Programming Language

Is available on google app?

Yes

Is available on ios?

Yes

Course Features

  • Lectures 193
  • Quizzes 0
  • Exercises 0
  • Duration 19.5 hours
  • Skill level Beginner Level
  • Students 868
  • Last Updated December, 2018

You have 20 weeks remaining for the course

  • Introduction To Rust 01:29:30

    • Lecture
      Introduction to Rust Programming 03:09
    • Lecture
      Installing Rust in Windows 05:19
    • Lecture
      Installing Rust in Linux 04:14
    • Lecture
      Installing Rust in Mac 04:15
    • Lecture
      Understanding Our First Program 04:25
    • Lecture
      Datatypes in Rust 16:15
    • Lecture
      Mutability and Intro to Strings 17:13
    • Lecture
      Operators in Rust 09:59
    • Lecture
      Comments in Rust 01:45
    • Lecture
      Shadowing 07:05
    • Lecture
      Typecasting 05:50
    • Lecture
      Taking Input From User 10:01

  • If - Else in Rust 54:06

    • Lecture
      Introduction to Section 00:39
    • Lecture
      Introduction to IF-Else 01:42
    • Lecture
      Programs Based on If Else 20:16
    • Lecture
      Else If Ladder 04:34
    • Lecture
      Assignment If Else 01:16
    • Lecture
      Assignment Solution 14:29
    • Lecture
      Using If in Let 11:10

  • Loops in Rust 24:37

    • Lecture
      Introduction to Section 00:41
    • Lecture
      Introduction to Loops 01:47
    • Lecture
      Loops Syntax in Rust 09:47
    • Lecture
      Assignment Loops 01:30
    • Lecture
      Assignment Solution Loops 10:52

  • Functions in Rust 31:14

    • Lecture
      Introduction to Section 01:06
    • Lecture
      Introduction to Functions 03:30
    • Lecture
      Function Syntax in Rust 05:54
    • Lecture
      Function Basic Program 13:00
    • Lecture
      Assignment Function 00:28
    • Lecture
      Assignment Solution Function 07:16

  • Tuple and Array in Rust 20:05

    • Lecture
      Introduction to Section 01:09
    • Lecture
      Tuple in Rust 09:37
    • Lecture
      Array in Rust 09:19

  • Ownership in Rust 01:08:51

    • Lecture
      Introdution to Section 01:12
    • Lecture
      Memory Allocation Techniques in Rust 06:51
    • Lecture
      Ownership in Rust 15:09
    • Lecture
      Ownership and Functions 07:33
    • Lecture
      References and Borrowing 13:18
    • Lecture
      Rules of References 12:25
    • Lecture
      Dangle References 04:18
    • Lecture
      Slices in Rust 08:05

  • Guessing Game Using Cargo 32:49

    • Lecture
      Introduction to Cargo 17:21
    • Lecture
      Using Crates from Crates.io 07:48
    • Lecture
      Coding Guessing Game Tutorial 07:40

  • Structure in Rust 01:04:56

    • Lecture
      Introduction to Section 02:31
    • Lecture
      Defining Struct 10:29
    • Lecture
      Using Dot Notation 05:50
    • Lecture
      Returning Instances of Struct 07:35
    • Lecture
      Using Struct Update Syntax 07:09
    • Lecture
      Methods 08:42
    • Lecture
      Methods Continued 08:19
    • Lecture
      Associated Function 06:12
    • Lecture
      Assignment Structure 01:36
    • Lecture
      Assignment Solution Structure 06:33

  • Enums and Pattern Matching 01:13:21

    • Lecture
      Introduction to Section 01:08
    • Lecture
      Introduction to Enums 14:15
    • Lecture
      Enum Values 17:03
    • Lecture
      Option Enum 11:21
    • Lecture
      Match Control Flow Operator 09:28
    • Lecture
      Patterns that Bind to Values 08:46
    • Lecture
      Matching Option Enum 04:39
    • Lecture
      "_" The PlaceHolder 03:01
    • Lecture
      Control Flow Using If Let 03:40

  • Using Modules to Reuse and Organize Code 34:04

    • Lecture
      Introduction to Section 01:26
    • Lecture
      Introduction to Modules 05:59
    • Lecture
      Moving Modules to Files 06:29
    • Lecture
      Controlling Visibility with Pub 05:06
    • Lecture
      Reffering Names to Different Modules 04:58
    • Lecture
      Assignment Modules 01:19
    • Lecture
      Assignment Solution Modules 08:47

  • Common Collections 01:02:08

    • Lecture
      Introduction to Section 01:25
    • Lecture
      Introduction to Vectors 05:09
    • Lecture
      Reading Data from Vector 03:13
    • Lecture
      Reading Data from Vector Using for 03:59
    • Lecture
      Storing Multiple Types in Vector 03:02
    • Lecture
      String Basic Functions 03:30
    • Lecture
      Plus Operator and Format! Macro 06:31
    • Lecture
      chars() Method 03:44
    • Lecture
      Introduction to HashMap 04:38
    • Lecture
      Using collect() Method 04:52
    • Lecture
      Using get() Method 05:41
    • Lecture
      Updating HashMap 04:42
    • Lecture
      Assignment Collections 00:34
    • Lecture
      Assignment Collections Solution 11:08

  • Error Handling 45:25

    • Lecture
      Introduction to Section 01:31
    • Lecture
      Unrecoverable Error with Panic! 04:16
    • Lecture
      Recoverable Errors with Result 06:54
    • Lecture
      Matching on Different Errors 06:01
    • Lecture
      Unwrap and Expect 02:43
    • Lecture
      Propagating Errors 06:27
    • Lecture
      Propagating Errors Using Question Mark 02:45
    • Lecture
      Assignment Error Handling 02:25
    • Lecture
      Assignment Solution Error Handling 12:23

  • Generic Types, Traits, Lifetimes 01:13:30

    • Lecture
      Introduction to Section 01:48
    • Lecture
      Removing Duplication 05:57
    • Lecture
      Fixing Largest Function 03:06
    • Lecture
      Generics in Structure Definition 03:49
    • Lecture
      Generics in Enums and Methods Definition 03:56
    • Lecture
      Using Concrete Types in Generics 04:08
    • Lecture
      Performance of Code Using Generics 02:35
    • Lecture
      Defining Traits 08:54
    • Lecture
      Default Implementation 05:19
    • Lecture
      Fixing Largest Function with Traits 02:32
    • Lecture
      Validating References with Lifetime 04:21
    • Lecture
      Generic Lifetime in Function 03:11
    • Lecture
      Lifetime-Annotation-Syntax 04:28
    • Lecture
      Different Concrete Lifetime 04:59
    • Lecture
      Lifetime Ellision 06:15
    • Lecture
      Lifetime in Struct 03:17
    • Lecture
      Assignment Generics 00:48
    • Lecture
      Assignment Generics Solution 04:07

  • Testing 42:22

    • Lecture
      Introduction to Section 01:23
    • Lecture
      Introduction to Testing 05:52
    • Lecture
      Using assert Macro 04:57
    • Lecture
      Using assert_eq and asser_ne macro 04:39
    • Lecture
      Custom Error Messages 04:20
    • Lecture
      Using should_panic 06:50
    • Lecture
      Running Test 07:19
    • Lecture
      Unit Testing 03:43
    • Lecture
      Integration Testing 03:19

  • An IO Project- Building a Command Line Program 01:15:05

    • Lecture
      Introduction to Section 02:10
    • Lecture
      Setting Up Our Project 05:18
    • Lecture
      Reading File 04:31
    • Lecture
      Refactoring to Improve Modularity 10:55
    • Lecture
      Fixing Error Handling 11:20
    • Lecture
      Extracting Logic from Main 05:42
    • Lecture
      Splitting Code Into Library Crate 03:19
    • Lecture
      Developing Library Functionality 12:27
    • Lecture
      Working with Environment Variables 14:14
    • Lecture
      Writing Error Messages to Standard Error 05:09

  • Iterators & Closures 01:44:42

    • Lecture
      Introduction to Section 01:17
    • Lecture
      Introduction to Closures 05:01
    • Lecture
      Writing Logic of Program 05:02
    • Lecture
      Refactoring Using Functions 04:13
    • Lecture
      Refactoring Using Closures 05:08
    • Lecture
      Closure Type Inference and Annotation 09:41
    • Lecture
      Storing Closures in Structure 14:15
    • Lecture
      Limitation of Cacher Implementation 03:47
    • Lecture
      Capturing the Environment with Closures 06:55
    • Lecture
      Introduction to Iterators 12:52
    • Lecture
      Methods that Produce Iterators 05:20
    • Lecture
      Closure that Capture Environment 10:44
    • Lecture
      Creating Our Own Iterator with Iterator Trait 07:26
    • Lecture
      Using Iterator Trait Methods 03:30
    • Lecture
      Improving our IO Project 09:31

  • Cargo and Crates.io 46:38

    • Lecture
      Introduction to Section 00:45
    • Lecture
      Customizing Builds with Release Profiles 04:09
    • Lecture
      Making Useful Documentation 09:49
    • Lecture
      Exporting Public API with Pub Use 10:18
    • Lecture
      Publishing on Crates.io 08:24
    • Lecture
      Cargo Workspaces 09:05
    • Lecture
      Adding Test to Workspace 02:34
    • Lecture
      Installing Binaries from Crates.io 01:34

  • Smart Pointer 01:23:03

    • Lecture
      Introduction to Section 03:05
    • Lecture
      Introduction to Box 03:20
    • Lecture
      Understanding Cons List 05:32
    • Lecture
      Fixing Cons List 06:49
    • Lecture
      Accessing Value with Dereference 03:58
    • Lecture
      Implementing Deref Trait 05:23
    • Lecture
      Implementing Deref Coercions 04:10
    • Lecture
      Introduction to Drop Trait 05:50
    • Lecture
      Dropping a Value Early 04:24
    • Lecture
      Reference Count 10:52
    • Lecture
      Introduction to Refcell 03:48
    • Lecture
      Using Interior Mutability 17:45
    • Lecture
      Refcell Borrow Checker 04:29
    • Lecture
      Multiple Owners by Rc and RefCell 03:38

  • Fearless Concurrency 01:43:53

    • Lecture
      Introduction to Section 02:31
    • Lecture
      Concurrency and Parallelism 05:04
    • Lecture
      Using Threads 09:22
    • Lecture
      Using Join Handles 03:07
    • Lecture
      Using Move Closure with Threads 05:13
    • Lecture
      Message Passing Between Threads 05:43
    • Lecture
      Sending Multiple Values 04:32
    • Lecture
      Multiple Producer by Cloning Transmitter 02:55
    • Lecture
      Passing Channel to Function 04:49
    • Lecture
      Cold Drink Manufacturing 09:35
    • Lecture
      Assignment Channels 01:58
    • Lecture
      Assignment Solution Channels 19:18
    • Lecture
      Introduction to Mutex 04:55
    • Lecture
      Sharing Mutex Between Multiple Threads 09:24
    • Lecture
      Movie Ticket Booking System 09:07
    • Lecture
      Assignment Cab Booking System 00:40
    • Lecture
      Assignment Solution Cab Booking System 05:40

  • Patterns and Matching 28

    • Lecture
      Introduction to Section 01:40
    • Lecture
      Match and If let 07:28
    • Lecture
      while let and for let Patterns 06:18
    • Lecture
      Refutable and Irrefutable Patterns 04:28
    • Lecture
      Pattern Syntax 04:57
    • Lecture
      Ref and Ref mut 03:09

  • Bonus Material 05:30

    • Lecture
      Bonus - Please Watch! 00:48
    • Lecture
      Check out Our Other 36 Udemy Courses! 00:35
    • Lecture
      Source Codes 04:07
Diwakar Singh
Go, Rust, Java, C, C++ My Mission is Simple I want to teach advanced concepts in an easy way. I am a full time Programmer with Knowledge of  Google's  GO, Rust Java, Oracle, PL/SQL, MySQL, C ++, C.  I have… View Profile
Tim Buchalka's Learn Programming Academy
Professional Programmers and Teachers - 323,000+ students 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 335,000 students in his courses… View Profile

Student Feedback

3.9
72 Average ratings
22%
40%
28%
6%
4%

  • 1 week ago

    Andrew Wooldridge

    So far so good.

  • 2 weeks ago

    Jeff Gillin

    Very nice job on this course. Rust isn't an easy language to pickup at first. So many new concepts not in other languages. This is really helping to solidify my knowledge, and clear up some confusions I previously had.

  • 2 weeks ago

    Christopher Adigun

    Good teaching method by instructor especially as I am a beginner..

  • 2 months ago

    Grzesiek Buraczewski

    I was sceptic about Indian course, but this one is fantastic. W8ing for advence rust course :D.

  • 3 months ago

    Hs.. ..

    This Course is amazing. It tells you every bit of rust from beginning. I had no previous experience with rust but now I can confidently write rust programs. Really great course.

  • 3 months ago

    Todd Cullum

    The course is pretty thorough so far which is good. The instructor gives illustrations and explains "why and how" which is very helpful.

  • 6 months ago

    Adam Hartleb

    Concepts are clearly explained. The accent takes a bit to get used to but that's okay :). Very well done.

Take this course
Take this course

Related Courses

Leave A Reply

Your email address will not be published. Required fields are marked *