CF

Ultimate Rust Foundations

17h 53m 36s
English
Paid

Ultimate Rust Foundations is a 76-lesson 17 hours 53 minutes self-paced course by Ardan Labs. Ultimate Rust: This course covers many best practices to help you integrate Rust into your workflow, and let Rust’s tooling work for you.

Course facts

Lessons
76
Duration
17 hours 53 minutes
Level
All levels
Language
English
Updated
Instructor
Ardan Labs
Price
Premium

Ultimate Rust: This course covers many best practices to help you integrate Rust into your workflow, and let Rust’s tooling work for you. It includes formatting, linting, dependencies, vulnerabilities, code style, and general development advice..

Additional

https://github.com/thebracket/ArdanUltimateRust-5Days

Who teaches Ultimate Rust Foundations? Ardan Labs

Ardan Labs thumbnail

Ardan Labs is a US training company founded by William Kennedy, focused almost entirely on Go (Golang) and the systems-engineering disciplines around it. Bill Kennedy is one of the most cited Go educators alive — co-author of Go in Action (Manning), maintainer of the Ardan Labs blog, and the lead instructor on a multi-track Go syllabus that runs from beginner through ultimate-Go advanced engineering.

The CourseFlix listing under this source carries nineteen Ardan Labs courses — covering Go language fundamentals, concurrency, advanced engineering patterns, Kubernetes (Bill teaches Go as the implementation language for cloud infrastructure), and the data-engineering / AI tracks Ardan added in recent years. Material is paid and aimed at engineers serious about Go as a career-defining language rather than as a syntax pickup.

What lessons are included in Ultimate Rust Foundations?

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 76 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: 1.0 - Introduction
All Course Lessons (76)
#Lesson TitleDurationAccess
1
1.0 - Introduction Demo
01:57
2
1.1 - Setup & Update Rust
04:17
3
1.2 - Setup Dev Environment
04:17
4
1.3 - IDE Configuration
03:43
5
1.4 - Rust Fundamentals
28:56
6
1.5 - Console Text Input
07:50
7
1.6 - Create a Library
15:05
8
1.7- World’s Simplest Login System
09:10
9
1.8 - Enumerations
23:41
10
1.9 - Structures
14:56
11
1.10 - Vectors
12:11
12
1.11 - HashMaps
10:03
13
1.12 - Serialization/Deserialization
15:48
14
1.13 - Hashing Passwords
11:10
15
1.14 - Start a CLI App
41:06
16
2.0 - Introduction
04:27
17
2.1 - System Threads: Overview
06:02
18
2.2 - Create Your First Thread
05:13
19
2.3 - Spawning Threads with Parameters and Closures
06:06
20
2.4 - Returning Data from Threads
05:17
21
2.5 - Dividing Workloads
09:36
22
2.6 - The ThreadBuilder Pattern
08:09
23
2.7 - Scoped Threads for Easy Local Data Sharing
10:08
24
2.8 - Sharing Data with Atomics
18:13
25
2.9 - Sharing Data with Mutexes
09:49
26
2.10 - Read/Write Locks
14:40
27
2.11 - Deadlocks, Panics and Poisoning
18:29
28
2.12 - Sharing Data with Lock-Free Structures
07:24
29
2.13 - Parking Threads
07:14
30
2.14 - Sending Data Between Threads with Channels
08:35
31
2.15 - Sending Functions to Worker Threads
13:58
32
2.16 - Let’s build a work queue with a thread pool
09:28
33
2.17 - Thread CPU/Core Affinity
07:47
34
2.18 - Thread Priority
12:20
35
2.19 - Making it Easy with Rayon
16:34
36
2.20 - Scopes and Pooled Threads with Rayon
17:18
37
3.0 - Introduction / Async Overview
07:30
38
3.1 - Hello Async/Await
15:28
39
3.2 - Getting Started with Tokio
09:07
40
3.3 - Working with Tokio Futures: Awaiting, Yielding and Spawning
14:02
41
3.4 - Blocking Tasks
10:05
42
3.5 - Unit Testing Tokio
10:21
43
3.6 - Handling Errors
41:44
44
3.7 - File I/O
17:21
45
3.8 - Basic Network I/O
23:50
46
3.9 - Async Channels (Tokio)
14:28
47
3.10 - Shared State (Tokio)
14:28
48
3.11 - Selecting Futures
09:16
49
3.12 - Pinning
16:48
50
3.13 - Tokio Tracing
22:56
51
3.14 - Working with Databases
34:13
52
3.15 - Axum - A Web Framework built on Tokio
18:56
53
3.16 - Let’s Build a Thumbnail Server
01:12:26
54
4.0 - Why Haven’t We Manually Managed Any Memory Yet?
03:42
55
4.1 - The unsafe Keyword
09:06
56
4.2 - Low-Level Memory Management
07:15
57
4.3 - The Drop Trait & RAII (Resource Acquisition is Initialization)
17:09
58
4.4 - Reference Counting
18:30
59
4.5 - Lifetimes
17:06
60
4.6 - Traits
25:08
61
4.7 - Generics
19:30
62
4.8 - Iterators
15:05
63
4.9 - Cycles and the Difficulty of Linked Lists
06:53
64
4.10 - Memory Fragmentation, Allocators and Arenas
07:39
65
4.11 - Packing, Reordering & Mangling
05:27
66
4.12 - From Bytes to Types
12:04
67
4.13 - Safely Interacting with Other Languages & Surprise: Memory Leaks are Safe!
17:10
68
5.0 - Introduction & Planning Our Project
06:28
69
5.1 - Shared Data Structures
15:31
70
5.2 - Collection Daemon Mk 1
13:23
71
5.3 - Collection Server Mk 1
09:01
72
5.4 - Error Handling in the Collector
22:47
73
5.5 - Setting the Collector ID
05:10
74
5.6 - Web Service Mk 1
27:32
75
5.7 - Web Server
11:10
76
5.8 - Let’s Use Less Bandwidth
06:54
Unlock unlimited learning

