Top 8 Recommended Rust Self-Study Materials! [December 2023]

Develop a an automated ChatGPT agent which not only writes code, but tests and re-write code for you. In fact, you can request your agent to do just about anything.

By going through this course, you will not only learn and master Rust from A-Z, but you will also have extensive knowledge in how to build your very own AutoGPT.

The name of the AutoGPT we build together will be Auto-Gippity.

Auto-Gippity will simply be given a task, which it will break down and delegate to other agents to complete. Each agent will be responsible for testing its own output.

Our test piece will be to build an agent that writes a web server given a template. It will write the code in Rust. Not only that, but we will write the agent, that writes Rust code...in Rust. Fantastic. What a time to be a developer.

AutoGPTs will only continue to become extremely relevant and highly sought after and combining these with the worlds favourite programming language, Rust, means that we can build an application which is blazingly fast, memory-safe, modern and robust.

Right now, there is a window of opportunity to learn this fantastic and uncommon technology before it takes over in software engineering.

Just think, you could build an AutoGPT that say, develops full stack SAAS websites end-to-end. With technologies like GPT-4 and soon beyond, such agents will only continue to improve in their performance.

Companies are looking for developers who can build such tools and SAAS startups have a window to be first. If you are curious as to how you can connect new AI technologies to change the world then THIS is the course for you.

You will learn:

• How to work with the Open AI API and the GPT-4 API using Rust

• How to master rust from A to Z, progressing from beginner, to intermediate, to advanced and beyond

• How to build AI functions (special functions that extract a desired response from large-language-models)

• How to develop a web server template (including an introduction to web servers) using Actix Web

• How to build an Automated GPT agent (Auto-Gippity) which writes code, that executes and tests code. If the code is wrong, it will simply re-write it and test again

  
  

We are truly excited to see what you develop, so make sure you share your application with the world.

See you in class!

Shaun

1. Introduction
2. What We Are Building
3. Programming Experience Required
4. About Your Instructor
5. Discord and Q&A
6. Getting Access to GPT-4
7. AI Functions and LLM Limitations
8. Course Structure Overview
9. IMPORTANT: RESOURCES
10. Rust Crash Course - Learning the Rust Environment
11. Rust installation - Quick Walkthrough
12. Rust Installation - Windows Docs
13. About Rustup
14. Rustup Tool Manager Docs
15. Preparing Visual Studio Code
16. Cargo New - Your First Rust Project
17. Your First Rust Function
18. A Brief Programming Language Comparison
19. Structuring Project Modules - Brief Introduction
20. Unit Testing with Cargo
21. Create Docs with Cargo
22. Creating a Rust Library
23. Dead Code and Unused Variables
24. Rust Crash Course - Types and Memory Management
25. Must-Know Resources
26. Rust vs Other Languages Revisited
27. Integer Types
28. Data Type Cheatsheet
29. Stack vs Heap Intro
30. Stack Deep Dive
31. Stack vs Heap Walkthrough
32. String Literals and Static (Read-Only) Memory
33. Ownership and Borrowing - Immutable References
34. Ownership and Borrowing - Mutable References
35. Ownership and Borrowing - Dereferencing
36. About Scope
37. Memory Management
38. Rust Crash Course - Basics
39. Intro - Create Project
40. Fixed Size Variables
41. Dynamic Sized Variables
42. Basic Collections
43. Closures
44. Number Literals and Raw Strings
45. Working Low Level with Binary
46. Rust Std Library
47. Rust Crash Course - Intermediate
48. Intro - Create Module
49. Enums - Your First Enum
50. Enums - Result Enum with Generics Introduction
51. Enums - Option Enum with Some or None
52. Rusts Result and Option
53. Structs - Your First Struct
54. Structs - Using Type Impl
55. Traits Introduction
56. Polymorphism with Traits and Generics
57. Lifetimes - Introduction
58. Lifetimes - Generics and Structs
59. Pattern Matching - Integer, Option and Result
60. Pattern Matching - Mixed Data Enum
61. Pattern Matching - Match Guards and Structs
62. Your First Async API Call
63. Handling Errors
64. Collections Revisited - HashMaps and HashSets
65. Project Cleanup
66. Rust Crash Course - Advanced
67. Declarative Macros - Introduction
68. Declarative Macros - With Repetitions
69. Declarative Macros - Note on Module Exporting
70. Procedural Macros (Theory) - Introduction to Derive
71. Procedural Macros (Theory) - Function Like Macro
72. Procedural Macros (Theory) - Attribute Like Macro
73. Procedural Macros (Practice) - Building an AI Function
74. Smart Pointers - Box
75. Smart Pointers - Reference Counting with RefCell
76. Smart Pointers - Reference Counting with Weak
77. Rust Concurrency with Mutex and Arc
78. Publish Packages to Crates
79. Build Web Server Template - First Project
80. Theory - Introduction to Web Servers and Actix Web
81. Theory - Actix Web REST API Docs Walkthrough
82. Project Setup
83. Struct Definitions
84. Database Implementation
85. Creating AppState with Mutex Provided Safety
86. Writing Our Initial Web Server
87. Testing Create Task Rest API Endpoint With Postman
88. Create and Test GET Task Request
89. Complete Task CRUD
90. User Registration and Login
91. Mutation Adjustment
92. Next Steps
93. Auto GPT Project - Supporting Functions
94. Supporting Functions - Section Introduction
95. Project Setup
96. User Interaction with Command Line
97. Extract API Keys
98. OpenAI Call - Key Provisions
99. OpenAI Call - Create Client
100. OpenAI Call - Test API Call
101. OpenAI Call - Error Handling
102. OpenAI Call - Completion
103. Extract AI Functions
104. Extend AI Function
105. Print Agent Activity to Command Line
106. AI Task Function
107. AI Task Function Decoded
108. API Endpoint Valid Check Function
109. File Read and Write Functions
110. Auto GPT Project - Create Agents
111. Create Agents - Section Introduction
112. Basic Agent - Create Basic Agent
113. Managing Agent - FactSheet Struct
114. Managing Agent - Special Functions Trait
115. Solutions Architect - Call Project Scope
116. Solutions Architect - Call External Urls
117. Solutions Architect - Handle Discovery State
118. Solutions Architect - Write Test for Checking Urls
119. Solutions Agent - Full Agent Test
120. Managing Agent - Create New
121. Managing Agent - Execute Project Fn
122. Managing Agent - Initial Agent Test
123. Backend Developer - Write and Improve Code Fn
124. Backend Developer - Fix Code Bugs Fn
125. Backend Developer - Rest API Endpoints Fn
126. Backend Developer - Discovery and Working States
127. Backend Developer - Initial Agent Test
128. Backend Developer - Ensure AI Safety Human Check
129. Backend Developer - Write Automated Cargo Build
130. Backend Developer - Write Automated Cargo Run
131. Backend Developer - Write Automated Endpoint Testing
132. Backend Developer - Unit Testing Agents Unit Tests
133. Backend Developer - Testing Code Rewrites
134. Auto GPT Project - Finalise Agent Gippity
135. Performing First Complete Agent Test (External Url Based)
136. Performing First Test - Human Review
137. Performing Second Test (Tracking CRUD Based)
138. Performing Third Test (Hangman Game Build)
139. Performing Third Test - Human Review
140. Paper - Large Language Models as Tool Makers (Optional)
141. Further Reading (Optional)
142. Considerations on Overcoming Limitations
143. Next Steps

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!

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, testing and advance topics in Trait, Types and Memory Allocations

