Philosophy

Translation in progress

The English edition follows the Chinese edition, which is the primary language of authoring. This page is a summary; the full text will land as the course is written.

A thinking course, not a coding course

There is no shortage of material that teaches you how to write Rust — the official Book (The Rust Programming Language) is already an excellent guide to syntax and practice. What’s missing is a course focused on shifting and building mental models: understanding why Rust is designed the way it is, so that the right intuitions are in place before you write your first line.

This course and the Book form a two-track companion:

	This course (thinking track)	The Book (practice track)
Question answered	“Why?”	“How?”
Deliverable	Mental models, design intuition, paradigms	Syntax, coding skill, practice
How you learn	Read, think, derive, run experiments	Read, type, build

Reinventing Rust

We don’t start from “here are Rust’s rules”. We start from a classic problem every language designer faces:

Safety, performance, expressiveness — why are they so hard to have at once? If you had to design a language to break this hard triangle, what would you do?

Along that line we derive ownership, moves, borrowing, lifetimes and traits step by step, until we discover these aren’t arbitrary constraints imposed by a compiler, but the necessary parts of the best solution we found ourselves.

Verified code experiments: predict → try → explain

Although this course doesn’t teach coding, key derivation points include carefully designed minimal Rust experiments — not exercises, but empirical tests of the mental model:

1. Predict: given 10–15 lines of code, will it compile? Why?
2. Try: run it and read what the compiler says.
3. Explain: connect the compiler’s verdict back to the “safety protocol” we derived.

You are not a programmer writing code; you are a scientist running an experiment.

Who it’s for

Developers with experience in at least one other language:

• Dynamic languages (Python / JS / Ruby) — building stack/heap intuition from scratch. The main narrative pace is set for this audience.
• Managed languages (Java / Go / C#) — the biggest hurdle is migrating away from OOP thinking.
• Systems languages (C / C++) — the hurdle is false familiarity: ownership ≠ RAII, traits ≠ vtables, lifetimes ≠ pointer validity. We don’t exclude you, but we don’t cater to the shortcut either.

What this course does not cover

Syntax details and hands-on coding (use the Book), async/await, macros, unsafe, and domain-specific frameworks. Clear boundaries set the right expectation: after this course, everything practical you learn about Rust will come faster, because the model is already in place.