A Tale of Teaching Rust

Transcript

1. A Tale of Teaching Rust 
 Andrew Brinker
2. Hi! I’m Andrew!
3. I’m here to tell you a story
4. Act 1: The Idea
5. In early 2017, I was asked to teach a class on programming languages
6. I replaced C with Rust,
 because it’s 2017
7. 10 weeks long. Enough time for Rust, right?
8. Normally: Lisp, C, Java, Prolog Me: Haskell, Rust, Java, Prolog
9. 3 weeks for Rust. No time to teach it all!
10. Act 2: The Pitch
11. What is Rust’s elevator pitch?
12. Zero-cost abstractions Move semantics Guaranteed memory safety (without GC) Threads without data races Trait-based generics Type inference Minimal runtime Optional unsafety And more!
13. Zero-cost abstractions Move semantics Guaranteed memory safety (without GC) Threads without data races Trait-based generics Type inference Minimal runtime Optional unsafety And more!
14. Week 1: 
 Safety without GC = Ownership + borrows + lifetimes
15. Week 2: 
 Threads without data races = Week 1 + Send + Sync
16. Week 3: 
 Explain why it matters
17. Act 3: The Plan
18. 26 upper-division undergrads Wide variety of backgrounds None knew Rust going in Some heard Rust was hard
19. What’s the approach?
20. Be very concrete: Lots of examples Live coding
21. Potential challenge: this requires the teacher to know Rust well
22. Suggestions: 1. Do examples beforehand 2. Treat rustc as a teacher 3. Don’t fake it
23. Know the ecosystem of tools
24. Rust Playground The (New) Rust Book Rustlings ❤ Godbolt
25. Give room & tools to explore
26. Act 4: The Class
27. Lab 1: Safety without GC
28. All data has an owner Ownership can be moved Old owner can’t use data Simple types can be copied
29. Students will realize this is painful to work around
30. Then introduce borrows
31. Aliasing XOR Mutability
32. Emphasize the rules Give lots of examples Show some complex cases
33. Students will ask how it works
34. Then introduce lifetimes
35. Be very explicit: lifetimes are scopes, and all borrows have one
36. The compiler tracks them whether they’re explicit or not
37. You can’t assign a lifetime
38. Sometimes you need code that’s generic over lifetimes
39. That’s when you make lifetimes explicit
40. If you have time (I didn’t), introduce Cell & RefCell
41. Assignment: do the move semantics Rustlings exercises
42. Lab 2: Threads w/out data races
43. Start with de fi nitions
44. Concurrency: Multiple threads of control Parallelism: Multiple threads of control, running at once Deadlock: All threads are stopped (dead) Livelock: Threads are live, but not progressing Data race: Non-syncing mutable data across threads Race condition: Result depends on execution order And so on…
45. Same as before, be concrete
46. Talk about Send and Sync
47. Explain why some types implement them, and some don’t
48. Don’t explain unsafe traits (yet)
49. Introduce the key stdlib types: Arc, Rc, Mutex, RwLock
50. Explain why Arc is Sync but Rc isn’t
51. Make clear that Rust stops data races, not race conditions
52. Easy parallelism is the best! Show it off! Rayon, Hyper w/ Tokio, Crossbeam
53. Assignment: solve the Dining Philosophers problem
54. Lab 3: Safety & Security
55. Bold move: Introduce unsafe
56. Explain Safe Rust & Unsafe Rust
57. Unsafe functions + unsafe traits: Have requirements the compiler can’t check The programmer has to check instead
58. Unsafe blocks + unsafe trait impls: Tell the compiler “I’ve checked these!” The compiler assumes you did so correctly
59. Safe Rust must trust Unsafe Rust
60. Unsafe Rust can’t trust Safe Rust
61. Safety lies at the module boundary
62. Safety has an impact on security
63. Embedded environments often can’t tolerate GC
64. Lots of old code in C and C++
65. Lots of common vulns still being written
66. Assignment: fi nd a CVE that could have been stopped by Rust
67. Act 5: The Results
68. Ended the series with
 a post-Rust survey
69. Here’s what my students said:
70. Students thought the compiler was too picky
71. And the syntax was weird
72. A couple said they only liked Rust in comparison to Haskell, which was too weird
73. Don’t despair!
74. Most students wanted to try Rust some more!
75. Students felt Rust was really powerful
76. Students felt more con fi dent than they did with C++
77. And there are more
 reasons for optimism
78. The ergonomics initiative will help new Rustaceans!
79. Students did way better with ownership, borrowing, and lifetimes than expected!
80. Conclusion
81. Can Rust be taught in 3 weeks? Not quite, but you can get students excited for more!
82. Can Rust be taught to newer programmers? You bet!
83. Can Rust overcome the bad press on its learning curve? I sure think so!
84. Thank you very much!
85. Twitter: @AndrewBrinker Github: @AndrewBrinker Class site: proglangs.com My site: andrewbrinker.com