Introduction to Rust

Rust was publicly announced by Mozilla in 2010; memory safety without a garbage collector is a design goal, and in safe Rust the compiler checks ownership and borrowing rules at compile time. You examine the design principles of safety, speed, and concurrency and assess when Rust fits a task. In the lab environment, you write a small Rust program.

Cargo serves as the build system and package manager; rustup manages toolchain versions; rustc compiles source code. The DevNinjas Dojo, our cloud learning environment, provides the exercises. You create, build and run a project there; the formatter and linter complement the basic development cycle from source changes to execution.

Rust is a statically typed language, supports type inference, and uses immutable bindings by default. In the lab environment, you work practically with fundamental data types and compound values in small code examples and examine different control-flow paths to observe how control flow can return values directly as an expression.

Functions use parameters and return values; visibility limits access to module items, which are private by default. A package bundles one or more crates; crates are binary crates or library crates. In the lab environment, you structure a small package into modules and use Cargo to add an external crate.

Rust distinguishes owned strings from borrowed string slices. In the lab environment, you work with Vec as a dynamic array and HashMap for key-value pairs; slices directly reference parts of data structures without copying them. This prepares you for ownership and borrowing on the second day.

Ownership assigns each value an owner and determines that memory is released automatically when its owner leaves scope. In the lab environment, you use several concrete values to distinguish move semantics, copy, and clone and decide for the respective data type when values are copied or moved.

Borrowing allows functions to use values through references without taking ownership. The borrow checker constrains simultaneous read and mutable access. In the lab environment, you use a concise code example to examine typical compiler diagnostics involving borrowed references, read the messages, and systematically resolve the underlying conflicts.

Structs group related data; enums model distinct valid states. match handles every variant of an enum exhaustively; if let targets a single pattern. In the lab environment, you model custom types in small code examples and apply both forms of pattern handling appropriately to their variants.

Result uses its variants to model successful values and errors in the type system; Option uses its variants to describe a present or absent value in the type system. In the lab environment, you compare different error-handling approaches in small code examples and assess their use. Rust handles errors here without exceptions.

Traits describe shared behaviour similarly to interfaces or type classes; generics make implementations reusable across types. Trait bounds constrain permitted types and connect generic designs with behaviour implemented for concrete types. In the lab environment, you write a generic function with trait bounds and compare it with separate implementations for individual types.

Lifetimes describe how long references remain valid. The compiler infers many of these relationships automatically; explicit annotations can be necessary when several references are involved. In the lab environment, you work practically with lifetime annotations in functions and structs and apply the elision rules to several concrete reference relationships.

Box places values on the heap; this is particularly relevant for recursive data structures and large objects. Rc uses reference counting for multiple owners within one thread; Arc supports shared ownership across threads. As a hands-on lab exercise, you implement a simple tree structure with Box and Rc.

Threads enable concurrent execution; channels pass messages; Arc supports shared ownership across threads, while Mutex synchronizes access to shared state. Send and Sync are distinct unsafe auto traits (marker traits): Send permits values to be transferred between threads, while Sync permits references to be shared safely. In the lab environment, you parallelize a computation and compare sequential with parallel execution.

Async is suitable for tasks that wait for input and output. You examine why Rust needs an external runtime such as Tokio to execute asynchronous applications. In the lab environment, you write asynchronous code in a small example, work with Tokio tasks, and examine how they interact with ownership.

Rust integrates unit and integration tests with its toolchain. Executable examples in documentation can also serve as tests. In the lab environment, you work practically with the different forms of unit and integration tests and measure code coverage for the respective changes under consideration as an additional observation.

Clap supports structured argument processing in Rust command-line tools. Input validation checks the expected form of arguments; automatically generated help text supports user guidance. In the lab environment, you develop a small, clearly bounded command-line tool yourself and bring these components together in a learning application.

Axum is a web framework from the Tokio ecosystem. You examine routing, request processing, and data exchange. In the lab environment, you work on a manageable HTTP server and bring the covered areas together in a deliberately small, clearly bounded learning application; a production-ready service is outside the scope.

Serde connects Rust data types with serialized formats; JSON serves as a concrete example. Cargo manages external dependencies and the version requirements selected for them in the project. In the lab environment, you process JSON practically in a web application and read the relevant accompanying documentation for external crates used in this processing.

Closures and iterators form an important part of idiomatic Rust code. Closures use values from their environment; this access directly relates to the ownership model. In the lab environment, you work practically with iterators in a small data example and examine how multiple processing steps are expressed as a connected sequence.

Rust is used for backend services; operating systems and kernels are further application areas. You consider possible next topics: WebAssembly, embedded Rust, and Linux, and receive pointers to further resources. To conclude, you see how Rust binaries are packaged into Docker containers and connect this topic with the Docker workshop.