English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 135 Lessons (19h 44m) | 4.35 GB
Learn Rust programming from the ground up and create real-world applications.
Rust Programming covers all the aspects of mastering the Rust language, from foundational to advanced levels. This video course will help you learn how to apply Rust to real-world scenarios through clear training and detailed examples.
The Rust language combines the efficiency, speed, and low-level power of C/C++ with the benefits of higher-level languages such as Java, Python, and C#, and you can use it to implement all kinds of solutions including embedded systems, DevOps operators, operating systems and platforms, and much more besides.
In the course, you will learn about the Rust toolset, the Rust type system, how to implement flow control, how to use compound types and collections, and how Rust carefully manages the lifetime of objects and how they are referenced safely in your code.
The course also looks at how to organize Rust applications into functions, structures, and traits. You will learn how to use these techniques to achieve familiar object-oriented goals such as abstraction, encapsulation, inheritance, and polymorphism. You will also learn how Rust deals with important issues such as generic types and multithreading.
You will learn how to structure large applications in Rust through detailed walkthrough of two complete real-world applications. Experienced trainer Andy Olsen will systematically teach you the skills needed to start using Rust effectively and efficiently.
Topics included in this course:
- Module 1: Rust Programming Essentials
- Module 2: Rust Ownership and Borrowing
- Module 3: Structuring Rust Code
- Module 4: Advanced Rust Programming Concepts
- Module 5: Real-World Rust in Action
Learn How To:
- Create, build, and run Rust applications
- Organize Rust code and application structure properly
- Manage memory safely and effectively
- Use object-oriented programming techniques
- Implement concurrency
- Explore additional Rust techniques
- Implement file handling
- Access a relational database
Table of Contents
Introduction
Rust Programming Essentials Introduction
Lesson 1 Getting Started with Rust
Learning objectives
Overview of Rust
Writing your first Rust application
Building and running your first Rust application
Creating an application by using Cargo
Building and running an application by using Cargo
Lesson 2 Understanding Rust Variables and Types
Learning objectives
Integer types
Floating-point types
Other simple types
Additional techniques
Lesson 3 Implementing Flow Control
Learning objectives
If-tests
Matching
Loops
Using break and continue
Lesson 4 Understanding Enums
Learning objectives
Defining and using simple enums – Part 1
Defining and using simple enums – Part 2
Avoiding warnings about unused variants
Defining and using enums with data
Using the Option enum
Using the Result enum
Lesson 5 Using Compound Types and Collections
Creating and using arrays
Array techniques
Creating and using tuples
Creating and using vectors
Creating and using maps
Lesson 6 Understanding Ownership in Rust
Learning objectives
Understanding local scope
Defining static local scope – Part 1
Defining static local scope – Part 2
Defining static global scope
Defining static mutable variables – Part 1
Defining static mutable variables – Part 2
Understanding strings in Rust – Part 1
Understanding strings in Rust – Part 2
Copying vs. moving
Lesson 7 Understanding Borrowing in Rust
Learning objectives
Understanding simple borrowing
Understanding the Rust borrow checker
Introduction to string slices
String slice techniques
Introduction to array slices
Array slice techniques
Lesson 8 A Closer Look at Functions
Learning objectives
Passing value parameters
Passing reference parameters – Part 1
Passing reference parameters – Part 2
Passing mutable reference parameters
Returning a value
Returning a reference
Returning a mutable reference
Lesson 9 Nested Functions and Closures
Learning objectives
Nested functions
Getting started with closures
Using type inference with closures
Capturing variables by reference
Capturing variables by value – Part 1
Capturing variables by value – Part 2
Iterating over a collection
Lesson 10 Defining Simple Structs
Learning objectives
Defining a struct type
Creating and using struct instances
Passing struct parameters by value
Passing struct parameters by reference
Returning structs by value
Returning structs by reference
Lesson 11 Implementing Functionality in a Struct
Learning objectives
Implementing mutable functionality
Organizing code into modules
Defining associated functions
Defining associated data
Lesson 12 Defining Traits
Learning objectives
Trait essentials
Trait techniques
Inheritance and polymorphism
Trait inheritance
Implementing the Display trait
Implementing the Debug trait
Implementing the Drop trait
Implementing the Clone trait
Implementing the Copy trait
Lesson 13 Generics
Learning objectives
Generic structs
Generic functions
Type constraints
Implementing the PartialEq trait
Implementing the Eq and Hash traits
Implementing the PartialOrd trait
Implementing the Ord trait
Understanding how closures work
Passing closures into functions – Part 1
Passing closures into functions – Part 2
Lesson 14 Multithreading and Concurrency
Learning objectives
Spawning a thread
Joining a thread
Joining multiple threads
Capturing state
Capturing state via an explicit move
Communicating data between threads by using channels
Lesson 15 Additional Rust Techniques
Learning objectives
Introduction to boxing
Using boxing in practice – Part 1
Using boxing in practice – Part 2
Reference counting
Defining unsafe code
Integrating with other languages
Lesson 16 Rust Project 1 Implementing a CSV Parser
Learning objectives
Understanding the application scenario – Part 1
Understanding the application scenario – Part 2
Understanding the application structure
Parsing the command line
Reading and writing data in a file
Implementing a menu system
Storing date information – Part 1
Storing date information – Part 2
Storing date information – Part 3
Going further with date processing – Part 1
Going further with date processing – Part 2
Lesson 17 Rust Project 2 Accessing a Relational Database
Learning objectives
Getting started
Understanding the application structure
Connecting to a database
Executing a simple SQL statement
Executing a parameterized SQL statement
Executing a query to select data
Wrapping up
Module 1 Rust Programming Essentials
Module introduction
Module 2 Rust Ownership and Borrowing
Module introduction
Module 3 Structuring Rust Code
Module introduction
Module 4 Advanced Rust Programming Concepts
Module introduction
Module 5 Real-World Rust in Action
Module introduction
Summary
Rust_Programming_Essentials_Summary
Resolve the captcha to access the links!