Home
Data Structures and Algorithms
Complexity Analysis
Arrays
Searching & Sorting
Linked Lists
Stacks
Queues
Heaps & Priority Queues
Hashing
Trees
Graphs
Tries
Math & Bit Manipulation
Greedy Algorithms
Backtracking
Dynamic Programming
Summary
About
Dark
Guide contents
Rust Programming
Getting Started
1.
Introduction: How This Course Works
2.
What Is Rust? A Complete Overview
3.
Installing Rust & Cargo
4.
Hello World & Printing Output
Language Basics
5.
Variables & Mutability
6.
Scalar Types: Integers, Floats, Booleans & Characters
7.
Functions
8.
Control Flow: if, loop, while, for & match
9.
Tuples & Arrays
10.
A First Look at String, Vec & HashMap
Ownership & Borrowing
11.
Ownership: The Three Rules
12.
Move, Copy & Clone
13.
Ownership & Functions
14.
References & Borrowing
15.
Mutable References
16.
Slices: &str and &[T]
17.
Strings in Depth: String vs &str
18.
Ownership & Borrowing with Collections
Structs, Enums & Pattern Matching
19.
Structs
20.
Methods & Associated Functions
21.
Enums: Types With Variants
22.
Option: Replacing null
23.
Pattern Matching in Depth
24.
Result & the ? Operator
Lifetimes
25.
Lifetimes in Functions
26.
Lifetimes in Structs & Methods
27.
Lifetime Elision & 'static
28.
Fixing Borrow Checker Errors
Traits & Generics
29.
Traits: Rust's Interfaces
30.
Deriving Standard Traits
31.
Generics
32.
Trait Bounds & where Clauses
33.
Trait Objects & Dynamic Dispatch
34.
Advanced Traits
35.
Conversion Traits: From, Into, TryFrom, FromStr, AsRef
Closures & Iterators
36.
Closures
37.
Fn, FnMut & FnOnce
38.
Iterators
39.
Iterator Adapters: The Complete Cookbook
40.
Custom Iterators
Collections
41.
Vec in Depth
42.
HashMap
43.
HashSet
44.
BTreeMap & BTreeSet
45.
VecDeque & BinaryHeap
Modules, Crates & Testing
46.
Modules & Visibility
47.
Crates, Packages & Workspaces
48.
Testing
Error Handling
49.
Custom Error Types
50.
thiserror & anyhow
51.
Error Handling Patterns
Files, I/O & the Command Line
52.
Reading & Writing Files
53.
Paths & Directories
54.
Standard Input, Output & Error
55.
Command-Line Arguments, Environment & Processes
Smart Pointers
56.
Box: Heap Allocation
57.
Rc & Weak: Shared Ownership
58.
Cell & RefCell: Interior Mutability
59.
Drop, Deref & Cow
OOP & Design Patterns
60.
OOP Concepts in Rust
61.
Creational Patterns
62.
Structural Patterns
63.
Behavioral Patterns
Concurrency
64.
Threads
65.
Shared State: Arc, Mutex & RwLock
66.
Channels: Message Passing
67.
Atomics, Send & Sync
Async Rust
68.
Async Fundamentals
69.
Tokio Patterns: select!, JoinSet & Friends
70.
Async Channels & Locks
71.
Async Traits
72.
Async Streams
73.
How Async Works: Futures, Pin & Wakers
Memory Management
74.
Memory Without a Garbage Collector
75.
Allocators & Measuring Memory
76.
The Rust Memory Model
77.
Aliasing & Undefined Behavior
Advanced Rust
78.
Advanced Lifetimes
79.
Declarative Macros
80.
Procedural Macros
81.
Unsafe Rust & FFI
82.
no_std: core and alloc
83.
Performance
84.
API Design Idioms
Under the Hood
85.
How the Rust Compiler Works
86.
The Runtime & Async Executors
Production Rust
87.
Panics & Failure Handling
88.
Async Pitfalls in Production
89.
Testing, Fuzzing & Benchmarking
90.
Compile Times & Build Engineering
91.
Dependencies, Security & CI
92.
Debugging & Profiling in Production
93.
Observability
94.
Architecting Rust Services
Home
/
Rust Programming
/
Concurrency
Concurrency
Threads, channels, and shared state.
4 lessons
64.
Threads
65.
Shared State: Arc, Mutex & RwLock
66.
Channels: Message Passing
67.
Atomics, Send & Sync
