Description

This course is designed for beginners and covers a wide range of topics including syntax, data structures, modules, and advanced techniques such as testing and memory allocations. It also includes real-life problem-solving exercises to ensure hands-on learning. Gain efficient programming skills and be proficient in Rust with this course.

In the world of programming languages, there are often tradeoffs to consider. Low-level languages such as C and C++ offer speed and control, but at the cost of memory safety. High-level languages such as Python and JavaScript prioritize safety but are less efficient in terms of power and speed. Rust, however, offers the best of both worlds. You will begin with the basics of Rust programming, including its syntax and memory safety features. As you progress, you will develop an understanding of advanced-level concepts such as generics, traits, and more. The course provides hands-on experience in solving intermediate to advanced-level problems using Rust. The course covers a range of topics, including basic Rust programming syntax, Enums, structures, rust module system, the use of external crates and publishing crates, smart pointers, commonly used data structures, advanced techniques such as macros, testing, memory allocations, and more. You will also learn some real-life applications in Rust from scratch, and efficient programming skills. Furthermore, you will understand concurrency and async programming, textual processing, directory handling, blockchain, and web programming in Rust. By the end of this course, you will become fluent in Rust programming and confidently and professionally code in the language.

What You Will Learn

Use Rust syntax and collectors to write basic programs
Apply enums, traits, structures, generics, and more to create complex programs
Utilize advanced Rust techniques, such as macros and testing, for efficient programming
Apply Rust to create real-life applications such as blockchain and web programming
Handle options, strings, and structures in concurrent and asynchronous programs
Learn performance optimization techniques and benchmarking using Criterion

Audience

This course is designed for beginners who have no prior knowledge of Rust and who are interested in learning the language. However, the book also covers advanced concepts, making it suitable for individuals who want to develop their skills and expertise in Rust programming. It may be particularly useful for students, professionals, or hobbyists who are interested in system programming, blockchain development, or other related areas.

Approach

The learning approach of this course is focused on practical, hands-on experience. You will learn by doing, with practice exercises and real-life applications that will enable you to develop your skills and build your confidence. We start from the basics and build up to advanced-level concepts, with a focus on memory safety, efficient programming, and best practices.

Key Features

Learn a massive amount of Rust programming skills and techniques, from basic syntax to advanced concepts * Explore the latest advancements in Rust, including web programming basics, async-await, threads, and more * Develop an understanding of advance level concepts such as generics, traits, lifetimes, and closures

Github Repo

https://github.com/PacktPublishing/Rust-Programming-Master-Class-from-Beginner-to-Expert

Course Outline

1. Introduction

This section introduces Rust programming and covers the course learning objectives. We will set up our working environment and learn how to run a simple "Hello World" program.

1. Course Introduction

In this video, we will get acquainted with Rust programming and cover the course learning objectives.

2. Installing Rust and VS Code Editor

In this video, you will learn how to install Rust and the VS Code Editor. We will also take a look at a web-based environment for executing programs.

3. Running and Compiling Your First Program

In this video, we will cover some basics such as how to run, compile, and execute our first program.

2. Basic Programming

This section covers the fundamentals of Rust programming language from scratch.

1. Program Outputs and Comments

In this video, you will learn about comments and basic print commands that are used to display outputs.

2. Variables and Scalar Data Types

In this video, we will cover variables and scalar data types such as floats, Booleans, integers, and characters in Rust.

3. More on Variables - Shadowing, Constants

In this video, you will learn about shadowing and constants in Rust.

4. Compound Data Types - Strings

In this video, you will learn about the String data type in Rust.

5. Compound Data Types - Tuples, Arrays

In this video, you will learn about tuples and arrays in Rust.

6. Compound Data Types - Vectors

In this video, you will learn about vectors in Rust.

7. Functions and Inputs

In this video, you will learn about basic functions and inputs.

3. Ownership - The Heart of Rust Programming

This section explains Rust's unique ownership model and its impact on memory safety.

1. Ownership, Primitive, and Non-Primitive Types

In this video, you will learn about ownership, primitive, and non-primitive types.

2. Application Memory - Heap and Stack

In this video, you will learn about application memory and understand what Heap and Stack are.

3. Ownership and References in Functions

In this video, you will learn about the concept of ownership with respect to functions.

4. Mutable and Immutable References

In this video, you will learn about reference rules and understand what mutable and immutable references are.

4. Control Structures

This section explores Rust's control structures, including if/else statements and loops, and teaches you how to use them effectively.

1. Conditional If and Its Variants

In this video, you will learn about the 'if' conditional statement and its variants.

2. If Let and Nested If

This video covers nested if statements, the 'if let' expression, and the 'match' expression.