Get instant access to all 75 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

What courses are similar to Ultimate Rust Foundations?

More courses by Ardan Labs

Frequently asked questions

What prerequisites are needed to enroll in this course?
The course assumes a basic understanding of programming concepts. Familiarity with systems programming and experience with languages such as C or C++ can be beneficial, but are not strictly required. The course starts with setting up the Rust environment, making it accessible for beginners to Rust itself.
What projects will I build during the course?
Throughout the course, you'll build practical projects such as a Console Text Input system, a simple Login System, a CLI App, and a Thumbnail Server using Axum. These projects are designed to reinforce Rust's features and tools, including threading, async programming, and memory management techniques.
Who is the target audience for this course?
This course is aimed at developers who want to integrate Rust into their existing workflow and are interested in learning best practices for using Rust's tooling effectively. It is suitable for software developers with a focus on system-level programming and those interested in concurrency and performance optimization.
What specific tools or platforms does the course cover?
The course covers a variety of Rust-specific tools and platforms, including the Tokio runtime for asynchronous programming, the Axum web framework, and the Rayon library for data parallelism. It also goes over Rust's standard library features like HashMaps, Vectors, and various concurrency primitives.
What is NOT covered in this course?
The course does not delve into graphical user interfaces (GUIs) or web frontend development. It also doesn't cover advanced topics in network security or cryptography beyond basic password hashing techniques. The focus is on system-level programming and Rust's concurrency and memory management features.
How much time should I expect to commit to this course?
With 76 lessons, the course is designed to be comprehensive. Although the total runtime is not specified, a typical student might spend several weeks completing the course, depending on their prior experience and the time they can dedicate each week. Exercises and projects are included to solidify learning, which may extend the time commitment.
How can the skills learned in this course benefit my career?
Learning Rust and its ecosystem can significantly enhance your skills in systems programming, concurrency, and performance optimization. These skills are highly valuable in industries such as software development, embedded systems, and network applications. The course also lays a strong foundation for pursuing more specialized Rust courses or contributing to open-source Rust projects.