Rust Track Summary

story, bites, and repositories of Rust code

"Rust is a systems programming language that runs blazingly fast, prevents segfaults, and guarantees thread safety."
- Graydon Hoare, creator of Rust

Figure 1. Rust demo code

1. What is Rust?

Rust is a general-purpose systems language that compiles to native code and delivers C++-equivalent runtime performance - with no garbage collector. Resources are released deterministically when their owner goes out of scope. What makes Rust distinctive is that memory safety and data-race freedom are enforced at compile time, not at runtime.

Three core guarantees:

Memory safety - no null or dangling references, no uninitialised reads, no buffer overruns; enforced statically by the borrow checker.
Data-race freedom - the type system prevents unordered concurrent mutable access without explicit synchronisation.
Zero-cost abstractions - generics, iterators, closures, and traits compile away; you pay only for what you use.

Rust is used in production by Microsoft, Amazon, Google, Meta, Discord, Dropbox, Cloudflare, and many others. Its first stable release was in 2015; the current edition, 2024, shipped in January 2025.

2. Track Contents

The Rust track offers three complementary learning pathways plus supporting reference material.

Pathway	Description	Entry Point
Rust Story	An ebook-style narrative covering Rust from first principles through advanced topics. Seven chapters: Prologue, Models, Data, Operations, Structures, Libraries, References. Best for readers who want a complete, linear progression.	Prologue
Rust Bites	Sixty-plus focused pages each covering a single language feature or concept. Pages form an ordered sequence but also work as stand-alone references. The Pages menu lets you jump directly to any topic.	Introduction
Repositories	Documented Rust code repositories illustrating real programs - thread pools, blocking queues, message-passing communication, text search, logging, and more. Each page discusses the design and links to the GitHub source.	Repositories
Other Resources	Glossary, Flash Cards, References page and downloadable pdf files.	RustTour.pdf RustModels.pdf RustErrorHandling.pdf

3. Key Language Concepts

The track covers the areas below, roughly from foundational to advanced.

Ownership and Safety

Rust's defining feature is its ownership model. Every value has exactly one owner; ownership can be moved or temporarily borrowed. The borrow checker proves at compile time that references never outlive their referend and that mutable and shared borrows never coexist.

Single ownership - resources released when owner leaves scope, no GC needed
Move semantics - assignment and pass-by-value transfer ownership; source is invalidated
Borrowing - shared &T and exclusive &mut T references, never both at once
Lifetimes - annotations that prove reference validity across function boundaries

Pages: Ownership, Safety, Lifetimes.

Type System

Rust has a rich static type system with no implicit conversions. All types - primitives, structs, enums - obey the same ownership rules.

Primitives: integers, floats, booleans, characters
Structs - the primary user-defined value type (no class keyword)
Enums - variants may carry data; Option<T> and Result<T,E> are enums
Generics - type-parameterised structs and functions; constraints via trait bounds
Traits - named sets of method signatures; types opt in with impl Trait for Type

Pages: Data, Structs, Enums, Generics, Traits.

Collections and Iterators

The standard library provides a full set of generic collections, all supporting a uniform iterator protocol with composable adapters (map, filter, fold, take, enumerate, …).

Vec<T>, HashMap<K,V>, HashSet<T>, BTreeMap, VecDeque, BinaryHeap
String (owned heap-allocated UTF-8) and &str (borrowed slice)
Lazy iterators - deferred computation, zero overhead until consumed

Pages: Collections, Iterators, Strings.

Error Handling

Rust has no exceptions. Errors are values propagated via Result<T,E> and Option<T>. The ? operator propagates errors ergonomically up the call stack.

Result<T,E> - Ok(T) on success, Err(E) on failure
Option<T> - Some(T) or None; used when absence is not an error
Pattern matching via match, if let, and while let

Pages: Error Handling, Options.

Concurrency

Ownership and the type system enforce thread safety at compile time - a Rust program that compiles is guaranteed free of data races.

Threads via std::thread::spawn; closures capture owned or Arc-wrapped data
Channels (std::sync::mpsc) for message passing between threads
Mutex<T> and RwLock<T> for shared mutable state
Async/await for non-blocking I/O (with an external executor crate)

Pages: Threads, Channels, Synchronisation, Async/Await.

Smart Pointers and Interior Mutability

When single ownership is too restrictive, Rust provides smart pointers that add shared ownership or defer mutability checks, at the cost of explicit syntax.

Box<T> - heap allocation with single ownership and zero overhead
Rc<T> / Arc<T> - reference-counted shared ownership (single-/multi-thread)
RefCell<T> - interior mutability; borrow rules checked at runtime
Mutex<T> - interior mutability across threads with locking

Pages: Smart Pointers, Interior Mutability.

4. Getting Started

Recommended first steps for someone new to Rust:

Install the Rust tool chain from rust-lang.org - provides cargo, rustc, clippy, and rustfmt.
Install VS Code with the rust-analyzer extension for inline diagnostics and code completion.
Read RustBites - Getting Started for an overview of what distinguishes Rust from C++ and C#.
Work through Tooling to confirm your environment, then experiment in the Rust Playground.
Follow the Rust Bites sequence page by page, or read the Rust Story in parallel for deeper narrative context.

The BuildOn project provides progressively demanding Rust programs to implement, ordered to match the Bites sequence - a practical way to consolidate what you read into working code.

5. References

Resource	Description
The Rust Book	Official introductory book - thorough and authoritative.
Rust by Example	Language feature tour driven entirely by runnable code snippets.
std library docs	Complete reference for every type and function in the standard library.
Cheats.rs	Dense, well-organised cheat sheet covering the whole language with visual guides.
Rust Playground	Browser-based environment for compiling and running Rust snippets.
Track References page	Curated list of additional blogs, videos, and books from this site.
RustTour.pdf	Slide deck summarising essential Rust features.
RustErrorHandling.pdf	Slide deck covering Rust's error-handling mechanisms in depth.
Rust API Guidelines	Guidelines for crafting idiomatic Rust APIs, from the Rust team.
Rust Users Forum	Community forum - read, post questions, and browse discussions.