Top 8 Recommended Rust Self-Study Materials! [November 2024]

Welcome to the most comprehensive and hands-on course for learning Rust from the ground up!

Rust is revolutionizing systems programming with its focus on memory safety, concurrency, and performance. But with its unique concepts and syntax, many find Rust challenging to learn. That's where this course comes in – providing you with a clear, structured path to Rust mastery.

What sets this course apart? We focus on building a rock-solid foundation in Rust's core concepts. No fluff, no skipping steps – just pure, essential Rust knowledge that will set you up for success in any Rust project.

Rust's most challenging concepts are covered:

• Rust's ownership model? Explained in great detail!

• Lifetimes and borrowing? Its here!

• Traits and generics? You'll use them to write flexible code

  
  

This course is designed for developers who want to truly understand Rust, not just copy-paste code. Whether you're coming from Javascript, Python, or any other language, you'll find a welcoming introduction to Rust's unique paradigms.

Rust has been voted the "most loved programming language" in the Stack Overflow Developer Survey for seven consecutive years. It's not just hype – major companies like Microsoft, Google, and Amazon are increasingly adopting Rust for critical systems. By mastering Rust, you're not just learning a language; you're future-proofing your career.

Here's a (partial) list of what you'll learn:

• Dive deep into Rust's type system and how it ensures memory safety

• Master pattern matching and destructuring for elegant, expressive code

• Harness the power of Rust's error handling with Result and Option types

• Explore Rust's module system to organize and scale your projects

• Implement common data structures and algorithms the Rust way

• Use cargo to manage dependencies and build your projects with ease

• A solid grasp of Rust's syntax and core concepts

• The ability to write safe, efficient, and idiomatic Rust code

• Confidence to tackle real-world Rust projects and contribute to the ecosystem

• A deep and fundamental understanding of error handling

• The skills to optimize code for performance and memory usage

• And much more!

How This Course Works:

This isn't just another "follow along" coding course. We've structured the learning experience to ensure you truly internalize Rust's concepts:

1. Concept Introduction: Clear, concise explanations of each Rust feature

2. Live Coding: Watch as we implement concepts in real-time, explaining our thought process

3. Challenges: Test your understanding with carefully crafted coding exercises

4. Project Work: Apply your skills to build progressively complex projects

5. Best Practices: Learn idiomatic Rust and industry-standard coding patterns

   
   

This is the course I wish I had when I was learning Rust. A course that focuses on the hardest parts, gives clear explanations, and discusses the pros and cons of different design options. Sign up today and join me in mastering Rust!

