Rust Programming: From Ownership to Fearless Concurrency

You'll trace Rust's long road from its early years to a stable 1.0 release, the move to an independent foundation, and the formal editions of 2015, 2018, 2021, and 2024. You'll see how key milestones reshaped the language, how the six-week release train keeps it moving forward, and how its governance and culture matured away from its browser-project origins without ever breaking your code.

You'll exercise Rust's operators across integers and floats, including arithmetic, comparison operators that return bool, and the short-circuiting && and || logical operators. You'll see integer division truncation, how the remainder operator behaves with negative numbers, and why Rust refuses to implicitly convert numeric types, then compute the area of a circle in f64 and explain why an integer would have given the wrong answer.

You'll branch with if and else and then take a step that surprises most newcomers: using an if/else block directly as the value of a let binding. You'll learn that almost everything in Rust is an expression and that both arms must produce the same type, and you'll write a single let statement that classifies a value into one of several tiers.

You'll meet match, Rust's checked and exhaustive alternative to the switch statement, matching on an integer with several arms and a catch-all underscore, then on a boolean to watch the compiler enforce exhaustiveness. You'll understand why the compiler refuses to build if any case is missed, and you'll also see range patterns and a match used directly as the value of an expression.

You'll write all three of Rust's loops: an unconditional loop that breaks with a value, a while loop counting down, and a for loop running over a range. You'll see why idiomatic Rust prefers for-in-range over manual index juggling and how break can yield a value out of a loop, then sum the first N squares with a for loop.

You'll define functions with typed parameters and return types and call them from main, learning that the last expression in a function body is its return value with no semicolon needed, alongside explicit early returns and why every parameter must be annotated. You'll also feel the "semicolon trap" and compose several small functions together into a final result.

You'll get the lay of the land of Rust's tooling and ecosystem: rustc the compiler, Cargo the build system and package manager, crates.io the registry, rustup the installer, plus rustfmt, clippy, rust-analyzer, and docs.rs. You'll also meet the influential crates you'll encounter early such as serde, tokio, axum, bevy, and embassy, and understand why Rust keeps a lean standard library and a rich community ecosystem that feels unusually polished coming from npm, pip, or Maven.

You'll work with Vec, the growable array that is the workhorse collection of Rust, creating one with vec!, pushing elements, indexing into it, and iterating with for. You'll learn the difference between indexing (which panics out of bounds) and the get method (which returns an Option), then build a vector of numbers, sum its values with a for loop, and print the result.

You'll store key-value data with HashMap from std::collections, inserting entries, looking one up, and iterating over its pairs. You'll see how get returns an Option instead of a sentinel value and how the entry API powers read-or-insert patterns, then count word frequencies in a sentence using a HashMap.

You'll learn slices, the borrowed views that let a function accept either a whole collection or just a fragment of one, taking a slice of a Vec and of a String and passing them into a function. You'll understand that a slice is a pointer and a length, that &str is itself a slice, and you'll write a function that returns the first word of a string slice.

You'll discover why iterators are at the heart of idiomatic Rust, calling .iter() on a vector, chaining adapters like map and filter, and consuming the result with a for loop or .collect(). You'll see that iterators are lazy and zero-cost, and you'll build an iterator pipeline that transforms and filters a vector of numbers.

You'll treat strings as collections, iterating one with .chars() and then with .bytes() and printing each. You'll learn that Rust strings are UTF-8 encoded so a single character can span multiple bytes, which is exactly why integer indexing into a String is disallowed, and you'll count the vowels in a string using .chars() and a filter.

You'll explore the three principles that define Rust: memory safety without garbage collection, zero-cost abstractions, and fearless concurrency, and how each is enforced by the language itself rather than at runtime. You'll see conceptually how ownership and borrowing replace C's manual discipline and a GC's runtime cost, how traits and monomorphization keep abstractions free, and how the type system stops data races at compile time, so you can grasp exactly what trade Rust is making on your behalf.

You'll make ownership concrete by creating a String, passing it into a function, and then trying to use it again to trigger Rust's famous use-after-move error. You'll internalize the rule that every value has a single owner and that moves transfer ownership, then fix it two ways by returning the value or cloning it, writing one function that consumes a String and one that hands it back.

