Rust Performance
What a Rust program actually costs, read off the things you can observe: Vec::capacity, strong_count, size_of and the order drops run in. Every claim here is one the snippet proves, which is why none of them is a timing.
Who it is for
Has never measured anything.
For someone confident in the language who wants the traps, the edge cases and the interview questions.
You will get the most out of it if you have written Rust recently enough to read it without effort, and have been surprised by it at least once. If you are picking the language up for the first time, start with Rust Essentials and come back to this one.
It is also built for interview preparation: the questions are the ones that get asked because they separate people who have read the documentation from people who have hit the behaviour in production.
How long it takes
90 graded questions at roughly 45 seconds each is about 68 minutes of answering in total.
At the default five questions a day, and because the session mixes in your other courses, expect around 18 days — call it 3 weeks — to see everything once, plus a few weeks of thinning reviews after that before it is all mastered.
A question is mastered on the third correct answer, once the gap between reviews has grown past a week — so a course cannot be finished in a weekend however long you sit with it.
Question mix
- 60 multiple choice
- 10 concept cards
- 10 predict the output
- 10 put it in order
- 10 matching questions
Syllabus
What you will be asked about
-
01
Stack, Heap & Box
Say what Box moves to the heap and what it leaves behind, and read size_of to tell the two apart.
-
02
Vec Growth & Capacity
Read a Vec's reallocation history off capacity(), and say what with_capacity buys.
-
03
String Building & reserve
Build a String without reallocating on every append, and say why its length is not its character count.
-
04
Clone vs Borrow
Tell a clone that copies a buffer from one that copies a pointer, and say what borrowing would have cost instead.
-
05
Iterators & collect
Say when an iterator does its work and where a collect puts an allocation you did not need.
-
06
size_of & Niches
Predict the size of an enum or an Option, and say when wrapping a value in Option costs nothing.
-
07
Reusing Allocations
Say which operations empty a collection while keeping its buffer, and which throw the buffer away.
-
08
Rc, Arc & Copy-on-Write
Use strong_count to prove no data was copied, and predict when make_mut copies and when it does not.
-
09
dyn Trait vs Generics
Weigh a trait object against a generic parameter using what size_of shows and what the type system allows.
-
10
Why Debug Timings Lie
Say which of a program's behaviours change between a debug and a release build, and what is left worth measuring.
8 more topics, and all 90 questions
Rust Performance is a Pro course. One subscription opens it and every other course in the catalogue, including the ones still being written.
A question from this course
Stack, Heap & Box
What does this print?
use std::mem::size_of;
fn main() {
println!("{} {}", size_of::<Box<[u8; 1000]>>(),
size_of::<[u8; 1000]>());
}Show the answer
A 8 1000
size_of asks how much room the value takes where it is declared, not how much memory it is responsible for. The array is a thousand bytes in the stack frame; boxing it leaves a pointer and nothing else, so the thousand bytes move to the heap and stop appearing here at all. Nothing in this number accounts for the allocation, which is the usual reason people expect 1008.
The rest of the track
Rust at every depth
Rust Essentials
The model underneath the syntax. Assigning a String to a second name moves it and the first name stops working, while an i32 is simply copied; borrowing, Option and exhaustive match are the same compiler insisting you say what happens in every case.
Rust Core
The compiler's side of the argument, made explicit. A lifetime constrains how long a borrow may be used rather than naming a span of time, an iterator chain does nothing at all until something consumes it, and a trait bound is the only thing a generic function is allowed to assume.
Rust Data & Collections
The containers people reach for daily and the places they bite: indexing that panics where get() hands back None, a borrow that freezes the Vec it came from, and an entry() call that writes when you only meant to read. Every snippet here runs, so the answers are what rustc really printed.
Rust Errors & Edge Cases
Failure as a value rather than an exception: Option where there is nothing to say and Result where there is, the ? operator and the From impl it quietly needs, custom error enums, Display against Debug, and the line between an error a caller can act on and a panic that ends the process. Every snippet here either runs or refuses to compile for a reason you can name.
Rust Standard Library
The parts of std that people reimplement by hand: the String and &str split, chars against bytes, the split and trim families, parse and the turbofish, the lazy iterator adaptors, collect into anything that implements FromIterator, the Option and Result combinators, the three sorts, and the Display against Debug distinction. Ten corners where a built-in already does the job and one behaviour in each is not what you assumed.
Rust Idioms & Pitfalls
Ten habits that compile and still mark the code as written by someone thinking in another language: the clone that silences the borrow checker, unwrap as punctuation, String parameters where a slice would do, index loops, a collect nobody reads, a five-line match that is one combinator, &Vec in a signature, lifetimes elision would have written, inherent methods that want to be trait impls, and drop misread. Each one is shown working, then shown costing something.
Rust Advanced
The type system and the borrow checker in earnest: elision that quietly ties a return to &self, two &mut borrows that look disjoint and are not, RefCell panicking at run time where the compiler would have refused. Every snippet here either compiles or fails to for a reason you can name.
Rust Testing
What a Rust assertion actually claims, and where that claim is weaker than it looks. assert_eq! and its argument order, should_panic and its substring match, tests that return Result, cfg(test) modules against integration tests, doc tests, floats, and the difference between a failed assertion and a panic somewhere else.
Rust Interview Questions
The questions a Rust interview actually turns on: where a value's owner is at each line, why two borrows that look disjoint are not, and what a lifetime annotation promises and what it cannot. Ownership and moves, aliasing, lifetimes, String against &str, Vec against slices, Option and Result, traits and dispatch, monomorphisation, Rc and RefCell, and what makes a type safe to send between threads.
Start Rust Performance
in tomorrow’s session.
Enrol and this course joins your daily five, mixed in with everything else you are studying — 90 questions spread over about 18 days rather than dropped on you at once.
Browse the catalogue