• 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

• Concurrency and Aysnc Programming

• Textual Processing and Directory Handling

• Blockchain in RUST

• Webprogramming in rust

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 the my course.

"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. Introductory Stuff and Course Resources
2. Course introduction
3. Installing Rust and Web-based Enviroment for Executing Programs
4. Running and Compiling your First Program
5. Tell us About the Course
6. Download all the Codes for the Course
7. Links to Useful Books on Rust
8. Quick Reference Material
9. ---- Part 1: Basic Programming with Rust ----
10. Introduction to the Section
11. Data Types
12. Variables and Constants
13. Practice on Variables
14. Primitive Data Types
15. Compound Data Types
16. Practice on Data Types
17. Functions and Code Blocks
18. Practice on Functions
19. Conditionals
20. Control Flow
21. Practice on Conditionals and Control Flow
22. Practice Exercise on Control Flow and Conditionals
23. Bonus - Comments, Prints Commands, Input
24. Test Your Knowledge
25. Ownership
26. Ownership Basics
27. Ownership in Functions
28. Practice on Ownership
29. Borrowing Basics
30. Borrowing in Functions
31. Dereferencing
32. Practice Exercise on Ownership
33. Practice on Borrowing
34. Let's Test Your Knowledge
35. Custom and Library Provided Useful Type
36. Structs Basics
37. Adding Functionality to Structs
38. Enums
39. Practive on Enums
40. Option
41. Practice on Option
42. Result
43. Practice on Result
44. BONUS: HashMaps
45. Practice on HashMaps
46. Let's have Some Practice
47. Let's Test Your Knowledge
48. Organizing your Code
49. Code Organization
50. Modules Basics
51. Visualizing and Organizing Modules
52. Re-exporting and Privacy
53. Practice on Modules
54. Using External Dependencies
55. Publishing your Crate
56. Let's Test Your Knowledge
57. Testing Code
58. Unit Testing (Basics)
59. Unit Testing (Testing Panics)
60. Controlling Tests Execution
61. Practice on Testing
62. Integration Tests
63. BONUS: Benchmark Testing
64. ---- Part 2: Intermediate Level Concepts ----
65. Introduction to the section
66. Iterators, Lifetimes and Closures
67. Lifetimes (Part 1)
68. Lifetimes (Part 2)
69. Closures (Part 1)
70. Closures (Part 2)
71. Function Types
72. Iterators (Part 1)
73. Iteartors (Part 2)
74. Let's have Some Practice
75. Let's Test Your Knowledge
76. Data Structures and Smart Pointers
77. Basics of Smart Pointers
78. Box Smart Pointers and Its Uses
79. Refining Cons List and Custom Defined Smart Pointers
80. Singly Link List (Part 1)
81. Singly Link List (Part 2)
82. Generics and Deref Coercion in Smart Pointers
83. Rc Smart pointer
84. RefCell Smart Pointer
85. Doubly Link List (Part 1)
86. Doubly Link List (Part 2)
87. Reference Cycles Creating Memory Leakage
88. Let's us Test Your Knowledge
89. Let's have Some Practive
90. Macros, Testing, Question Mark, Partial Move
91. Macros Basic
92. Capturing Types
93. Repeating Patterns
94. Practice on Macros
95. As_ref and Partial Move in Option
96. Take and Swap for Avoiding Allocations
97. Question Mark Operator
98. Testing Your Code (Part 1)
99. Testing your Code (Part 2)
100. Lets Test Your Knowledge
101. Real Life Problems with Data Structure Heavy Solutions
102. Search Results with Word Groupings Using HashMaps and Nested Loops
103. Product Popularity using HashMaps
104. Highest Stock Price Using MaxStack and Structures
105. Finding and Employee with No Meeting Using Multidimensional Arrays
106. Longest Non-Stop Working Employee Using HashSets
107. Items Suggestions Using HastSets and Vectors
108. Items in Ranges Using Binary Search Tree(Part 1)
109. Items in Ranges Using Binary Search Tree (Part 2)
110. Fetching Top Products
111. Effective Storage and Retrieval Using Trie Data Structure
112. Most Recently Used Product using Doubly LinkList and Hashmaps (Part 1)
113. Most Recently Used Product using Doubly LinkList and Hashmaps (Part 2)
114. Dsiplaying Participants in an Online Meeting (Part 1)
115. Dsiplaying Participants in an Online Meeting (Part 2)
116. Deep Dive into the Trait System
117. Trait Bounds
118. Associated Types
119. Trait Items
120. Scope of a Trait, Marker and Super Traits
121. Some Useful Traits
122. Static Versus Dynamic Dispatch (Trait Objects)
123. Let's have Some Practice
124. Advance Structs: Initialization, Mutability, Simplification and Builder Pattern
125. Initializing Struct Instances
126. Disabling Mutability for Finalized Struct Objects
127. Simplifying Structures
128. The Builder Pattern for Struct Objects
129. Concurrency
130. Thread Basics
131. Multiple Thread and Ownership
132. Communication Through Channels
133. Multiple Producers, Threads and Functions
134. Sharing States
135. Passes Mutexes Between Threads
136. Synchronization Through Barriers
137. Project: Web Scrapping using Threads
138. Scoped Threads
139. Thread Parking, Yielding
140. Async Await (Part 1)
141. Async Await (Part 2: Tasks and Select)
142. Measuring and Improving Performance
143. Performance Lints
144. Web Programming
145. Web Programming Basics
146. Making Responces
147. Multiple Requests Using thread
148. Implementing Simple BlockChain Features in Rust
149. Blockchain Theory (Part 1: Hashes)
150. Blockchain Theory (Part 2: Blocks and Blockchain)
151. Bockchain in Rust (Part 1: Basic Structures and Functions)
152. Bockchain in Rust (Part 2: Chain Validation and Selection)
153. Text Processing, File and Directory Handling
154. Basic File Handling
155. Directory and Path Related Functions
156. Regular Expressions Basics
157. Repeititions Quantifiers and Capturing Groups
158. String Literals
159. String Concatenation and Ownership
160. Miscellaneous Topics
161. Function Inputs and Coercion
162. Iterating Through Option
163. Efficient Programming Tips
164. Todo Macro and Some Useful Extentions
165. Extra Programming Practice (Optional)
166. Implementing Stack
167. String Reversal Using Stacks
168. Expression Evaluation (Infix to PostFix Illustration)
169. Expression Evaluation (Postfix Evaluation)
170. Expression Evaluation - Part 1
171. Expression Evaluation - Part 2
172. Implementing Postfix Evaluation