1. Foundations of Rust: Setup and First Steps
2. Introduction
3. Rust Installation
4. Local Rust Install
5. Creating and Running Rust Projects
6. Disabling Inlay Type Hints
7. Course Resources
8. Core Concepts: The Building Blocks of Rust
9. Representing Data with Structs
10. Adding Functionality to Structs
11. Arrays vs Vectors
12. Mutable vs Immutable Bindings
13. Implementations and Methods
14. Implicit Returns
15. Installing External Crates
16. Using Code from Crates
17. Shuffling a Slice
18. Splitting a Vector
19. Project Review
20. A Taste of Rust
21. Ownership and Borrowing: Rust's Unique Memory System
22. Project Overview
23. Defining Structs
24. Adding Inherent Implementations
25. A Mysterious Error
26. Unexpected Value Updates
27. The Goal of Ownership and Borrowing
28. The Basics of Ownership
29. Owning and Moving Values
30. Visualizing Ownership and Moves
31. More on Owning and Moving
32. Exercise Overview
33. Exercise Solution
34. Another Quick Exercise
35. A Quick Exercise Solution
36. Writing Useful Code with Ownership
37. Working Around Ownership
38. Introducing the Borrow System
39. Immutable References
40. Working with References
41. Exercise On References
42. References Exercise Solution
43. Mutable References
44. Handling Mutable References
45. Exercise on Mutable Refs
46. Solution on Mutable Refs
47. Copy-able Values
48. Understanding Copies vs Moves
49. Lifetimes Explored: Understanding Memory Management
50. Basics of Lifetimes
51. Lifetimes
52. Deciding on Argument Types
53. Back to the Bank Impl
54. Implementing Deposits and Withdrawals
55. Accounts and Bank Implementation
56. Project Wrapup
57. Enums Unleashed: Pattern Matching and Options
58. Project Overview
59. Defining Enums
60. Declaring Enum Values
61. Adding Implementations to Enums
62. Pattern Matching with Enums
63. When to Use Structs vs Enums
64. Adding Catalog Items
65. Unlabeled Fields
66. Enums
67. The Option Enum
68. Option From Another Perspective
69. Replacing Our Custom Enum with Option
70. Other Ways of Handling Options
71. The Option Enum
72. Excercise Overview
73. Exercise Solution
74. Project Architecture: Mastering Modules in Rust
75. Modules Overview
76. Rules of Modules
77. Refactoring with Multiple Modules
78. Handling the Unexpected: Errors and Results
79. Project Overview
80. Reading a File
81. The Result Enum
82. The Result Enum in Action
83. Types of Errors
84. Matching on Results
85. Empty OK Variants
86. Exercise Around the Result Enum
87. Exercise Solution
88. Using a Result When Reading Files
89. Tricky Strings
90. The Stack and Heap
91. Strings, String Refs, and String Slices
92. When to Use Which String
93. Strings
94. Finding Error Logs
95. Understanding the Issue
96. Fixing Errors Around String Slices
97. Writing Data to a File
98. Alternatives to Nested Matches
99. The Try Operator
100. When to Use Each Technique
101. Iterator Deep Dive: Efficient Data Processing
102. Project Overview
103. Basics of Iterators
104. Using For Loops with Iterators
105. Iterator Consumers
106. Iterator Adaptors
107. Vector Slices
108. Reminder on Ownership and Borrowing
109. Iterators with Mutable Refs
110. Mutable Vector Slices
111. Collecting Elements from an Iterator
112. How Collect Works
113. Moving Ownership With Into_Iter
114. Inner Maps
115. Reminder on Lifetimes
116. Iterators Wrapup
117. Collect Excercise
118. Exercise Solution
119. The Filter Method
120. Filter Solution
121. Advanced Lifetimes: Mastering Rust's Memory Model
122. Lifetime Annotations
123. A Missing Annotation
124. A Review of Borrowing Rules
125. What Lifetime Annotation Are All About
126. Common Questions Around Lifetimes
127. Lifetime Elision
128. Common Lifetimes
129. Generics and Traits: Writing Flexible, Reusable Code
130. Project Setup
131. Issues with Number Types
132. The Basics of Generics
133. Trait Bounds
134. Multiple Generic Types
135. Super Solve Flexibility
136. App Overview
137. Building the Basket
138. Generic Structs
139. More on Generic Structs
140. Implementing a trait
141. Generic Trait Bounds
142. Bonus!
143. Bonus!

Programming languages usually have some tradeoffs. There are low level languages like C anc C++ usually have speed and control at the cost of memory safety. On the other hand, we high level languages such as python or java script are more safer but are not very efficient from power and speed perspectives. With rust we have best of both the worlds. More specifically, it is a system programming language which means they have speed and control but at the same time are much much better because of the safety features just like high level languages. This makes rust so clearly standout among all the other programming languages.

Its popularity is increasing day by day and is therefore being adapted by bigger companies world wide. Google is also planning to use Rust in the Linux kernel, Microsoft, meanwhile, has turned to Rust to reduce memory-related bugs in Windows and Facebook has also forged closer ties with Rust, joining the Rust Foundation. All these are clear indications that Rust is gaining significant attention of the community.

At 18+ hours of video tutorials, this course will take you from beginner to master level.  This course is designed from a perspective of a student who has no prior knowledge of RUST and who is a RUST beginner.

Throughout this comprehensive course, we cover a massive amount of skills and techniques including:

• Basic rust programming syntax and Common Rust Collectors

• Enums, Traits,  Structures, Generics, Lifetimes and Closures

• Rust Module System, the use of External Crates and Publishing Crates

• Smart Pointers and Commonly used Data Structures including linklists, trees, BST and doubly linklist

• Advance Techniques including macros, Concurrency and Aysnc Programming

• Real Life Problem where we will learn 13 Real Life Applications in rust from Scratch

• Efficient programming skills including Design Patterns, Efficient handling of Options, Strings and Structures

• Textual Processing and Directory Handling

• Webprogramming 

The course ensures that you learn by doing

• Practice exercise questions along with solutions

• Quizes and

• Assignments