You'll borrow values instead of moving them, passing a value by &T to a function that only reads it and by &mut T to a function that modifies it, then watching the change reflected back in main. You'll learn the borrow-checker rule of many shared references or one mutable reference but never both, trigger the error on purpose, and write a function that doubles every element of a vector in place through &mut.

You'll get a gentle first encounter with lifetimes through a function that returns the longer of two string slices, annotated with an explicit lifetime parameter. Rather than drowning in theory, you'll see that the apostrophe-a syntax is simply the compiler asking which input the output borrows from, and you'll adapt the function to return the shorter slice and notice the annotation stays the same.

You'll define your own types with structs, declaring named fields, instantiating a value, printing its fields, and writing an associated function as a constructor. You'll also meet tuple structs and unit structs and use the derive attribute to enable Debug printing, then give a struct a method that computes and returns a value from its fields.

You'll model data with enums whose variants carry their own data, match on them, and then use Option to represent a function that might return nothing. You'll see how Option replaces null and forces you to handle the absent case through match or if let, and you'll write a function that finds the first negative number in a vector and returns it as an Option.

You'll handle recoverable errors the Rust way, parsing integers from string slices that return a Result and chaining them with the ? operator inside a helper function. You'll watch what happens when parsing succeeds and when it fails, learn how ? propagates the error to the caller with zero boilerplate, and write a function that parses several values, combines them, and returns the result or an error.

You'll get an honest, marketing-free look at where Rust is genuinely hard or limited: the steep learning curve of the borrow checker, long compile times next to Go, the rough edges in async such as function coloring, the places where the ecosystem still lags, the sharp corners in the language itself, verbose error handling, and the cognitive load of lifetimes. You'll come away able to judge when Rust is the wrong tool, not just when it's the right one.

You'll spawn real OS threads from main with std::thread::spawn, have each print a message, and use join handles to wait for them all to finish. You'll see how the move keyword transfers ownership of captured variables into a thread closure and how the compiler refuses to compile code that would share mutable state unsafely, then spawn four threads that each sum a slice of a vector.

You'll pass messages between threads using a std::sync::mpsc channel, spawning a worker thread that sends a sequence of values while the main thread receives and prints them. You'll learn why Rust favors message passing over shared state and how the type system carries the element type across the channel, then treat the receiver as an iterator and consume a stream of values as they arrive.

You'll share mutable state safely across threads by wrapping a counter in Arc<Mutex<i32>>, spawning several threads that each lock the mutex and increment it, then printing the final total. You'll understand why Arc provides shared ownership across threads while Mutex provides exclusive access to the inner value and why you need both together, then accumulate counts from threads into a shared HashMap protected by a Mutex.

You'll turn a sequential computation into a parallel one almost for free, importing the rayon prelude and swapping an iterator chain for par_iter to sum the squares of a million numbers across every core. You'll see how data-parallel libraries make parallelism a near one-line change and how the borrow checker keeps it safe by construction, then run a filter-map-sum operation in parallel across cores.

You'll write asynchronous Rust on the tokio runtime, defining two async functions, awaiting them one after another, and then running them concurrently with tokio::join!. You'll learn that async functions return Futures that do nothing until polled, that .await suspends without blocking the thread, and that tokio is what drives those futures to completion, then write async functions that simulate a delay with tokio::time::sleep and await two of them at once, using a stopwatch to prove they run concurrently.

You'll look at hard numbers on how Rust performs against C, C++, Go, and Java in published benchmarks like the Computer Language Benchmarks Game and TechEmpower, alongside adoption indicators from recent developer surveys, where Rust has been a consistently admired language. You'll look at real systems running on Rust, including Cloudflare's Pingora proxy measured against NGINX, and the companies now talking publicly about it, so the case for Rust feels concrete rather than aspirational.

You'll work with closures as first-class values, passing one into a function that expects a callable and capturing variables from the surrounding scope by reference and by move. You'll learn the three closure traits Fn, FnMut, and FnOnce and how Rust gives each closure a concrete type for zero-cost higher-order programming, then write a function that takes a closure and applies it twice to a starting value.

