Introduction to Rust

Rust was publicly announced by Mozilla in 2010 with a clear goal: memory safety without a garbage collector. Today, Rust powers parts of Firefox, the Linux kernel, Cloudflare Workers, and tools like ripgrep. In this block you will explore what problems Rust solves that C and C++ leave open, and why companies like Microsoft, Google, and Amazon use Rust in safety-critical systems. You will understand the three design principles (safety, speed, concurrency) and assess when Rust is the right choice.

You set up your Rust workspace in the DevNinjas Dojo and get familiar with the toolchain: rustup for version management, cargo as the build system and package manager, rustc as the compiler. With cargo new you create your first project, build it with cargo build, and run it with cargo run. By the end of this block you know the project structure (Cargo.toml, src/main.rs) and have set up clippy and rustfmt as quality tools.

Rust is statically typed but supports type inference, so you do not need to annotate every type explicitly. You work with primitive types (i32, f64, bool, char), tuples, and arrays. Special focus goes to Rust's distinction between let (immutable) and let mut (mutable): immutability by default is a deliberate design decision. For control flow (if, loop, while, for), you will see that if is an expression and can return values directly.

Functions in Rust have explicit return types and return the last expression without return. You write functions with various parameters, use closures as anonymous functions, and organize code into modules with mod. Rust controls visibility through pub: private by default. Then you learn the difference between binary crates and library crates and pull in your first external dependency via Cargo.toml and crates.io.

Why does Rust have two string types? String and &str regularly confuse newcomers. In this block you clarify the difference between owned and borrowed data using strings, preparing you for the ownership concept on day 2. Then you work with Vec as a dynamic array and HashMap<K, V> for key-value pairs. Slices (&[T]) show you how Rust efficiently references parts of data structures without copying them.

Ownership is the concept that sets Rust apart from every other language. Every value in Rust has exactly one owner, and when that owner leaves scope, the memory is automatically freed. You work through the three ownership rules, observe move semantics in action, and understand why let b = a on a String invalidates access to a. With Copy and Clone you consciously control when values are copied or moved.

Not every function call should take ownership. With references (&T and &mut T) you borrow values without moving them. The borrow checker ensures at compile time that no data races occur: either any number of readers or exactly one writer. Using concrete examples, you provoke typical compiler errors, learn to read the error messages, and fix the issues systematically. This debugging pattern will accompany you through the rest of the workshop.

You define custom data types with structs (named fields, tuple structs, unit structs) and enrich them with methods via impl blocks. Then come enums: unlike Java or C#, Rust enums can carry data. Option and Result<T, E> are the most important standard library enums and replace null pointers and exceptions. With match and if let you destructure enums in a type-safe way and handle every case explicitly.

Rust has no exceptions. Instead, Result<T, E> and the ? operator enforce explicit error handling at every call site. You implement custom error types with the Error trait, use ? for elegant error propagation, and see how the thiserror crate reduces boilerplate. You also learn the difference between unwrap() (quick but unsafe) and expect() (better for debugging) and why panic! is only meant for unrecoverable errors.

Traits are Rust's answer to interfaces and type classes. You implement Display, Debug, and From for your own types and write your first custom traits. With generics you define functions and structs that work across different types: fn largest<T: PartialOrd>(list: &[T]) -> &T instead of separate functions per type. Trait bounds give the compiler the necessary guarantees, and you see why generic code in Rust is monomorphized at compile time (zero runtime overhead).

Lifetimes describe how long a reference remains valid. Most of the time the compiler infers them automatically (lifetime elision), but in certain cases you must annotate them explicitly: fn longest<'a>(x: &'a str, y: &'a str) -> &'a str. Using practical examples you work with lifetime annotations in functions and structs, understand the elision rules, and resolve typical lifetime errors. This block builds directly on the ownership and borrowing knowledge from day 2.

Not all data lives on the stack. With Box you allocate values on the heap, which is necessary for recursive data structures and large objects. Rc (reference counting) enables multiple owners within the same thread, Arc (atomic reference counting) does the same across threads. You implement a simple tree structure with Box and Rc and see how RefCell enables interior mutability when the borrow checker is too strict at compile time.

Rust's "fearless concurrency" is not marketing: the compiler prevents data races at compile time. You start threads with std::thread::spawn, communicate via mpsc channels (multiple producer, single consumer), and protect shared data with Mutex and Arc. Using a concrete example you parallelize a computation and compare sequential versus parallel runtime. Send and Sync as marker traits explain why some types are thread-safe and others are not.

Threads work well for CPU-bound work, but for I/O-intensive applications (web servers, API clients) async is more efficient. You write your first async fn, use .await, and understand why Rust needs an external runtime like Tokio (unlike Go with its built-in runtime). With Tokio you start asynchronous tasks, work with tokio::select!, and see how async interacts with ownership. This block prepares you for day 4 (Axum web server).

Rust ships with a built-in test framework: #[test] functions, assert!, assert_eq!, and assert_ne!. You write unit tests directly alongside production code (in the same module), create integration tests in the tests/ directory, and measure code coverage with cargo tarpaulin. Doc comments (///) become HTML documentation and can include executable code examples that cargo test verifies automatically. No dead code examples in the docs.

Many well-known developer tools are written in Rust: ripgrep, fd, bat, delta, eza. You build your own command-line tool with the clap crate, the standard for argument parsing in Rust. Using derive macros you define subcommands and flags declaratively, validate inputs, and auto-generate help text. The result: a compiled binary you can run on any system without a runtime.

Axum is the web framework from the Tokio ecosystem and has established itself as the modern standard for Rust web servers. You define routes with the Router, write handler functions, and use extractors for path parameters, query strings, and JSON bodies. By the end of this block your own REST-capable server with multiple endpoints is running in the Dojo.

Serde is Rust's serialization framework and one of the most downloaded crates on crates.io. With #[derive(Serialize, Deserialize)] you make your structs JSON-capable and integrate serde_json for processing. You extend your Axum server with JSON endpoints and see how the type system catches invalid data at deserialization time. Then you evaluate new crates: how do you read documentation on docs.rs? How do you assess quality and maintenance status?

Closures and iterators are the backbone of idiomatic Rust code. You work with .map(), .filter(), .collect(), and .fold() and see how the compiler optimizes iterator chains into efficient machine code (zero-cost abstractions). The three closure traits (Fn, FnMut, FnOnce) determine how closures capture values from their environment, tying directly back to the ownership model. After this block you replace manual loops with expressive iterator pipelines.

To wrap up, you assess where Rust stands today and which directions are worth pursuing. From WebAssembly for browser performance to embedded Rust on microcontrollers to contributing to the Linux kernel (in the mainline kernel since Linux 6.1, an official part of kernel development since late 2025): you get a roadmap with concrete resources. For the cloud context, we show how Rust binaries are packaged into Docker containers and deployed on Kubernetes, and how this connects to our container workshops.