By taking this course, you will become a fluent in RUST programming and you'll be so good so that you can confidently and professionlay code in the language.

Don't just rely on my word, check what some of our existing students have to say about my courses.

"I had viewed the video in the propose sequence, as well, as I had looked at some videos outside of the instructor propose sequence, and only had one thing to say: - This course is excellent"  Gabriel Federo Hungria

"I have gone through the course on MATLAB Gui by the instructor. It was an A++ experience. He is the best instructor, really professional and knows exactly what to teach. Thanks for your wonderful contribution to help us understand MATLAB." Kunal Singh

"Very interesting course, complete functionality of Matlab was explained and the quizzes further helped with the learning process." Hassan Ayub

Pleaset note… I am very confident that you will like the course and therefore provides you with a FULL money back guarantee for 30 days! So there is a ZERO risk and nothing to loose.

Finally, i am super excited to teach you RUST programming, so hit enroll and enjoy learning RUST

1. Course Orientation
2. Course introduction
3. Version 2.0 of the Course
4. Advice
5. Installing Rust and Web-based Enviroment for Executing Programs
6. Running and Compiling your First Program
7. VS Code Setting
8. Tell us About the Course
9. Links to Useful Books on Rust
10. Quick Reference Material
11. ---- Part 1: Basic Programming with Rust ----
12. Code Files Used in the Section
13. Quick Startup
14. Variables and Constants
15. Practice on Variables
16. Primitive Data Types
17. Compound Data Types
18. Practice on Data Types
19. Functions and Code Blocks
20. Practice on Functions
21. Conditionals
22. Control Flow
23. Practice on Conditionals and Control Flow
24. Extra - Comments, Prints Commands, Input
25. Test Your Knowledge
26. Ownership
27. Ownership Basics
28. Ownership in Functions
29. Practice on Ownership
30. Borrowing Basics
31. Borrowing in Functions
32. Practice on Borrowing
33. Dereferencing
34. Let's Test Your Knowledge
35. Extra: Good to know
36. Custom and Library Provided Useful Types
37. Structs Basics
38. Practice on Structs
39. Adding Functionality to Structs
40. Enums
41. Practice on Enums
42. Option
43. Practice on Option
44. Result
45. Practice on Result
46. Extra: HashMaps
47. Practice on HashMaps
48. Let's Test Your Knowledge
49. Organizing Your Code
50. Code Organization
51. Modules Basics
52. Practice on Modules
53. Visualizing and Organizing Modules
54. A note on the previous lecture
55. Re-exporting and Privacy
56. Practice on Re-exporting and Privacy
57. Using External Dependencies
58. Publishing your Crate
59. Let's Test Your Knowledge
60. Testing Code
61. Unit Testing (Basics)
62. Unit Testing (Testing Panics)
63. Controlling Tests Execution
64. Practice on Testing
65. Integration Tests
66. Extra: Benchmark Testing
67. ---- Part 2: Intermediate Level Concepts ----
68. Code Files Used in the Section
69. Flexibility and Abstraction with Generics and Traits
70. Generics
71. Practice on Generics
72. Traits
73. Practice on Traits
74. Trait Bounds
75. Practice on Trait Bounds
76. Supertraits
77. Practice on Supertraits
78. Trait Objects
79. Practice on Trait Objects
80. Derived Traits and Marker Traits
81. Associated Types in Traits
82. Practice on Associated Types
83. Choosing Associated vs Generic Type
84. Functional Programming Aspects
85. Closures
86. Practice on Closures
87. Functional Pointers
88. Practice on Functional Pointers
89. Iterators
90. IntoIter
91. Practice on Iterators and IntoIter
92. Iterating over Collections
93. Combinators
94. Practice for Iterating over Collections and Combinators
95. Extra - Iterating Through Option
96. Memory Management Features
97. Lifetimes (Part 1)
98. Lifetimes (Part 2)
99. Practice on Lifetimes (Part 2)
100. Lifetime Elision
101. Practice on Lifetime Elision
102. Lifetimes and Structs
103. Box Smart Pointer (Part 1)
104. Box Smart Pointer (Part 2)
105. Practice on Box Smart Pointer
106. Rc Smart Pointer
107. Practice on Rc Smart Pointer
108. RefCell Smart Pointer
109. Practice on RefCell Smart Pointer
110. Extra - Example of RefCell
111. Let's Test Your Knowledge
112. Implementing Typical Data Structures
113. Singly Linked List (Part 1)
114. Singly Linked List (Part 2)
115. Practice on Singly Linked List
116. Doubly Linked List (Part 1)
117. Doubly Linked List (Part 2)
118. Practice on Doubly Linked List
119. Extra - Reference Cycles Creating Memory Leakage
120. Let's us Test Your Knowledge
121. Useful Patterns for Handling Structs
122. Initializing Struct Instances
123. Builder Pattern
124. Simplifying Structs
125. Part 3: ---- Advance Concepts of the Language ----
126. Code Files Used in the Section
127. Understanding Size in Rust
128. Sized and Unsized Types
129. References to Unsized Types
130. Sized and Optionaly Sized Traits
131. Optionaly Sized and Generic Parameters
132. Unsized Coercion
133. Zero Sized Never Type
134. Zero Sized Unit Type
135. Zero Sized Unit Structs
136. Zero Sized Phantom Data
137. Concurrency
138. Thread Basics
139. Practice on Threads
140. Ownership in Threads
141. Practice on Ownership in Threads
142. Message Passing Through Channels (Part 1)
143. Message Passing Through Channels (Part 2)
144. Practice on Message Passing
145. Sharing States (Part 1)
146. Sharing States (Part 2)
147. Synchronization Through Barriers
148. Scoped Threads
149. Thread Parking
150. Async Await
151. Tokio Tasks
152. Practice on Async Await
153. Extra: Web Scrapping using Threads
154. Macros
155. A note on material after this point
156. Macros Basic
157. Capturing Types
158. Repeating Patterns
159. Practice on Macros
160. Extra: Question Mark Operator
161. Lets Test Your Knowledge
162. Real Life Problems with Data Structure Heavy Solutions
163. Search Results with Word Groupings Using HashMaps and Nested Loops
164. Product Popularity using HashMaps
165. Highest Stock Price Using MaxStack and Structures
166. Finding and Employee with No Meeting Using Multidimensional Arrays
167. Longest Non-Stop Working Employee Using HashSets
168. Items Suggestions Using HastSets and Vectors
169. Items in Ranges Using Binary Search Tree(Part 1)
170. Items in Ranges Using Binary Search Tree (Part 2)
171. Fetching Top Products
172. Effective Storage and Retrieval Using Trie Data Structure
173. Most Recently Used Product using Doubly LinkList and Hashmaps (Part 1)
174. Most Recently Used Product using Doubly LinkList and Hashmaps (Part 2)
175. Displaying Participants in an Online Meeting (Part 1)
176. Displaying Participants in an Online Meeting (Part 2)
177. Part 4: ---- Extra Material ----
178. Introduction to the Section
179. Web Programming
180. Web Programming Basics
181. Making Responses
182. Multiple Requests Using thread
183. Text Processing, File and Directory Handling
184. Basic File Handling
185. Directory and Path Related Functions
186. Regular Expressions Basics
187. Repeititions Quantifiers and Capturing Groups
188. String Literals
189. String Concatenation and Ownership
190. Miscellaneous Topics
191. Function Inputs and Coercion
192. Efficient Programming Tips
193. Todo Macro and Some Useful Extentions
194. Performance Lints
195. Part 5: ---- Legacy Material in the Course ----
196. Introduction to the Section
197. Extra Programming Practice (Optional)
198. Implementing Stack
199. String Reversal Using Stacks
200. Expression Evaluation (Infix to PostFix Illustration)