You'll compose iterator combinators into a single expression, chaining map, filter, and sum to compute a result over the even numbers with no explicit loop at all. You'll see how these chains replace imperative loops in idiomatic Rust and how the compiler usually optimizes them into one tight loop, then meet fold as the universal reducer and run a similar chain that produces a different result type.

You'll write code once that works for many types using generics and trait bounds, defining a generic function that sums any iterator whose items implement Sum and Add and calling it with both i32 and f64 collections. You'll understand how trait bounds express a contract a type must satisfy and how the compiler monomorphizes your function into specialized versions, then write a generic function that returns the largest element of a slice using PartialOrd.

You'll use trait objects and dynamic dispatch, defining a Shape trait with an area method, implementing it for a Circle and a Rectangle, and storing them together in a Vec<Box<dyn Shape>> that you iterate over calling area. You'll contrast this with the static-dispatch generics from the previous lecture and learn when each is the right choice, then add a Triangle implementation and push it onto the same vector.

You'll design clean, application-specific error handling with the thiserror derive macro, defining an enum that implements std::error::Error with several variants for different failure modes and using it as a function's Result error type. You'll see how idiomatic Rust apps model their whole error domain in one enum and let ? convert between error types through From, then add a new variant for a parse failure and propagate it from a helper function.

You'll see Rust's deterministic cleanup in action by implementing the Drop trait on a struct, printing a message inside drop, and watching the messages fire in reverse order of construction as values leave scope. You'll understand that this is exactly how the standard library closes files, releases locks, and frees memory without a garbage collector, then wrap a resource handle in a struct and confirm Drop runs even on early-return paths.

You'll go deep on what the borrow checker actually does at compile time: it builds a model of every reference's lifetime within a function and proves, region by region, that no shared reference outlives its data and that no two mutable references alias the same memory at once. You'll trace the borrow checker's own evolution, including the shift from lexical lifetimes to non-lexical lifetimes, leaving you with a mental model of the borrow checker as a theorem prover smuggled into a mainstream compiler rather than a list of rules to memorize.

You'll picture how Rust lays values out in memory, with scalar values and fixed-size structs on the stack and the contents of Box, Vec, and String on the heap behind fat-pointer headers. You'll see how a Vec is really a pointer-length-capacity triple, how a &str is a pointer and a length, and how a trait object carries a vtable pointer beside its data pointer, building the intuition for why moves are cheap and why ownership and Drop matter.

You'll understand monomorphization, the way Rust specializes generic code at compile time into a dedicated copy for each concrete type, and how it differs from Java-style type erasure and C++ templates. You'll weigh the tradeoff of larger binaries and slower compiles in exchange for runtime performance equal to hand-written specialized code, and contrast static dispatch through generics with dynamic dispatch through dyn Trait objects.

You'll explore the two marker traits that make Rust's concurrency story unique: Send for types that can move across thread boundaries and Sync for types whose references can be shared across threads. You'll see how the compiler auto-derives them and uses them together with the borrow checker to mechanically prevent data races at compile time, and why some types are Send but not Sync, why Rc is neither, and why Arc is both.

You'll study three patterns experienced Rustaceans reach for again and again: the newtype wrapper that gives a primitive a distinct type for safety, the typestate pattern that encodes a state machine in the type system so invalid transitions fail to compile, and RAII realized through Drop. You'll see where each shines, with examples like an HTTP request builder for typestate and resources that manage themselves through Drop, including how RAII pays off in async code too.

You'll take a panoramic tour of the domains Rust has colonized thanks to its rare blend of safety and control: embedded firmware on bare metal via no_std, operating system kernels and the Rust-for-Linux project, WebAssembly modules running in the browser, real-time audio, game engines, and high-performance network proxies. You'll meet the crown crates of each domain, understand why Rust uniquely fits where other languages cannot follow, and see how its tooling makes targets that are out of reach for most languages feel routine, closing the course and setting you up for the journey ahead.