Learn Rust programming with a practical, hands-on approach! This course combines theory with numerous exercises, guiding you through Rust’s unique features and robust compiler. Starting with an overview of Rust’s powerful tools and ecosystem, you’ll master basic and advanced concepts, including ownership, lifetimes, generics, and concurrency. Experience the benefits of Rust’s safety and performance, and explore topics like traits, pointers, and error handling. Ideal for developers seeking to enhance their skills with one of the most loved programming languages.
- This is a hands-on course: theory is interleaved with numerous practical
exercises, and ideas are constantly illustrated and explored up by inspecting
the compiler’s response to illustrative code samples. Rust’s compiler error messages have advanced the state of the art in terms of
helpfulness. The course tries to emphasize how much can be learned about the
language by reading the compiler error messages.
- The course tries to follow a path through the material which introduces only
one new concept at a time. However, Rust is a complex language where the
concepts form a dense and cyclic dependency graph, so it is not entirely
possible to live up to this goal.
- The tooling that comes with Rust is tightly integrated into the workflow of
the Rust programmer, and probably a significant contributing factor to Rust’s
consistent top spot in the GitHub Survey’s ranking of languages most-loved by
their users. The course starts with an overview of these tools and the
ecosystem that has grown as a consequence of their existence, and will
continue to use many of them throughout.
This is a hands-on course: theory is interleaved with numerous practical
exercises, and ideas are constantly illustrated and explored up by inspecting
the compiler’s response to illustrative code samples.
Rust’s compiler error messages have advanced the state of the art in terms of
helpfulness. The course tries to emphasize how much can be learned about the
language by reading the compiler error messages.
The course tries to follow a path through the material which introduces only
one new concept at a time. However, Rust is a complex language where the
concepts form a dense and cyclic dependency graph, so it is not entirely
possible to live up to this goal.
The tooling that comes with Rust is tightly integrated into the workflow of
the Rust programmer, and probably a significant contributing factor to Rust’s
consistent top spot in the GitHub Survey’s ranking of languages most-loved by
their users. The course starts with an overview of these tools and the
ecosystem that has grown as a consequence of their existence, and will
continue to use many of them throughout.
Some ideas are difficult to convey adequately in natural language alone and
are best demonstrated with concrete examples in some programming language,
and seeing the compile-time and run-time results can be very illuminating;
C++ is sometimes the best choice in this context.
Consequently, a small number of the exercises ask the participants to
translate small samples of C++ code into Rust, usually to demonstrate how the
Rust compiler refuses to accept unsound code. The meaning of this sample code
will be explained patiently to anyone not familiar with C++.
- Some topics which are explicitly NOT covered in this course: writing unsafe Rust async implementation of procedural macros details of String manipulation
Some topics which are explicitly NOT covered in this course:
- writing unsafe Rust
- async
- implementation of procedural macros
- details of String manipulation
Detailed Topics
- Why Rust
- Installing the toolchain
- Cargo features the manifest managing libraries and executables unit tests integration tests examples docs benchmarks
- Preludes
- std vs core: no operating system, no problem
- Basic language features functions expression-orientation type declaration and inference attributes modules
- Review, consolidation and integration of concepts
- Previews pattern matching Option: avoiding the billion-dollar mistake ownership semantics triad
- Types and traits unit structs never tuple structs associated functions traits structs enums
- Review, consolidation and integration of concepts
- Ownership copy and move semantics shared refs exclusive refs ref rules in action methods non-lexical lifetimes reborrows borrow splitting interior mutability
- Review, consolidation and integration of concepts
- Generics and traits Display generic types From and Into blanket implementations generic functions operator overloading coherence and the orphan rule impl Trait in argument position impl Trait in return position
- Pointers fat/wide pointers stack and heap arrays dynamically-sized types slices vectors review, consolidation and integration of concepts Deref deref coercion smart pointers static polymorphism dynamic dispatch trait objects dangling pointers and memory leaks are disallowed dynamic return type
- Lifetimes syntax semantics elision
- Closures syntax type inference moves, copies, shared- and exclusive-borrows capture two distinct binding times FnOnce , FnMut and Fn under the hood of closures types with lifetimes Fn-traits recapitulation forcing transfer of ownership fine-grained control of capture returning closures
- Dealing with errors panics when to panic Result and Option ergonomics functors and monads the ? operator thiserror : developer-facing error ergonomics anyhow : user-facing error ergonomics review, consolidation and integration of concepts
- Iterators for-loops consuming, shared and mutable iteration digression: stretching but not breaking the boundaries of safe Rust laziness internal and external iteration collect adapters consumers (catamorphisms) producers (anamorphisms) copied and cloned nested loops overview of utilities fallible iteration
- Fearless concurrency data races eliminated at compile time aliasing XOR mutability Mutex interior mutability stretching the boundaries Rc and Arc Send and Sync marker traits and auto traits data concurrency: Rayon channels
- Builder pattern
- Type-driven development typestate
- the manifest
- managing libraries and executables
- unit tests
- integration tests
- examples
- docs
- benchmarks
- functions
- expression-orientation
- type declaration and inference
- attributes
- modules
- pattern matching
- Option: avoiding the billion-dollar mistake
- ownership semantics triad
- unit structs
- never
- tuple structs
- associated functions
- traits
- structs
- enums
- copy and move semantics
- shared refs
- exclusive refs
- ref rules in action
- methods
- non-lexical lifetimes
- reborrows
- borrow splitting
- interior mutability
- Display
- generic types
- From and Into
- blanket implementations
- generic functions
- operator overloading
- coherence and the orphan rule
- impl Trait in argument position
- impl Trait in return position
- fat/wide pointers
- stack and heap
- arrays
- dynamically-sized types
- slices
- vectors
- review, consolidation and integration of concepts
- Deref
- deref coercion
- smart pointers
- static polymorphism
- dynamic dispatch
- trait objects
- dangling pointers and memory leaks are disallowed
- dynamic return type
- syntax
- type inference
- moves, copies, shared- and exclusive-borrows
- capture
- two distinct binding times
- FnOnce , FnMut and Fn
- under the hood of closures
- types with lifetimes
- Fn-traits recapitulation
- forcing transfer of ownership
- fine-grained control of capture
- returning closures
- panics
- when to panic
- Result and Option
- ergonomics
- functors and monads
- the ? operator
- thiserror : developer-facing error ergonomics
- anyhow : user-facing error ergonomics
- review, consolidation and integration of concepts
- for-loops
- consuming, shared and mutable iteration
- digression: stretching but not breaking the boundaries of safe Rust
- laziness
- internal and external iteration
- collect
- adapters
- consumers (catamorphisms)
- producers (anamorphisms)
- copied and cloned
- nested loops
- overview of utilities
- fallible iteration
- data races eliminated at compile time
- aliasing XOR mutability
- Mutex
- interior mutability
- stretching the boundaries
- Rc and Arc
- Send and Sync
- marker traits and auto traits
- data concurrency: Rayon
- channels