Join Nathan Stocks for a fast-paced, entertaining, and curiously informative hands-on crash course in the Rust programming language.

This course will provide you with the fundamentals you need to boost you up Rust's steep learning curve.  This is a hands-on course with targeted exercises for each subject and projects for you to use your combined knowledge.  From using cargo to creating a project, to writing your code, to compiling and running it, this course has everything you need to get started. This course is kept up-to-date when Rust is updated with new features or major editions.

Rust is a systems programming language that eliminates entire classes of bugs and security vulnerabilities, has zero-cost abstractions like C and C++, is fun to program in, and lets systems programmers have nice things. No wonder Rust is gaining traction in spaces as diverse as game engines, high-performance computing, embedded devices, and web programming! Learn how to write high-performance code without the worry of crashes or security vulnerabilities. Join a vibrant community of developers where diversity, inclusion, and just plain being nice are all first-class objectives.

This course is the first in the Ultimate Rust series. If you like this course, then you'll love Ultimate Rust 2: Intermediate Concepts afterwards!

1. Introduction
2. Introduction
3. Exercises Overview
4. Fundamentals
5. Cargo
6. Variables
7. Scope
8. Memory Safety
9. Exercise A - Variables
10. Functions
11. Exercise B - Functions
12. Module System
13. Primitive Types & Control Flow
14. Scalar Types
15. Compound Types
16. Exercise C - Simple Types
17. Control Flow
18. Strings
19. Exercise D - Control Flow & Strings
20. The Heart of Rust
21. Ownership
22. References & Borrowing
23. Exercise E - Ownership & References
24. The Meat of Rust
25. Structs
26. Traits
27. Exercise F - Structs & Traits
28. Collections
29. Enums
30. Exercise G - Collections & Enums
31. Final Lectures
32. Closures
33. Threads
34. Exercise H - Closures & Threads
35. Project - Invaders
36. Invaders Part 1 - Setup Audio
37. Invaders Part 2 - Rendering & Multithreading
38. Invaders Part 3 - The Player
39. Invaders Part 4 - Shooting
40. Invaders Part 5 - Invaders
41. Invaders Part 6 - Winning & Losing
42. Final Words
43. Thank You!