Join Nathan Stocks for a fast-paced, entertaining, curiously-informative, hands-on even deeper dive into the Rust programming language. This is the second course in the Ultimate Rust series following the Ultimate Rust Crash Course. If you like that course, you'll love this one!

This is a hands-on course! Not only are there targeted exercise for each topic discussed, there are also a series of project scenarios that walk you through using what you've learned to put together playable game prototypes that work on macOS, Linux, and Windows!  These projects will make use of Rusty Engine, a game engine developed specifically for this course to keep game engine concepts to a minimum so you can focus on using exactly what you learned in this course.

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.

1. Introduction
2. Introduction
3. Exercises Overview
4. Lectures & Exercises
5. Idiomatic Code
6. Exercise - Idiomatic Code
7. Documentation
8. Exercise - Documentation
9. Publishing
10. Exercise - Publishing
11. Closures
12. Iterators
13. Exercise - Closures & Iterators
14. Common Traits
15. Exercise - Traits
16. Creating Errors
17. Handling Errors
18. Exercise - Errors
19. Unit Tests
20. Integration Tests
21. Benchmarks
22. Exercise - Testing
23. Logging
24. Exercise - Logging
25. Multithreading
26. Channels
27. Exercise - Threads & Channels
28. Project: Game Prototype with Rusty Engine
29. Project Overview
30. Tutorial: Configuration
31. Tutorial: Engine Initialization
32. Tutorial: Game State
33. Tutorial: Game Logic Function
34. Tutorial: Sprites
35. Tutorial: Colliders
36. Tutorial: Keyboard Input
37. Tutorial: Mouse Input
38. Tutorial: Text
39. Tutorial: Audio
40. Tutorial: Timer
41. Tutorial: Engine & Game Structs
42. Game Walkthrough: Common Setup
43. Game Walkthrough: Road Race