3. Match Statement

This video teaches you how to use the match statement in a Rust program.

4. While and Simple Loops

In this video, you will learn how to use while and simple loops in Rust.

5. For Loops and Their Variants

This video covers for loops and their variants in Rust.

6. Break and Continue

This video explains how to use the 'break' statement to stop a loop and the 'continue' statement to skip the current iteration.

5. Project: Stack Implementation

This section provides a project to practice your Rust programming skills by implementing a stack data structure.

1. Implementing Stack

In this video, you will receive a quick introduction to stack implementation and learn how to implement a stack using 'vec'.

2. String Reversal Using Stacks

This video teaches you how to use string reversal using stacks.

3. Expression Evaluation (Infix to Postfix Illustration)

In this video, you will be introduced to expression evaluation and learn how to convert an infix to postfix illustration.

4. Expression Evaluation (Postfix Evaluation)

This video covers how to evaluate the final results from postfix evaluation.

5. Expression Evaluation - Part 1

In this video, you will dive into the code for postfix conversion.

6. Expression Evaluation - Part 2

This video covers how to implement postfix conversion.

7. Implementing Postfix Evaluation

In this video, you will learn how to implement the final part of expression evaluation.

6. Structures, Traits, Generics, Enums

This section covers Rust's advanced data structures and type system, including traits and generics.

1. Structures Basics

In this video, you will learn about the basics of structures in Rust.

2. Traits and Default Implementations

This video teaches you about traits and default implementations.

3. Functions within a Trait

In this video, you will learn about different functions within a trait.

4. Enums

This video covers enums in Rust.

5. Generics

This video teaches you about generics in Rust.

6. Option Enum

In this video, you will learn about the option enum.

7. Result Enum

This video covers the result enum in Rust.

8. Hash Maps

This video teaches you about hash maps in Rust.

7. Iterators, Lifetimes, and Closures

In this section, we will explore Rust's powerful functional programming features, including iterators, lifetimes, and closures.

1. Lifetimes - Part 1

In this video, we will explore the concept of lifetimes in Rust, understand when they are necessary, and address issues such as dangling references and undetermined lifetimes.

2. Lifetimes - Part 2

In this video, you will learn about lifetime specifiers in Rust and how they can help us manage memory safely and effectively.

3. Closures - Part 1

In this video, we will delve into closures in Rust, covering the basic syntax and how to use closures with inputs.

4. Closures - Part 2

In this video, you will learn about some advanced closure features that can help us write more concise and expressive code.

5. Function Types

In this video, you will learn about function types in Rust, their basic syntax and usage, and how to use them as parameters to functions.

6. Iterators - Part 1

In this video, we will explore iterators in Rust, covering the basics, useful functions for iterators, and common statistics.

7. Iterators - Part 2

In this video, you will learn how to modify and collect values with iterators, providing you with more control over your data.

8. Rust Modules and Crates

In this section, we will discover how to create and use modules and crates in Rust to build larger, more complex projects.

1. Rust Modules (Part 1)

In this video, you will learn about Rust Modules systems and learn to create packages that contain crates.

2. Rust Modules (Part 2)

In this video, we will have a look at Modules in Rust.

3. Using External Crates

In this video, you will learn how to use external crates.

4. Publishing Your Crate

In this video, you will learn how to publish Crate.

9. Smart Pointers

In this section, we will delve into Rust's smart pointers and discover how they enhance memory management and minimize bugs.

1. Basics of Smart Pointers

In this video, we will explore the basics of smart pointers and why they are important in Rust.

2. Box Smart Pointers and When to Use It

In this video, you will learn about Box smart pointers and when to use them.

3. Refining Cons List and Custom-Defined Smart Pointers

In this video, we will refine Cons lists, create custom smart pointers, and custom-defined smart pointers.

4. Singly Link List (Part 1)

In this video, we will begin our discussion on singly linked lists and how they work.

5. Singly Link List (Part 2)

In this video, we will continue our discussion on singly linked lists and explore their applications.

6. Generics and Deref Coercion in Smart Pointers

In this video, you will learn about the use of generics and deref coercion in smart pointers.

7. Rc Smart Pointer

In this video, we will examine Rc smart pointers and how they can help in sharing data across multiple ownership contexts.

8. RefCell Smart Pointer

In this video, we will discuss RefCell smart pointers and how they enable interior mutability in Rust.

9. Doubly Link List (Part 1)

In this video, we will begin our discussion on doubly linked lists and how they differ from singly linked lists.

10. Doubly Link List (Part 2)

In this video, we will continue our discussion on doubly linked lists and explore their applications.

11. Reference Cycles Creating Memory Leakage