Welcome to the biggest and most comprehensive Rust programming language course on Udemy!

With 17.5 hours of content already, this hands-on practical course is frequently updated to make sure you master all the skills you need to become a Rust expert in the quickest, clearest manner possible.

Stuffed full with practical challenges and exercises, the first half of the course introduces you to the basics of Rust and getting you comfortable and confident with Rust. The second half of the course focuses on data structures and algorithms, looking at which data structures you can use, as well as how to use them! You'll also learn to analyse algorithms for space and time resource consumption... and a lot more!

Why learn Rust?

Rust is the most loved programming language by developers over the past few years according to numerous developer surveys. The Rust programming language is a highly sought after skill and is also one of the best paying skills in the industry.

In the US, Rust developers earn an average of 140k - 250k USD per annum (2022).

What do YOU want to do with Rust?! Developers can (and do!) use Rust to build game engines, file systems, websites and tools, operating systems, browser components, and a whole lot more.

Rust does not sacrifice speed for memory management like many languages do, but Rust ensures memory safety unlike languages like C/C++. Rust's compiler is going to handle a lot of the checking for you to ensure there are no undefined behaviors, dangling pointers, double-frees, etc.

Why THIS course?

This is a fast paced course that is designed to give you everything you need to learn in a clear, but very concise manner. There is no fluff involved. I want to give you the skills you need as quickly as possible to allow you to immediately begin developing high quality software using Rust.

As well as practical projects, nearly every section of the course has a dedicated student assignment to complete! Each assignments tests your new skills and helps give you the confidence to tackle your own projects going forward!

In this course I will cover:

• Common programming concepts (fundamental types, functions, control flow)

• Ownership and moves

• References

• Structs

• Enums and Patterns

• Error Handling

• Crates and Modules

• Traits and Generics

• Iterators

• Collections

• Concurrency

• Webassembly

• And much, much more!

By the end of this course you will have started at the basics of programming and journeyed all the way to becoming an expert in Rust!

What are you waiting for? Dive in to Rust today! 