You have probably heard of the Rust Programming Language - a modern systems language that is blazingly fast, guarantees memory safety without the use of a garbage collector and most importantly is fun to write. It has a great community and excellent tooling. These are just some of the reasons why Rust was voted the most loved programming language for five years in a row. Rust is the proof that systems programmers can have nice things.

In this course you will learn the fundamentals of Rust. The format will be a bit different than most other courses. Instead of jumping between unrelated concepts in every video and showing examples that have nothing to do with the real world use of the language, we will learn entirely through practice.

Together we will build real Rust applications and introduce new concepts when we need them to solve actual problems.

To start there will be a short theoretical section on low level memory management.

Then to introduce the basics of Rust we will build a simple command line application. This will provide us with the necessary knowledge to tackle a much larger project.

For our big project we will build a working HTTP server from scratch. We will write our custom implementation of the HTTP protocol and we will build a functioning web server with it. This will let us introduce all of the fundamental and some advanced features of the Rust language.

1. Getting Started
2. Course Introduction
3. What is Rust
4. Installing Rust
5. Setting Up the Development Environment
6. Cargo
7. Manual Memory Management
8. Code for this section
9. Introduction
10. The Stack
11. The Heap
12. Smart Pointers
13. Explore the Memory Layout in GDB
14. Memory Management
15. Building a Command Line Application
16. Code for this section
17. Introduction
18. Basic Data Types
19. Functions
20. Macros
21. Mutability
22. The Standard Library
23. Ownership
24. References and Borrowing
25. Explore the Ownership and Borrowing in GDB
26. Finishing Touches
27. Rust Basics
28. Building a HTTP Server From Scratch
29. Code for this section
30. Introduction
31. The HTTP Protocol and the Architecture of Our Server
32. Structs
33. Strings
34. Enums
35. The Option Enum
36. Organising Our Code into Modules
37. Listening for TCP Connections
38. The Result Enum
39. Loops
40. Tuples
41. The Match Expression
42. Arrays
43. Logging the Incoming Requests to the Console
44. Traits and Type Conversions
45. Custom Errors
46. Advanced Error Handling
47. Iterating Over Strings
48. Converting an Option into a Result
49. Parsing Values From Strings
50. The "If Let" Expression
51. Lifetimes - Part 1
52. Lifetimes - Part 2
53. Lifetimes
54. Silencing Compiler Warnings
55. Representing the Query String Using a Hash Map - Part 1
56. Representing the Query String Using a Hash Map - Part 2
57. The Derive Attribute
58. Modelling the HTTP Response
59. Copy and Clone Types
60. Writing Data to a TCP Stream
61. Dynamic vs Static Dispatch
62. Custom Traits
63. Implementing Getters
64. Routing Incoming Requests
65. Working with Environment Variables
66. Serving HTML Files
67. Serving Arbitrary Files Securely
68. Final Quiz
69. Next Steps