1. 1. Class Introduction
  2. 2. The Rust Ecosystem
    1. 2.1. Rust Tooling Cheat Sheet
    2. 2.2. Rust Syntax 101
      1. 2.2.1. A Quick Hello World
      2. 2.2.2. Functions, Variables and Scopes
      3. 2.2.3. Overflow and Wrapping
      4. 2.2.4. Structures and Containers
    3. 2.3. Memory Safety
    4. 2.4. The Borrow Checker
    5. 2.5. Lifetimes
    6. 2.6. Reference Counting - Borrow Checker Escape Hatch
    7. 2.7. Data-Race Protection
    8. 2.8. Opt-Out vs Opt-In Safety
    9. 2.9. Safety Wrap-Up
    10. 2.10. Workspaces, Crates, Programs and Libraries
    11. 2.11. Unit Tests
    12. 2.12. Dependencies
    13. 2.13. Benchmarking
  3. 3. Workshop: Build a Basic Rust System
    1. 3.1. Setup
    2. 3.2. Console Text Input
    3. 3.3. Simplest Login System
    4. 3.4. Enumerations
    5. 3.5. Structures, Vectors and HashMaps
    6. 3.6. Serialization/Deserialization
    7. 3.7. Hashing Passwords
    8. 3.8. A CLI Application
  4. 4. Threaded Concurrency
    1. 4.1. Spawning Threads and Returning Data
    2. 4.2. Dividing Workloads
    3. 4.3. ThreadBuilders
    4. 4.4. Scoped Threads
    5. 4.5. Sharing Data
    6. 4.6. Deadlocks, Panics and Poisoning
    7. 4.7. Lock Free Structures
    8. 4.8. Thread Parking
    9. 4.9. Channels
    10. 4.10. CPU Affinity and Thread Priority
    11. 4.11. Rayon
  5. 5. Asynchronous Rust
    1. 5.1. Hello async/await
    2. 5.2. Executors and Runtimes
    3. 5.3. Getting Started with Tokio
    4. 5.4. Blocking Tasks
    5. 5.5. Unit Testing with Tokio
    6. 5.6. File I/O
    7. 5.7. Network I/O
    8. 5.8. Async Channels
    9. 5.9. Async Shared State
    10. 5.10. Selecting Futures
    11. 5.11. Pinning
  6. 6. Traits and Generics
    1. 6.1. Basic Traits
    2. 6.2. Basic Generics
    3. 6.3. Iterators
  7. 7. Make a Web Service in 30 Minutes
    1. 7.1. Working with Databases
    2. 7.2. Axum for Web Services
    3. 7.3. Workshop: Let's Build a Thumbnail Server
  8. 8. Writing Rustacean Code
    1. 8.1. Best Practices: Tooling
      1. 8.1.1. Formatting
      2. 8.1.2. Clippy (the linter)
      3. 8.1.3. Documentation
      4. 8.1.4. Understanding Dependencies
      5. 8.1.5. Managing Your Own Dependencies
      6. 8.1.6. Checking for Vulnerabilities
      7. 8.1.7. Check for Outdated Dependencies
      8. 8.1.8. Denying Dependencies by License
      9. 8.1.9. Build Profiles and Smaller Binaries
    2. 8.2. Code Best Practices
      1. 8.2.1. Favor Iterators
      2. 8.2.2. Minimize Cloning
      3. 8.2.3. Don't Emulate OOP
      4. 8.2.4. Don't Reference Count Everything
      5. 8.2.5. Favor Small Functions
      6. 8.2.6. Clever Code
      7. 8.2.7. Let the Type System Help You
      8. 8.2.8. Floating Point Numbers
      9. 8.2.9. Platform- and Feature- Specific Code
    3. 8.3. General Best Practices
      1. 8.3.1. TANSTAAFL: There Aint No Such Thing As A Free Lunch
      2. 8.3.2. YAGNI: You Aint Gonna Need It
      3. 8.3.3. Domain Boundaries and Network Calls
  9. 9. Error-Handling and Debugging
    1. 9.1. Error Handling
    2. 9.2. Logging and Telemetry
    3. 9.3. Debugging
    4. 9.4. Avoiding Bugs
  10. 10. FFI: Linking Rust and C or C++
    1. 10.1. Packing and Reordering
  11. 11. Rust as a Service
  12. 12. Embedded Challenges
  13. 13. Optimizing Rust
    1. 13.1. Memory Fragmentation
    2. 13.2. Zero Copy
  14. 14. WASM for the Browser
  15. 15. WASM for WASI

KLA Training (Dec 2023)

Code Best Practices