In this video, we will examine the problem of reference cycles and how they can lead to memory leaks.

10. Advance Techniques

In this section, we will explore advanced Rust programming techniques such as macros, testing, and memory allocation.

1. Macros Basic

In this video, we will cover the basics of macros.

2. Capturing Types

In this video, we will explore capturing types in macros.

3. Repeating Patterns

In this video, we will cover repeating patterns in macros.

4. Unit Type, Expression Versus Statements, and Partial Move

In this video, we will discuss the unit type, expressions vs. statements, and partial moves.

5. As_ref and Partial Move in Option

In this video, we will cover as_ref and partial move in the Option type.

6. Take and Swap for Avoiding Allocations

In this video, we will explore the take and swap methods for avoiding allocations.

7. Question Mark Operator

In this video, we will cover the question mark operator.

8. Testing Your Code (Part 1)

In this video, we will cover the basics of testing your Rust code.

9. Testing Your Code (Part 2)

In this video, we will explore more advanced testing techniques in Rust.

11. Real-Life Applications and Problem-Solving Using Rust

In this section, we will apply our Rust skills to build real-world applications and solve complex problems.

1. Search Results Using Word Groupings with HashMaps and Nested Loops

In this video, we will build a search results feature using word groupings with HashMaps and nested loops.

2. Product Popularity Using HashMaps

In this video, we will build a product popularity feature using HashMaps.

3. Highest Stock Price Using MaxStack and Structures

In this video, we will build a feature to find the highest stock price using MaxStack and structures.

4. Finding an Employee with No Meeting Using Multidimensional Arrays

In this video, we will build a feature to find an employee with no meeting using multidimensional arrays.

5. Longest Non-Stop Working Employee Using HashSets

In this video, we will build a feature to find the longest non-stop working employee using HashSets.

6. Items Suggestions Using HashSets and Vectors

In this video, we will build an item suggestion feature using HashSets and vectors.

7. Items in Ranges Using Binary Search Tree (Part 1)

In this video, we will have a look at a purchase problem.

8. Items in Ranges Using Binary Search Tree (Part 2)

In this video, we will start building the feature to find items in ranges using a Binary Search Tree and Box pointer.

9. Fetching Top Products

In this video, we will build a feature to fetch top products.

10. Effective Storage and Retrieval Using Trie Data Structure

In this video, we will explore effective storage and retrieval using a Trie data structure.

11. Most Recently Used Product Using Doubly Link List and HashMaps (Part 1)

In this video, we will have a look on a problem where a business is interesting in knowing the products that has been purchased most recently by a customer.

12. Most Recently Used Product Using Doubly Link List and HashMaps (Part 2)

In this video, we will start implementing the MRU product algorithm using doubly linked lists and HashMaps.

13. Displaying Participants in an Online Meeting (Part 1)

In this video, you will learn how to display participants in an online meeting. In this problem, we need to retrieve a paginated view of the list of participants in an online meeting.

14. Displaying Participants in an Online Meeting (Part 2)

In this video, we will work on the implementation using BST and Stack for displaying participants in an online meeting.

12. Deep Dive Into Traits

In this section, we will unlock the power of traits in Rust as you take a deep dive into their concepts, usage, and advanced features.

1. Trait Bounds

In this video, we will discover the versatility of trait bounds in Rust and learn how to apply them effectively.

2. Associated Types

In this video, we will delve into the world of associated types in Rust and harness their capabilities for generic programming.

3. Trait Items

In this video, we will explore the concept of trait items in Rust. You will learn about the "Self" keyword, how to define functions and methods within traits, and the use of generic parameters and associated types.

4. Scope of a Trait, Marker, and Super Trait

In this video, we will delve into the scope of traits in Rust. We will discuss the scope of trait methods and how they interact with types. Additionally, we will explore marker traits and auto traits, and their significance in Rust programming.

5. Some Useful Traits

In this video, we will explore traits that provide common functionality and simplify code implementation. Learn how to leverage these traits to enhance code readability, maintainability, and modularity.

6. Static Versus Dynamic Dispatch (Trait Objects)

In this video, we will uncover the differences between static and dynamic dispatch in Rust and their impact on program execution. Gain insights into the concept of trait objects and understand when to use each dispatch mechanism for optimal code design and performance.

13. Efficient Programming with Rust

In this section, you will learn how to write efficient code in Rust using design patterns and optimization techniques.

1. Initializing Struct Instances

In this video, you will learn about initializing struct instances in Rust.

2. Function Inputs and Coercion

In this video, we will discuss function inputs and coercion in Rust.

3. Iterating Through Option

In this video, you will learn how to iterate through Option in Rust.

