Skip to content
New this month 24 fresh C++, C#, F#, JavaScript, TypeScript and Lua courses just landed. Browse new releases Use code WELCOME10 for 10% off your first order · 14-day refund
WisdomCharms — home
Cart 0 items in cart
Systems & Low-Level Intermediate

Rust Intermediate: Traits, Lifetimes and Error Handling

Move from writing Rust that compiles to designing Rust APIs other people enjoy using.

Rated 5.0 out of 5 from 1 review 10 students

DO Created by Dimitri Orlov

  • Last updated August 2026
  • English
  • 8h 32m of material
  • 64 lessons

What you will learn

8 concrete outcomes

Every bullet below is something you will have built, shipped or be able to explain by the time you finish the last lesson.

  • Design traits with associated types, supertraits and blanket implementations
  • Choose static or dynamic dispatch deliberately, with measurements to back the choice
  • Read and write lifetime annotations, including structs that hold references
  • Implement the standard traits that make your types feel native to Rust
  • Design library error types with thiserror and application handling with anyhow
  • Use Rc, Arc, RefCell and Mutex correctly and know the cost of each
  • Write declarative macros where they genuinely reduce duplication
  • Publish a documented, semver-correct crate to crates.io

Course curriculum

6 modules · 64 lessons · 8h 32m of material

12 lessons running 1h 36m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

12 lessons running 1h 34m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

10 lessons running 1h 18m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

10 lessons running 1h 20m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

9 lessons running 1h 12m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

11 lessons running 1h 28m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

6 modules · 64 lessons

8h 32m total length

Requirements

Short list, and deliberately so. If you meet these you can start today.

  • Working Rust knowledge: ownership, borrowing, enums and basic traits
  • A stable Rust toolchain installed with Cargo
  • Experience building at least one small Rust project of your own

About this course

You can write working Rust with a partial understanding of traits and lifetimes, right up to the point where you design something for others to use. Then the questions get sharp: should this take a reference or an owned value, should this be generic or a trait object, what lifetime does this struct actually need. This course answers them properly.

Traits are covered in depth: associated types versus generic parameters, blanket implementations, the orphan rule, supertraits, the standard traits worth implementing such as From, TryFrom, Display, Deref and IntoIterator, and static versus dynamic dispatch with measured cost. Lifetimes get a full module including elision rules, structs holding references, higher-ranked bounds and the errors that look impossible until the rule behind them is visible.

The rest covers interior mutability with Cell, RefCell and the smart pointer family, error design with thiserror for libraries and anyhow for applications, iterator implementation, declarative macros, and API design conventions from the Rust API guidelines: builders, newtypes, sealed traits and semantic versioning. A closing module covers documentation, doctests and publishing to crates.io.

Topics covered

Frequently asked questions

Still unsure about something? Write to misteryjj100@gmail.com and a human answers, usually the same working day.

Async is touched where it interacts with traits and lifetimes, such as pinning and lifetime bounds on futures, but the full async ecosystem is not the subject here.

Yes. The final module takes a library you build during the course through documentation, doctests, semantic versioning and an actual crates.io publish.

Only enough to explain what safe abstractions are protecting. The systems programming course covers unsafe, FFI and raw pointers in full.

Checkout is handled on our provider's secure payment page. The moment your payment clears we email your personal access link and access code to the address you used at checkout, and the same link appears in your account library. There is nothing to install and nothing to wait for.

Email misteryjj100@gmail.com within 14 days of your purchase, quote your order number, and we refund the full amount to your original payment method. No form to fill in and no questions about how much of the course you watched.

What students say

Reviews are written by people who bought this course. We publish the critical ones too.

5.0

Rated 5.0 out of 5

Course rating · 1 review

Rating distribution

  • 5 stars 100%
  • 4 stars 0%
  • 3 stars 0%
  • 2 stars 0%
  • 1 star 0%
  • SF

    Sigrid Falk

    Rust developer

    Jan 2026
    Rated 5.0 out of 5

    Error design for libraries versus applications

    The distinction is stated plainly early on, that a library exposes an enumerated error and an application flattens and adds context, and then it holds all the way through to the publishing chapter. I had been mixing the two and producing types nobody enjoyed matching on.

Your instructor

DO

Dimitri Orlov

Rust engineer and performance specialist

  • 64 students taught
  • 4 courses published
  • 4.8 instructor rating
  • Rust
  • Low-level programming
  • Performance tuning
  • Embedded systems

Dimitri writes Rust for networking gear and battery-powered devices, and came to it after a long stretch of production C he does not miss. He teaches ownership and borrowing by showing the exact C bug each rule prevents, which makes the borrow checker feel like a colleague rather than an obstacle. His courses build a real binary — a parser, a server, a no-std firmware image — and then take a profiler to it. He reviews for a Rust working group and speaks at systems meetups.

See every course by Dimitri Orlov
$59 USD

One-time payment · lifetime access

The WisdomCharms dispatch

One useful email a week. No fluff, no spam.

New course releases, discount codes before anyone else, and a short, practical breakdown of one technique — a prompt pattern, a C++ idiom, a TypeScript trick — that you can use the same day.

  • Subscriber-only launch pricing
  • Unsubscribe in one click
  • We never sell your address

By subscribing you agree to our Privacy Policy. Questions? Write to misteryjj100@gmail.com.