Rust Fundamentals with Generative AI

Section 1: Getting to Know Rust and Its Ecosystem

• Why organisations choose Rust: memory safety, performance and safe concurrency
• Where Rust fits and where it does not, compared with Go, Java, C# and Python
• The six-week release cycle, the edition concept and what changed in Edition 2024
• crates.io, docs.rs, The Rust Book and the community's main learning resources

Section 2: Lab: Installing and Using the Toolchain

• Install rustup, choose the stable toolchain and keep it up to date
• Core cargo commands: new, build, run, check, add, and the structure of Cargo.toml
• Format code with rustfmt and check quality with clippy
• Set up VS Code with rust-analyzer and learn to read compiler error messages
• Lab: create a first project and fix clippy warnings

Section 3: Syntax and Basic Data Types

• Variables, immutability by default, mut and shadowing
• Scalar types, tuples, arrays and safe type conversion
• Functions, expressions versus statements, and return values
• Control flow: if, loop, while, for and ranges
• Lab: exercises writing calculation functions and loops over data

Section 4: Structs, Enums and Pattern Matching

• Define structs and methods with impl, including associated functions
• Enums that carry data, and Option in place of null
• match, if let and let else for exhaustive case handling
• Lab: design the Ticket struct and enums for status and urgency

Section 5: Workshop: Modules and the TicketPilot CLI

• mod, pub, use and splitting code into files by responsibility
• Library crates versus binary crates, and project structure
• Basic command line arguments with clap
• Workshop: create the TicketPilot project and a CLI command that lists sample tickets

Section 6: Ownership and Memory Management

• Stack versus heap, and why Rust does not need a garbage collector
• Ownership rules, move semantics and freeing memory with Drop
• Clone versus Copy, and the real cost of cloning
• Lab: move values between variables and functions and read what the compiler says

Section 7: Borrowing and References

• Immutable references (&T) and mutable references (&mut T)
• The borrowing rules, and how to read borrow checker errors line by line
• Common problems when starting with Rust and how to fix them by reasoning
• Lab: fix code that does not compile without reaching for clone as a shortcut

Section 8: Lifetimes Basics

• What a lifetime means and the lifetime elision rules
• Annotating lifetimes in functions and in structs that hold references
• Choosing between holding a reference and owning the data
• Lab: write functions that return references the compiler accepts

Section 9: Strings, Slices and Collections

• String versus &str, and working with UTF-8 text including Thai
• Slices of arrays and vectors
• Vec, HashMap and HashSet, and choosing the right one for the job
• Iterating by borrowing (iter), mutating (iter_mut) and moving (into_iter)
• The Entry API for counting and grouping data

Section 10: Workshop: Searching and Grouping Tickets

• Write functions that search and filter tickets by status and urgency
• Group tickets by category with HashMap and the Entry API
• Design function signatures that take references instead of moving values
• Workshop: review the code to remove unnecessary clones and compare before and after

Section 11: Traits and Generics

• Define and implement traits, with default methods
• Generics with trait bounds, and impl Trait
• Trait objects (dyn Trait) and choosing static or dynamic dispatch
• Common standard traits: Debug, Display, From and Default
• Lab: separate the ticket repository behind a trait

Section 12: Closures and Iterators

• Closures and capturing variables from the surrounding scope
• Iterator adapters: map, filter, fold and collect
• Writing functional-style code that stays readable and avoids copying data
• Lab: rewrite the Day 2 functions with iterators

Section 13: Systematic Error Handling

• Result, the ? operator, and when panic! is the right choice
• Create library error types with thiserror
• Use anyhow at application level and add context to errors
• Lab: create TicketPilot's error type and propagate errors correctly

Section 14: Serialisation with serde

• Serialize and Deserialize with derive
• Read and write JSON files with serde_json
• Field renaming, default values and optional fields
• Lab: load sample ticket data from a JSON file

Section 15: Workshop: Testing in Rust

• Unit tests with #[test] and cargo test
• Integration tests in the tests folder
• Use traits to build a fake repository for testing
• Workshop: a JSON file repository and an in-memory repository, with unit tests covering the main functions

Section 16: Async Rust with Tokio

• async/await, futures and the role of the runtime
• #[tokio::main], tokio::spawn and running work concurrently
• Sharing state between tasks with Arc and Mutex or RwLock
• Timeouts and cancellation
• Lab: make several HTTP calls concurrently with reqwest

Section 17: Lab: Building a Web API with axum

• Routers, handlers and extractors (Path, Query, Json, State)
• Returning responses and errors as consistent JSON
• Middleware with tower, such as logging and timeouts
• Lab: endpoints to list tickets and fetch a single ticket

Section 18: LLM Basics for Developers

• Tokens, context windows and the cost of each request
• Designing instructions and input for summarising and categorising
• Personal data under PDPA, and criteria for choosing a cloud or local model
• Why LLM output must always be checked before it is used

Section 19: Connecting to the OpenAI Responses API and Ollama

• Install async-openai with the responses feature and store the API key securely
• Send requests, read results, and handle retries and rate limits
• Install Ollama and a small model that runs on a laptop
• Call Ollama over HTTP with reqwest and through its OpenAI-compatible endpoint
• Lab: compare quality, speed and limits of cloud and local models

Section 20: Workshop: The TicketPilot API Calls an LLM

• Design the POST /tickets/{id}/analyze endpoint
• Send a ticket to the LLM to summarise and categorise it
• Handle LLM errors and timeouts so the API still responds
• Workshop: test the API with several types of sample ticket

Section 21: Lab: Designing an LLM Provider with a Trait

• Define an LlmProvider trait and implement it for OpenAI and Ollama
• Choose the provider from configuration to meet the organisation's data requirements
• Test with a fake provider without calling a real API
• Lab: switch providers without changing the business logic

Section 22: Structured Output and Validating Results

• Define a JSON schema for the analysis: category, urgency, summary and suggested reply
• Convert results into structs with serde and handle output that does not match the schema
• Bounded fallback and retry
• Lab: ticket analysis the system can use straight away

Section 23: Streaming and Tool Calling Basics

• Receive streamed output and pass it to the client with server-sent events in axum
• The tool calling concept: letting the LLM call a Rust function to look up related tickets
• Restrict permissions and validate arguments before running any function
• Lab: a streaming endpoint for drafting replies

Section 24: Production Readiness and Docker

• Structured logging with tracing
• Managing configuration and secrets through environment variables
• Graceful shutdown and a health check endpoint
• Release builds, reducing binary size and a multi-stage Dockerfile
• Lab: run the service alongside Ollama with Docker Compose

Section 25: Master Workshop: TicketPilot AI Service

• Bring together the switchable provider, structured output and the streaming endpoint
• Add logging, configuration and unit tests for the key parts
• Build a Docker image and run it with Ollama
• Present the result and summarise how to apply it to your organisation's systems