Mental Models
Layer 2: Design Choices
Core Question
What's the right way to think about this Rust concept?
When learning or explaining Rust:
- What's the correct mental model?
- What misconceptions should be avoided?
- What analogies help understanding?
Key Mental Models
| Concept | Mental Model | Analogy |
|---------|--------------|---------|
| Ownership | Unique key | Only one person has the house key |
| Move | Key handover | Giving away your key |
| &T | Lending for reading | Lending a book |
| &mut T | Exclusive editing | Only you can edit the doc |
| Lifetime 'a | Valid scope | "Ticket valid until..." |
| Box<T> | Heap pointer | Remote control to TV |
| Rc<T> | Shared ownership | Multiple remotes, last turns off |
| Arc<T> | Thread-safe Rc | Remotes from any room |
Coming From Other Languages
| From | Key Shift | |------|-----------| | Java/C# | Values are owned, not references by default | | C/C++ | Compiler enforces safety rules | | Python/Go | No GC, deterministic destruction | | Functional | Mutability is safe via ownership | | JavaScript | No null, use Option instead |
Thinking Prompt
When confused about Rust:
-
What's the ownership model?
- Who owns this data?
- How long does it live?
- Who can access it?
-
What guarantee is Rust providing?
- No data races
- No dangling pointers
- No use-after-free
-
What's the compiler telling me?
- Error = violation of safety rule
- Solution = work with the rules
Trace Up ↑
To design understanding (Layer 2):
"Why can't I do X in Rust?"
↑ Ask: What safety guarantee would be violated?
↑ Check: m01-m07 for the rule being enforced
↑ Ask: What's the intended design pattern?
Trace Down ↓
To implementation (Layer 1):
"I understand the concept, now how do I implement?"
↓ m01-ownership: Ownership patterns
↓ m02-resource: Smart pointer choice
↓ m07-concurrency: Thread safety
Common Misconceptions
| Error | Wrong Model | Correct Model |
|-------|-------------|---------------|
| E0382 use after move | GC cleans up | Ownership = unique key transfer |
| E0502 borrow conflict | Multiple writers OK | Only one writer at a time |
| E0499 multiple mut borrows | Aliased mutation | Exclusive access for mutation |
| E0106 missing lifetime | Ignoring scope | References have validity scope |
| E0507 cannot move from &T | Implicit clone | References don't own data |
Deprecated Thinking
| Deprecated | Better |
|------------|--------|
| "Rust is like C++" | Different ownership model |
| "Lifetimes are GC" | Compile-time validity scope |
| "Clone solves everything" | Restructure ownership |
| "Fight the borrow checker" | Work with the compiler |
| "unsafe to avoid rules" | Understand safe patterns first |
Ownership Visualization
Stack Heap
+----------------+ +----------------+
| main() | | |
| s1 ─────────────────────> │ "hello" |
| | | |
| fn takes(s) { | | |
| s2 (moved) ─────────────> │ "hello" |
| } | | (s1 invalid) |
+----------------+ +----------------+
After move: s1 is no longer valid
Reference Visualization
+----------------+
| data: String |────────────> "hello"
+----------------+
↑
│ &data (immutable borrow)
│
+------+------+
| reader1 reader2 (multiple OK)
+------+------+
+----------------+
| data: String |────────────> "hello"
+----------------+
↑
│ &mut data (mutable borrow)
│
+------+
| writer (only one)
+------+
Learning Path
| Stage | Focus | Skills | |-------|-------|--------| | Beginner | Ownership basics | m01-ownership, m14-mental-model | | Intermediate | Smart pointers, error handling | m02, m06 | | Advanced | Concurrency, unsafe | m07, unsafe-checker | | Expert | Design patterns | m09-m15, domain-* |
Related Skills
| When | See | |------|-----| | Ownership errors | m01-ownership | | Smart pointers | m02-resource | | Concurrency | m07-concurrency | | Anti-patterns | m15-anti-pattern |