Mastering Rust – Build Robust, Concurrent, and Fast Applications

Mastering Rust – Build Robust, Concurrent, and Fast Applications
Mastering Rust – Build Robust, Concurrent, and Fast Applications

English | MP4 | AVC 1920×1080 | AAC 48KHz 2ch | 1h 53m | 1.75 GB
eLearning | Skill level: All Levels

Discover Rust’s powerful but hidden features and build robust, concurrent, and fast applications

Developers love Rust as a programming language for various reasons. It’s safe and more secure than its contemporaries; it’s also good at maintaining performance. Rust uses a modern inbuilt dependency and build management system to provide concurrency.

This course will show you how to use these benefits of Rust to enhance your programming experience. You will understand how Rust improves performance and handles errors to make your code reliable. Also, you’ll test your programs and take your code to the next level with concurrency. The course demonstrates how you can build scalable and reliable programs with Rust.

By the end of the course, you will be able to build and implement high-performance software applications to fulfill your organization’s needs and requirements.


  • Get to know the different error handling philosophies and learn to use them wisely
  • Get to know how concurrency works in Rust and use concurrency primitives such as threads and message passing
  • Effectively leverage Rust’s memory safety guarantees
  • Create and work with structs, vectors, scalar types, functions, string, enums, and more
  • Share data in your application with mutex
  • Design Rust projects that grow and ensure as much correctness at compile time as possible
  • Ensure that no runtime cost is incurred during the execution of your Rust application
+ Table of Contents

Diving into Functions and Ownership
1 The Course Overview
2 Different Types of Functions
3 Creating Expressions
4 Strings and Scope with Strings
5 Working with Strings
6 Ownership of Strings in Functions
7 Programming a Calculator App

Understanding Compound Types
8 Creating and Working with Structs
9 Using Methods with Structs
10 Creating enums and Using Them in the Main Program
11 Creating and Working with Vectors

Working with Cargo and Modules
12 Introduction to Cargo
13 Modules and Structure of the Files
14 Using pub to Make Elements Public
15 Using Modules in Main Program
16 Practice Project with Modules

Handling Errors in Your Code
17 The Panic Functionality in Rust
18 Result and Working with Errors
19 Unwrapping, Expecting, and Outputting Custom Errors
20 Error Matching in Rust
21 Propagating an Error

Unit and Integration Testing
22 The Panic Functionality in Rust
23 Using assert() macro
24 Creating the Custom Error Messaging
25 Using should panic with Tests
26 Using macros – assert eq and assert ne
27 Unit and Integration Testing
28 Test Running with Terminal

Maintaining Concurrency in Rust
29 Understanding Threads and Handling Threads
30 Using move closure with Threads
31 Sending Messages Between Threads
32 Passing Channels to Function
33 Sending Multiple Values
34 Creating Multiple Producers
35 Mutex and Sharing Mutex with Multiple Threads