English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 61 lectures (6h 31m) | 2.31 GB
Fundamentals of the Rust Programming Language
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.
What you’ll learn
- The fundamentals of the Rust Programming Language
- Low level memory management
- Rust’s unique approach to memory safety
- How to troubleshoot common compiler errors
Table of Contents
Getting Started
1 Course Introduction
2 What is Rust
3 Installing Rust
4 Setting Up the Development Environment
5 Cargo
Manual Memory Management
6 Code for this section
7 Introduction
8 The Stack
9 The Heap
10 Smart Pointers
11 Explore the Memory Layout in GDB
Building a Command Line Application
12 Code for this section
13 Introduction
14 Basic Data Types
15 Functions
16 Macros
17 Mutability
18 The Standard Library
19 Ownership
20 References and Borrowing
21 Explore the Ownership and Borrowing in GDB
22 Finishing Touches
Building a HTTP Server From Scratch
23 Code for this section
24 Introduction
25 The HTTP Protocol and the Architecture of Our Server
26 Structs
27 Strings
28 Enums
29 The Option Enum
30 Organising Our Code into Modules
31 Listening for TCP Connections
32 The Result Enum
33 Loops
34 Tuples
35 The Match Expression
36 Arrays
37 Logging the Incoming Requests to the Console
38 Traits and Type Conversions
39 Custom Errors
40 Advanced Error Handling
41 Iterating Over Strings
42 Converting an Option into a Result
43 Parsing Values From Strings
44 The If Let Expression
45 Lifetimes – Part 1
46 Lifetimes – Part 2
47 Silencing Compiler Warnings
48 Representing the Query String Using a Hash Map – Part 1
49 Representing the Query String Using a Hash Map – Part 2
50 The Derive Attribute
51 Modelling the HTTP Response
52 Copy and Clone Types
53 Writing Data to a TCP Stream
54 Dynamic vs Static Dispatch
55 Custom Traits
56 Implementing Getters
57 Routing Incoming Requests
58 Working with Environment Variables
59 Serving HTML Files
60 Serving Arbitrary Files Securely
61 Next Steps
Resolve the captcha to access the links!