1. Installing Rust
2. Welcome to the Course!
3. Course Structure
4. Installation Update
5. Windows 10 Installation
6. Linux and MacOS Installation
7. *Read Experienced Programmers*
8. The Basics
9. About This Section
10. Quick Note
11. Hello, World!
12. More about Visual Studio Code
13. Variables and Mutability
14. Scalar Data Types
15. Tuples
16. Arrays
17. Vectors
18. Slices
19. Strings and &str
20. String Literals
21. Functions
22. Control Flow
23. Wrap Up
24. Section 2 Quiz
25. Section 2 Assignment
26. Section 2 Assignment - Solution
27. Rust Principles
28. About this Section
29. Ownership
30. Move
31. Clone
32. Copy
33. More Moves
34. References and Borrowing
35. Section 3 Quiz
36. Section 3 Assignment
37. Section 3 Assignment - Solution
38. Structs and Lifetimes
39. About this Section
40. Structs
41. Methods
42. Lifetimes
43. Lifetimes in Structs
44. Static Lifetime
45. Section 4 Quiz
46. Section 4 Assignment
47. Section 4 Assignment - Solution
48. Enums and Pattern Matching
49. About this Section
50. Enums
51. Option
52. Match
53. If Let
54. More Matches
55. Section 5 Quiz
56. Section 5 Assignment
57. Section 5 Assignment - Solution
58. Traits and Generics
59. About this Section
60. Generics
61. Traits
62. Traits as Parameters
63. Drop
64. Clone
65. Copy
66. From and Into
67. Operator Overloading
68. Section 6 Quiz
69. Section 6 Assignment
70. Section 6 Assignment - Solution
71. Cargo, Crates, and Modules
72. Cargo, Crates, and Packages
73. Modules
74. Common Collections
75. About this Section
76. Vectors
77. Binary Heap
78. Maps
79. Sets
80. Error Handing
81. About this Section
82. Panic!
83. Result
84. Catching Errors
85. Error Propagation
86. Testing
87. About this Section
88. Test Setup
89. Assertations
90. Find and Replace CLI Program
91. About this Section
92. Setup
93. Handling Arguments
94. Separating Code
95. Accessing Files
96. Replacing Text
97. Iterators and Closures
98. About this Section
99. Closures
100. Type Annotation and Performance
101. Fn Traits
102. Iterators
103. Section 12 Quiz
104. Section 12 Assignment
105. Section 12 Assignment - Solution
106. Pointers
107. About this Section
108. Box and Dereferencing
109. Rc and Arc
110. RefCell
111. Section 13 Quiz
112. Section 13 Assignment
113. Section 13 Assignment - Solution
114. Concurrency
115. About this Section
116. Spawn and Join
117. Channels
118. Send and Sync
119. Shared State
120. Mutex Poisoning
121. Rayon
122. Section 14 Quiz
123. Section 14 Assignment
124. Section 14 Assignment - Solution
125. Macros
126. About this Section
127. Macros
128. Procedural Macros
129. Declarative Macros
130. Section 15 Assignment
131. Section 15 Assignment - Solution
132. Unsafe Code
133. About this Section
134. Unsafe Code
135. Asynchronous Rust
136. About This Section
137. Future, Async, and Await
138. Tasks
139. Setting up our Project
140. The Client
141. Server
142. Wrap Up
143. Section 17 Quiz
144. Webassembly
145. Introduction to Webassembly
146. Assignment One
147. WASM Project Part 1
148. WASM Project Part 2
149. WASM Project Part 3
150. Big-O
151. Experimental
152. Theoretical
153. Recursion
154. Factorial Introduction
155. Factorial Implementation
156. Fibonacci Introduction
157. Fibonacci Solution
158. Palindrome
159. Tower of Hanoi
160. Assignment
161. Assignment Solution
162. Sorting
163. Selection Sort Introduction
164. Selection Sort Implementation
165. Bubble Sort Introduction
166. Bubble Sort Implementation
167. Merge Sort Introduction
168. Merge Sort Implementation
169. Quick Sort Introduction
170. Quick Sort Implementation
171. Linked List
172. Linked List Introduction
173. Setting Up Linked List
174. Linked List Methods
175. Drop
176. Linked List Tests
177. Peek and PeekMut
178. Iterators
179. IterMut Assignment
180. IterMut Solution
181. Stack and Queue
182. Stack
183. Queue Introduction
184. Queue Implementation
185. Queue Testing
186. Binary Search Tree
187. BST Introduction
188. BST Implementation pt. 1
189. BST Implementation pt. 2
190. BST Implementation pt. 3
191. Assignment Solution
192. Dynamic Programming
193. DP Introduction
194. LCS Introduction
195. LCS Implementation
196. Maximum Subarray Assignment
197. Maximum Subarray Solution
198. Graphs
199. Graphs Introduction
200. Graph Implementation

println!("### Our new Rust course, designed for beginners, covers ###");

println!("### % fundamental to advanced topics % ###");

println!("### to build a strong foundation. ###");

Update #5 and #6

1. Iterators: Trait 'Iterator', Trait 'IntoIterator',

2. Creating custom iterator

3. Implementing Trait 'IntoIterator' on a custom type

Update #4

1. Traits: trait objects, virtual table, boxing DST, memory layout

2. Closures: as struct member fields, memory layout

Update #3

