Programming
Rust Programming
Overview
This hands‑on, instructor‑led course introduces systems programmers, backend engineers, and DevOps professionals to the Rust programming language. Over five intensive days (or eight half‑day sessions), participants progress from first compiling “Hello, Rust!” to writing production‑ready, concurrent, and asynchronous applications. Emphasis is placed on Rust’s unique ownership model, fearless concurrency, memory‑safety guarantees, and modern toolchain (Cargo, Clippy, Rustfmt). Daily lab challenges reinforce theoretical concepts, culminating in a capstone project that integrates file I/O, networking, and multithreading.
Duration
5 days
Course Materials
- Slide deck (PDF)
- Annotated lab workbook (PDF & Markdown)
- GitHub starter repo with incremental branches
- Cheat‑sheet: common Cargo commands & syntax tips
- Supplemental reading list and community links
Who Should Take This Course
Audience
- Backend or systems developers switching from C/C++, Go, or Java
- DevOps/SREs looking to build performant CLI tools
- Computer‑science students exploring modern systems languages
Prerequisites
- Comfortable in at least one programming language (variables, control flow, functions)
- Familiarity with basic memory concepts (stack vs. heap, pointers/references)
- Git installed and basic command‑line navigation
- Laptop capable of running recent stable Rust (1.79+) and VS Code / IntelliJ Rust plugin
Why You Should Take This Course
By the end of this course, participants will be able to:
- Install and manage Rust toolchains with rustup and create projects with Cargo.
- Explain and leverage ownership, borrowing, and lifetimes to write memory‑safe code without garbage collection.
- Build robust types using structs, enums, pattern matching, and traits.
- Write generic and trait‑bound functions leveraging Rust’s zero‑cost abstractions.
- Handle errors idiomatically with Result, Option, and the ? operator.
- Implement concurrent and asynchronous programs using threads, channels, and async/await with Tokio.
- Test, benchmark, document, and package reusable crates for publication to crates.io.
- Optimize and profile Rust code for performance, memory usage, and safety.
Course Outline
Day 1 – Rust Toolchain & Language Basics (8 hrs)
- Course kickoff, environment setup (rustup, cargo new)
- Syntax tour: variables, immutability, shadowing
- Scalar & compound types; pattern matching with match
- Control flow (if, loop, while, for)
- Lab 1: Build a temperature‑converter CLI
Day 2 – Ownership, Borrowing & Error Handling (8 hrs)
- The ownership model: move semantics, copy types
- References & borrowing rules, slices
- Lifetimes primer; compiler error anatomy
- Error handling: Result, Option, idiomatic ? propagation
- Lab 2: Refactor a file parser to eliminate panics
Day 3 – Data Abstractions & Generics (8 hrs)
- Structs & methods, tuple structs, unit structs
- Enums & algebraic data types; exhaustive pattern matching
- Traits & default implementations; trait objects vs. generics
- Generic functions, zero‑cost abstractions, monomorphization
- Lab 3: Implement a pluggable logger with trait‑based backends
Day 4 – Concurrency & Asynchronous Programming (8 hrs)
- The Rust memory model; Send & Sync markers
- Native threads & message passing (channels)
- Shared‑state concurrency (Mutex, RwLock, Arc)
- Futures, async/await, and the Tokio runtime
- Lab 4: Build an async TCP echo server with graceful shutdown
Day 5 – Ecosystem, Testing & Capstone (8 hrs)
- Module system, workspaces, re‑exports; publishing to crates.io
- Documentation with rustdoc; doctests
- Unit, integration, and property‑based tests; benchmarking harness
- Profiling & optimization (cargo‑flamegraph, perf, cargo‑audit)
- Capstone: Pair programming—create a multi‑threaded file indexer or REST microservice; peer code review & demos
- Course wrap‑up, certification exam, feedback survey
Optional Advanced Topics (for extended track)
-
- Unsafe Rust, FFI with C & C++
- WebAssembly targets and wasm‑bindgen
- Building GUIs with egui or Druid
- Embedded & no‑std development
- Formal verification with kani and creusot
FAQs
- Is there a discount available for current students?UMBC students and alumni, as well as students who have previously taken a public training course with UMBC Training Centers are eligible for a 10% discount, capped at $250. Please provide a copy of your UMBC student ID or an unofficial transcript or the name of the UMBC Training Centers course you have completed. Asynchronous courses are excluded from this offer.
- What is the cancellation and refund policy?Student will receive a refund of paid registration fees only if UMBC Training Centers receives a notice of cancellation at least 10 business days prior to the class start date for classes or the exam date for exams.
- What is Live Online training?Classes marked Live Online have the same content and expert instructors as our classroom training, but are delivered entirely online through our virtual classroom environment. Each class session is live, and led by an Instructor.