Rust explainers

Choosing between generics, impl Trait, &dyn, Box<dyn> and enums

Compare generic parameters, trait objects and enums by type relationships, ownership and extension needs. Includes a complete example of cloning boxed trait objects.

About 8 min Read explainer

Monomorphisation: what generics compile to, and what that costs

Understand generic code generation, compare static and dynamic dispatch, and use a small generic wrapper around shared implementation code.

About 5 min Read explainer

async fn in traits and RPITIT: what works and what does not

Return hidden iterator and future types from traits, choose explicit Send bounds, and use boxed returns when you need dynamic dispatch.

About 5 min Read explainer

Benchmarking: measure the work you intend to compare

Build useful benchmarks by defining the workload, limiting unwanted optimization, measuring variation, and checking what timing and allocation counts actually include.

About 7 min Read explainer

Profiling Rust: finding the hot spot before you optimise it

Choose a representative workload, collect an optimized profile, and test whether a targeted change improves the result.

About 6 min Read explainer

SIMD in Rust: what is stable, what is not

The three ways to use SIMD in Rust as of Rust 1.98 (auto-vectorisation, core::arch intrinsics and the nightly-only std::simd), what each one requires, and an order in which to try the options on stable Rust.

About 15 min Read explainer

Choosing your concurrency primitive

Choose concurrency tools by the state they protect, the work they coordinate and how they shut down. Compare atomics, locks, channels and scoped threads with runnable examples.

About 8 min Read explainer

Reduce deadlock risks in shared-state code

Use consistent lock ordering, explicit guard lifetimes and complete critical sections. Learn what these techniques prevent and where they need support from tests and diagnostics.

About 6 min Read explainer

Choosing atomic memory orderings

Learn when relaxed operations are enough, how release/acquire publishes data, and what sequential consistency adds. Use reasoning and tests together.

About 7 min Read explainer

Send and Sync as unsafe auto traits

Distinguish transferring ownership from sharing references, understand conditional trait bounds, and review what an unsafe Send or Sync implementation must justify.

About 6 min Read explainer

False sharing: when separate counters compete for a cache line

Understand how nearby writes can cause cache contention, when padding helps, and when local accumulation is a better fit.

Read explainer

What passing concurrency tests tells you

Understand the grader's limits and choose additional checks for memory safety, thread schedules and algorithm behavior.

About 6 min Read explainer

Why async exists: blocking, threads, and the cost of waiting

Async lets one thread keep many waiting operations in progress instead of dedicating a blocked thread to each. It does not make computation faster. Rust's standard library provides the syntax, the Future trait and the waker types, but no executor or async I/O.

About 12 min Read explainer

`Waker` and `Context`: the wakeup contract

What a future must do with the waker when it returns Pending, why it must keep the waker from the most recent poll, and how a missed wakeup can leave a task idle with no error.

About 11 min Read explainer

What `async fn` actually compiles to

Calling an async fn runs none of its body. It returns a compiler-generated future: a state machine that stores the values it still needs at each await. That model explains why these futures are not Unpin, why a recursive call needs a Box, why a lock guard held across an await keeps the lock, and why nested futures can grow large.

About 12 min Read explainer

Pin and Unpin: keeping a value at a stable address

Learn why some futures need a stable address, what Pin guarantees, and how Unpin changes the operations available through a pinned pointer.

About 6 min Read explainer

How tokio and smol build on these primitives

How the parts of this track's small runtime compare with tokio and smol: per-worker queues with work stealing, an operating-system wait combined with timers, one allocation per task that also backs its wakers, and join handles with different cancellation rules.

About 16 min Read explainer

Rust explainers

Choosing between generics, impl Trait, &dyn, Box<dyn> and enums

Monomorphisation: what generics compile to, and what that costs

async fn in traits and RPITIT: what works and what does not

Benchmarking: measure the work you intend to compare

Profiling Rust: finding the hot spot before you optimise it

SIMD in Rust: what is stable, what is not

Choosing your concurrency primitive

Reduce deadlock risks in shared-state code

Choosing atomic memory orderings

Send and Sync as unsafe auto traits

What passing concurrency tests tells you

Why async exists: blocking, threads, and the cost of waiting

`Waker` and `Context`: the wakeup contract

What `async fn` actually compiles to

Pin and Unpin: keeping a value at a stable address

How tokio and smol build on these primitives

Choosing between blocking and async code

Safe and unsafe Rust: obligations and soundness

What is Undefined Behaviour? The complete list

Aliasing, mutable references and unsafe code

Stacked Borrows, Tree Borrows and Miri

Safety invariants and privacy: unsafe contaminates the module

Why macros exist: code that writes code

Choosing between generics, impl Trait, &dyn, Box<dyn> and enums

Monomorphisation: what generics compile to, and what that costs

async fn in traits and RPITIT: what works and what does not

Benchmarking: measure the work you intend to compare

Profiling Rust: finding the hot spot before you optimise it

SIMD in Rust: what is stable, what is not

Choosing your concurrency primitive

Reduce deadlock risks in shared-state code

Choosing atomic memory orderings

Send and Sync as unsafe auto traits

False sharing: when separate counters compete for a cache line

What passing concurrency tests tells you

Why async exists: blocking, threads, and the cost of waiting

Waker and Context: the wakeup contract

What async fn actually compiles to

Pin and Unpin: keeping a value at a stable address

How tokio and smol build on these primitives

Choosing between blocking and async code

Safe and unsafe Rust: obligations and soundness

What is Undefined Behaviour? The complete list

Aliasing, mutable references and unsafe code

Stacked Borrows, Tree Borrows and Miri

Safety invariants and privacy: unsafe contaminates the module

Why macros exist: code that writes code

`Waker` and `Context`: the wakeup contract

What `async fn` actually compiles to