English | MP4 | AVC 1920×1080 | AAC 48KHz 2ch | 6h 21m | 5.72 GB
Take your apps to the next level with Rust
This video course features application-specific recipes to boost your development of real-world apps by integrating Rust units into your existing applications, even those written in another language. Geared towards those already familiar with the basics of Rust, this course will take you through solutions that will allow you to use Rust code samples right away in your existing applications.
You will learn key techniques that Rust uses to write scalable code, including advanced-level concepts such as error handling, macros, fearless concurrency, and zero cost abstractions such as futures, and create an HTTP server that reads from a database. We’ll cover some of the many benefits of working in Rust as you write systems-level software. We’ll move on to add our Rust code into existing C and Python applications so that you can learn how to integrate our new fast and safe code into other environments.
By the end of the course, you will have a strong foundational knowledge in server-side programming, enabling you to deliver solutions to build high-performance web applications and services using Rust.
Learn
- Useful patterns for handling error cases
- Patterns for building complex objects with ease
- How lifetimes provide data safety and how to pass them around even concurrent code
- How we can use generics to handle complex data with ease
- What it means for an abstraction to be zero cost
- How we can use macros to simplify make our code easier to write
- How we can use “iterator” and “intoiterator” to make our functions more flexible
- How Rust futures allow us to handle IO without blocking our program from working on something else
- How libraries such as Diesel and Rocket use macros to make them easier to write for
- How we can integrate our new rust code with existing libraries written in other languages
Table of Contents
1 The Course Overview
2 Error Handling in Rust
3 Avoid Using Match with Combinators
4 Building Our Own Error Type
5 Results and Options
6 Splitting Our Codes between Modules and Crates
7 Introducing the Failure Crate
8 Writing an Iterator
9 Adding a New Combinator Function to All Iterators
10 Discovering the Itertools Crate
11 Building on the IntoIterator Trait
12 A Function that Takes Anything Loopable
13 Publishing our Crate on Cargo
14 Tracking Lifetimes Across Closures
15 Closures as Parameters
16 Reference Counting with Rc and RefCell
17 Channels and Threads
18 Creating a Thread Pool
19 Rayon Parallelism Crate
20 Builder Patterns Using SVGs
21 Builder Objects and Default Properties
22 Composing Objects by Wrapping
23 Declarative Macros
24 Introducing Procedural Macros
25 Reading Properties in Derive Macros
26 Defining Futures
27 Creating a Future
28 Chain Futures Together Using Combinators and Async Await
29 Building a Futures Based Stream
30 Building a TCP Server Using Futures
31 Installing PostgreSQL
32 Create a basic database table
33 Using Migrations and Schemes to Plan Your Database
34 Writing to the Database
35 Reading Joins from the Database
36 Selecting Joins from the Database
37 Learn to use Rocket Macros to Build A Simple Server
38 Creating a responder
39 Connecting to the Diesel Database
40 Managing your Cookies and sessions
41 Maud Compile Time Templates
42 Reading Cookies
43 Calling C Code from Rust
44 Other Languages Calling Rust
45 Sending Complex Data types between Rust and C
46 Calling Dynamic libraries from Rust
47 Calling Rust from Python
Resolve the captcha to access the links!