CF

Ultimate Rust Foundations

17h 53m 36s
English
Paid
Added to CourseFlix

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
Language
English
Added to CourseFlix
March 2024
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)

Watch the first 10 minutes free. One payment unlocks all 76 lessons here and every other premium course. No auto-renew.

Watch all 76 lessons from $6.67/mo
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
Watch the other 75 lessons

One payment unlocks this course and every other premium course. No auto-renew.

See plans

What courses are similar to Ultimate Rust Foundations?

  • Ultimate Rust Crash Course thumbnailUpdated 10mo ago

    Ultimate Rust Crash Course

    By: Ardan Labs
    Learn the basics of Rust, gain practical skills for writing safe and fast code. The course is suitable for both beginners and experienced programmers.
    2h 26m
  • Rust for JavaScript Developers thumbnailUpdated 1mo ago

    Rust for JavaScript Developers

    By: Sidhartha Chatterjee
    A Rust course for JavaScript developers, covering core syntax, common idioms, and the package ecosystem to help you branch into systems programming.
  • Rust for Beginners thumbnailUpdated 1mo ago

    Rust for Beginners

    By: Zero To Mastery
    Start Rust from zero: syntax, control flow, structs, enums, and the ownership model that makes Rust's memory management unique.
    3h 18m5/5
  • Rust as a Service thumbnailUpdated 2y ago

    Rust as a Service

    By: Ardan Labs
    This course teaches integrating Rust into service-oriented architectures, covering REST server development, data handling, error management, and modularization.
    6h 13m5/5
  • Crusty Interpreter thumbnailUpdated 1mo ago

    Crusty Interpreter

    By: David Beazley
    Build a Rust interpreter for the Lox language from Crafting Interpreters in this week-long, project-intensive course for ambitious developers.
    33h 53m
  • Rust from C/C++ thumbnailUpdated 2y ago

    Rust from C/C++

    By: Ardan Labs
    This course bridges the transition from C and C++ to Rust by highlighting their similarities and differences. Exploring Rust's native compilation, memory manage
    5h 31m5/5
  • Ultimate Rust Best Practices thumbnailUpdated 3y ago

    Ultimate Rust Best Practices

    By: Ardan Labs
    This course covers many best practices to help you with integrate Rust into your workflow, and let Rust’s tooling work for you.
    1h 39m5/5
  • Learn Rust in a Month of Lunches thumbnailUpdated 1mo ago

    Learn Rust in a Month of Lunches

    By: Dave MacLeod
    A 24-lesson book teaching Rust in short, lunch-break-sized lessons, from basic syntax through async code and test-driven development.
    5/5

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.