1. Closures: introduction, syntax

2. Closures capturing environment, traits associated with closures(Fn, FnMut, FnOnce)

3. Passing closures as function arguments

Update #2

1. Traits: introduction, methods

2. Associated types of a trait

3. Implementing custom Display trait

4. Trait bounds

Update #1

1. Generics: syntax, functions, structs, enums

2. Lifetimes: scope, annotations, elision rules

3. Lifetime annotations: structs, methods

4. Const. and static variables

   
   

Do you want to learn a new programming language?

How about The Rust Programming Language?

Rust is becoming increasingly popular in system-level programming due to its memory safety and performance. It stands as a strong competitor to C++ and is perfect for those looking to elevate their system-level programming skills. Whether you are a beginner or an experienced programmer, Rust offers a modern and powerful toolset for your development needs.

Learning Rust opens doors to high-performance, safe, and reliable system-level programming

2023 Stack Overflow Developer Survey findings indicate that,

"Rust is the most admired language, more than 80% of developers that use it want to use it again next year."

"More respondents want to continue using Cargo(Rust's official package manager) next year than the top competitors."

Why should you consider learning Rust?

There are many answers, but here are the important ones.

* Memory safety without garbage collection

* Better concurrency without data races 

* Safe and unsafe code

* Performance friendly abstractions

* Rust is designed to be as fast as C and C++

* Awesome Tools and Ecosystem (Cargo (the package manager and build system), rustfmt (code formatting), clippy (linting), and a comprehensive standard library.)

* Built-in testing support

* Support for key Object-oriented programming principles

Why should you consider our course?

Our course is designed with beginners in mind. We use text, images, graphics, and animations to concisely demonstrate many intriguing concepts of Rust. This will build a solid foundation for you to understand the key concepts of the language. Also, we cover numerous small to large code snippets to demonstrate the concepts, allowing you to build complex programs.

Important Topics covered so far in the course

1.  Variables  and primitive data types

2.  Ownership and Borrow 

3. Copy and Move semantics

4. Tuples and Pattern matching

5. Decision-making and Loops

6. Structs and  Pattern matching

7. Enums and Pattern matching

8.  Struct/Enum Methods and associated functions

9. Slices

10. String, String slice and UTF encoding

11. Lifetimes

12. Traits

13. Generics

14. Closures

12. More topics to come(Iterators, multi-thread , smart pointers, etc ). We constantly update this course to ensure you have the latest knowledge and skills

Hardware/Software Requirements

1. Windows/MAC/Ubuntu machine with Microsoft VS Code IDE installed

Note:

This course focuses on general Rust programming and does not specifically discuss no_std scenarios commonly used for embedded systems.