4. Disabling Mutability for Finalized Objects

In this video, you will learn about disabling mutability for finalized objects in Rust.

5. String Concatenation and Ownership

In this video, we will discuss string concatenation and ownership in Rust.

6. Simplifying Structures

In this video, you will learn about simplifying structures in Rust.

7. Efficient Programming Tips

In this video, we will explore some tips for writing efficient code in Rust.

8. String Literals

In this video, we will discuss string literals in Rust.

9. Todo Macro and Some Useful Extensions

In this video, we will cover the Todo Macro and some useful extensions in Rust.

10. The Builder Pattern

In this video, you will learn about the Builder pattern in Rust.

14. Concurrency

In this section, we will master Rust's powerful concurrency features, including channels and locks.

1. Threads Basics

In this video, we will get an introduction to threads, learn how to create, and join threads, and understand the basics of thread synchronization.

2. Multiple Threads and Ownership in Threads

In this video, we will discuss multiple threads and ownership in threads in Rust.

3. Communication through Channels

In this video, we will cover communication between threads through channels in Rust.

4. Multiple Producers, Threads, and Functions

In this video, we will explore multiple producers, threads, and functions in Rust.

5. Sharing States

In this video, we will discuss how to share states between threads in Rust.

6. Passing Mutexes between Threads

In this video, we will cover how to pass mutexes between threads in Rust.

7. Synchronization Through Barriers

In this video, we will explore synchronization between threads through barriers in Rust.

8. Project: Web Scraping Using Threads

In this video, we will apply our knowledge of threads in Rust to a practical project: web scraping.

9. Scoped Threads

In this video, we will cover scoped threads in Rust.

10. Thread Parking, Yielding

In this video, we will discuss thread parking and yielding in Rust.

11. Async Await

In this video, we will explore async/await in Rust.

12. Async Await (Tasks and Select)

Discover the power of async-await in Rust as we dive into tasks and select operations. In this video, you will learn how to leverage async-await for concurrent programming using the Tokio framework with the version "1.17" and the "full" feature enabled. Explore the capabilities of async-await and master the art of asynchronous programming in Rust.

15. Text Processing, File and Directory Handling

In this section, we will discover how to handle text processing, file, and directory operations in Rust.

1. Basic File Handling

In this video, we will cover basic file handling.

2. Directory and Path-Related Functions

In this video, we will explore directory and path-related functions.

3. Regular Expressions Basics

In this video, we will go over the basics of regular expressions.

4. Repetitions Quantifiers and Capturing Groups

In this video, we will cover repetition quantifiers and capturing groups.

16. Blockchain in Rust

In this section, we will explore Rust's potential for building decentralized applications and smart contracts on blockchain technology.

1. Blockchain Theory (Part 1: Hashes)

In this video, we will delve into blockchain theory, specifically focusing on hashes.

2. Blockchain Theory (Part 2: Blocks and Blockchain)

In this video, we will continue our exploration of blockchain theory, focusing on blocks and the blockchain.

3. Blockchain in Rust (Part 1: Basic Structures and Functions)

In this video, we will start building a blockchain in Rust, covering basic structures and functions.

4. Blockchain in Rust (Part 2: Chain Validation and Selection)

In this video, we will continue building our Rust blockchain by covering chain validation and selection.

17. Web Programming

In this section, we will dive into the world of web programming with Rust.

1. Web Programming Basics

In this video, we will lay the foundation of web programming in Rust. Join us as we explore the basics of web development, including HTTP protocols and handling requests and responses.

2. Making Responses

In this video, we will dive deeper into web development with Rust by focusing on making responses. Discover different types of responses you can send back to clients, such as HTML pages. Learn how to customize responses and handle different content types effectively to create dynamic and engaging web applications.

3. Multiple Requests Using Threads

In this video, we will explore how to handle multiple requests using threads in Rust. Discover how to leverage Rust's thread capabilities to process requests concurrently, improving the performance and responsiveness of your web applications.

18. Measuring and Improving Performance

In this section, we will focus on measuring and improving the performance of Rust applications. Discover tools and techniques to benchmark and optimize your code, ensuring that it runs efficiently and meets the highest performance standards.

1. Benchmarking Using Criterion

In this video, we will explore the powerful benchmarking tool Criterion in Rust. Learn how to set up benchmarks, measure code performance, and analyze the results.

2. Performance Lints

In this video, we will delve into performance lints, a valuable tool for identifying potential performance issues in your Rust code. Explore how to leverage lints to detect common performance pitfalls and apply best practices.

Course Images

Rust Programming Masterclass from Beginner to Expert

By Packt

Booking options

Highlights