1. Introduction
2. 1. Lab 01: Unsafe system programming
   1. 1.1. Development setup
   2. 1.2. Memory unsafety
   3. 1.3. Smashing the stack
3. 2. Lab 02: Hardening system programming
   1. 2.1. Unit testing
   2. 2.2. Stack overflow detection
   3. 2.3. Memory leak detection
4. 3. Lab 03: Rust and references
   1. 3.1. Your first Rust program
   2. 3.2. Using a Rust tutorial
   3. 3.3. References
   4. 3.4. Lifetimes
   5. 3.5. Lifetimes: a complex case
5. 4. Lab 04: Error handling
   1. 4.1. Web page retrieval
   2. 4.2. Name identification
   3. 4.3. Sets intersection
   4. 4.4. File system
   5. 4.5. Easier errors
   6. 4.6. Prettier messages
   7. 4.7. Even prettier messages
6. 5. Lab 05: Complex data structures
   1. 5.1. Recursive data structures
   2. 5.2. Solving common tasks with traits
   3. 5.3. Refactoring with iterators
   4. 5.4. Going generic
7. 6. Lab 06: Packaging, testing, and fuzzing
   1. 6.1. Packaging
   2. 6.2. Testing
   3. 6.3. Property testing
   4. 6.4. Fuzzing
8. 7. Lab 07: Unsafe, FFI, procedural macros
   1. 7.1. FFI: Foreign library setup
   2. 7.2. FFI: Low-level bindings
   3. 7.3. FFI: Testing the bindings
   4. 7.4. FFI: High-level bindings
   5. 7.5. Macros: Setup
   6. 7.6. Macros: English-to-French
   7. 7.7. Macros: Chaining computations
   8. 7.8. Macros: Secure token
9. 8. Lab 08: Parallelism
   1. 8.1. Counting characters
   2. 8.2. Getting big
   3. 8.3. Parallel computing
   4. 8.4. Benchmarking
   5. 8.5. If you have more time
10. 9. Lab 09: Asynchronous programming
    1. 9.1. An asynchronous client
    2. 9.2. An asynchronous server