1. Introduction
2. Introduction
3. How Rust is different from other programming languages? Immutability
4. Course repository
5. Borrowing
6. Rust automatically deallocates heap memory
7. Features related to type inference,ownership,error handling,and dangling pointer
8. Create, Build, Run a Rust program
9. Prints
10. Print related macros in Rust
11. format!() and named place holders
12. Exercise-diy-1
13. Useful cargo tools
14. Printing in hex and binary formats
15. Exercise-diy-2
16. Exercise-diy-3
17. r and r# tagging of strings
18. Variables and Data types
19. Variables, mutability and data types explanation
20. 'as' keyword and storing ASCII values
21. char data type
22. Exercise-diy-4
23. Array and array iteration
24. Exercise-diy-5
25. Arithmetic operators and short hand notations
26. Writing a Function in Rust
27. Testing
28. Unit testing
29. Writing test cases
30. Standard library assert macros
31. Writing test cases contd.
32. Can you help us?
33. References
34. References
35. Borrow, Borrower and Referent
36. slice data type
37. Std. library functions of the slice data type
38. Decision making
39. Using if..else as statements and expressions
40. The 'match' statement
41. Using if..else if..else and if let..else if let…else
42. comparision and logical operators
43. Bitwise operators
44. Exercise-diy-6
45. Exercise-diy-6.2
46. Strings
47. Strings in Rust
48. Strings and UTF-8 format
49. Slice of a String
50. Converting String to Slice and vice versa
51. String concatination
52. String Indexing
53. Exercise-diy-7-Part-1
54. Exercise-diy-7-Part-2
55. Exercise-diy-7-Part-3
56. Ownership
57. Ownership, Move, and Copy semantics
58. Call by value and Call by reference
59. Loops
60. Loop statements in Rust
61. Different ways of Iteration using for..in loop
62. Solution
63. while and while let loops
64. Exercise-diy-8
65. Tuples
66. Tuple datatype
67. Pattern matching with tuples
68. Tuple matching and Move
69. ref keyword
70. Exercise-diy-9
71. Exercise-diy-10
72. Structure
73. Creating and Initializing a struct
74. Is struct 'move' or 'copy'?
75. Struct and Default trait
76. Tuple struct and Unit struct
77. Writing Struct methods
78. Associated function as Constructor of a Struct
79. Pattern matching with Struct
80. ref and @ usage in pattern matching with Struct
81. Enums
82. Defining an Enum in Rust
83. Methods and associated functions of an Enum
84. Pattern matching using Enums
85. Option type
86. Option Usage
87. Vectors
88. Introduction to Vectors
89. Vectors under the hood
90. Vector indexing
91. Slice of a vector
92. Vector methods: push(), pop(), shrink_to_fit()
93. Exercise-diy-11
94. Vector methods: drain(), extract_if()
95. Vector methods: retain(), retain_mut()
96. Vector methods: split() and friends
97. Vector methods: splice(), append(), extend()
98. Vector methods: prepend using index() and splice()
99. VecDeque
100. HashMap
101. HashMap and its methods part-1
102. HashMap and its methods part-2
103. Error Handling
104. Enum Result
105. Error handling using Result enum
106. Exercise on Result
107. Error propagation operator ( ? )
108. Converting Option to Result type
109. unwrap() and expect() methods
110. unwrap_err()
111. Std. Library error types
112. Handling std::io::Error
113. Numeric Errors : Exercise
114. Numeric Errors : Exercise contd
115. Exercise on error conversion
116. Exercise on error conversion contd.
117. map_err() usage
118. Auto conversion of errors
119. Exercise-diy-12
120. Can you help us?
121. Generics
122. Generics syntax and Writing generic functions
123. Function with multiple generic type parameters
124. Generic structs and Enums
125. Exercise-diy-13
126. Lifetimes
127. Lifetime and scope
128. Lifetime annotations example
129. Lifetime elision rules
130. Lifetime annotations with structs
131. Lifetime annotations with structs contd.
132. Lifetime annotations with struct methods
133. Const. and Static
134. Const. and Static variables
135. Traits
136. Introduction to Trait and Trait methods
137. Associated types of a Trait
138. Exercise: Implementing Display trait for user defined structure part-1
139. Exercise: Implementing Display trait for user defined structure part-2
140. Exercise: Implementing Display trait for user defined structure part-3
141. Trait bounds
142. Trait objects and Virtual table
143. Boxing the DST
144. Memory layout of Box
145. Closures
146. Introduction to Closures and Syntax
147. Closure capturing environment
148. Traits associated with closures
149. Behaviour of closure variables
150. Passing closure as arguments to a function part-1
151. Passing closure as arguments to a function part-2
152. Closures as Struct member fields[Using Trait Object]
153. Memory layout of the program
154. Types of Closures
155. Exercise on Closure
156. Closures as Struct member fields[Using Generics]
157. Closures and event handling
158. Iterators
159. Introduction to Iterators
160. About Trait 'Iterator'
161. Creating a custom iterator
162. Iterating over custom iterator by value, mutable and immutable borrow
163. Creating a custom iterator: Refactoring 'next' method
164. Trait 'Iterator' Vs Trait 'IntoIterator'
165. Exercise: Implementing a custom iterator
166. Solution: Implementing a custom iterator
167. Implementing Trait 'IntoIterator' for a custom type Part-1
168. Implementing Trait 'IntoIterator' for a custom type Part-2
169. Implementing Trait 'IntoIterator' for a custom type Part-3
170. Implementing Trait 'IntoIterator' for a custom type Part-4-Solution
171. Iterator Methods
172. for_each() as an alternate to for loop
173. iter(), iter_mut() and into_iter() explanation
174. Commonly used iterator adapters
175. map() method explanation with examples
176. collect()
177. Using collect() with custom collection
178. Implementing Trait 'FromIterator' on a type
179. filter()
180. Structuring Code in Rust:
181. package, crate, cargo.toml , cargo.lock
182. [package] section of cargo.toml, Semantic Versioning