Einführung in Rust

Rust wurde 2010 von Mozilla vorgestellt, mit einem klaren Ziel: Speichersicherheit ohne Garbage Collector. Heute steckt Rust hinter Firefox, Teilen des Linux-Kernels, Cloudflare Workers und Tools wie ripgrep. In diesem Block ordnen Sie ein, welche Probleme Rust löst, die C und C++ offenlassen, und warum Unternehmen wie Microsoft, Google und Amazon Rust in sicherheitskritischen Systemen einsetzen. Sie verstehen die drei Designprinzipien (Safety, Speed, Concurrency) und können einschätzen, wann Rust die richtige Wahl ist.

Sie richten Ihren Rust-Workspace im DevNinjas Dojo ein und machen sich mit der Toolchain vertraut: rustup für Versionsmanagement, cargo als Build-System und Paketmanager, rustc als Compiler. Mit cargo new legen Sie Ihr erstes Projekt an, kompilieren es mit cargo build und führen es mit cargo run aus. Am Ende dieses Blocks kennen Sie die Projektstruktur (Cargo.toml, src/main.rs) und haben clippy und rustfmt als Qualitätswerkzeuge eingerichtet.

Rust ist statisch typisiert, unterstützt aber Type Inference, sodass Sie nicht jeden Typ explizit angeben müssen. Sie arbeiten mit primitiven Typen (i32, f64, bool, char), Tupeln und Arrays. Besonderes Augenmerk liegt auf Rust's Unterscheidung zwischen let (unveränderlich) und let mut (veränderlich): Immutability als Standard ist eine bewusste Designentscheidung. Bei den Kontrollstrukturen (if, loop, while, for) sehen Sie, dass if ein Ausdruck ist und direkt Werte zurückgeben kann.

Funktionen in Rust haben explizite Rückgabetypen und geben den letzten Ausdruck ohne return zurück. Sie schreiben Funktionen mit verschiedenen Parametern, nutzen Closures als anonyme Funktionen und strukturieren Code in Module mit mod. Sichtbarkeit regelt Rust über pub: privat ist der Standard. Danach lernen Sie den Unterschied zwischen Binary Crates und Library Crates kennen und ziehen eine erste externe Dependency über Cargo.toml und crates.io ein.

Warum hat Rust zwei String-Typen? String und &str verwirren Einsteiger regelmäßig. In diesem Block klären Sie den Unterschied zwischen owned und borrowed Data anhand von Strings und bereiten damit das Ownership-Konzept von Tag 2 vor. Danach arbeiten Sie mit Vec als dynamischem Array und HashMap<K, V> für Schlüssel-Wert-Paare. Slices (&[T]) zeigen Ihnen, wie Rust effizient auf Teile von Datenstrukturen verweist, ohne sie zu kopieren.

Ownership ist das Konzept, das Rust von allen anderen Sprachen unterscheidet. Jeder Wert in Rust hat genau einen Besitzer, und wenn der Besitzer den Scope verlässt, wird der Speicher automatisch freigegeben. Sie arbeiten die drei Ownership-Regeln durch, beobachten Move-Semantik in Aktion und verstehen, warum let b = a bei einem String den Zugriff auf a unterbindet. Mit Copy und Clone steuern Sie bewusst, wann Werte kopiert oder verschoben werden.

Nicht jeder Funktionsaufruf soll Ownership übernehmen. Mit Referenzen (&T und &mut T) leihen Sie Werte aus, ohne sie zu verschieben. Der Borrow Checker stellt zur Compile-Zeit sicher, dass keine Data Races entstehen: entweder beliebig viele Leser oder genau ein Schreiber. An konkreten Beispielen provozieren Sie typische Compiler-Fehler, lernen die Fehlermeldungen lesen und beheben die Probleme gezielt. Dieses Debugging-Muster begleitet Sie den Rest des Workshops.

Sie definieren eigene Datentypen mit Structs (benannte Felder, Tupel-Structs, Unit-Structs) und reichern sie mit Methoden über impl-Blöcke an. Dann kommen Enums: anders als in Java oder C# können Rust-Enums Daten tragen. Option und Result<T, E> sind die wichtigsten Enums der Standardbibliothek und ersetzen Null-Pointer und Exceptions. Mit match und if let zerlegen Sie Enums typsicher und behandeln jeden Fall explizit.

Rust kennt keine Exceptions. Stattdessen erzwingen Result<T, E> und der ?-Operator explizite Fehlerbehandlung an jeder Stelle. Sie implementieren eigene Error-Typen mit dem Error-Trait, nutzen ? zur eleganten Fehlerweitergabe und sehen, wie die thiserror-Crate Boilerplate reduziert. Dazu lernen Sie den Unterschied zwischen unwrap() (schnell, aber unsicher) und expect() (besser für Debugging) und warum panic! nur für nicht-wiederherstellbare Fehler gedacht ist.

Traits sind Rust's Antwort auf Interfaces und Typklassen. Sie implementieren Display, Debug und From für Ihre eigenen Typen und schreiben erste eigene Traits. Mit Generics definieren Sie Funktionen und Structs, die über verschiedene Typen hinweg arbeiten: fn largest<T: PartialOrd>(list: &[T]) -> &T statt separater Funktionen für jeden Typ. Trait Bounds geben dem Compiler die nötigen Garantien, und Sie sehen, warum generischer Code in Rust zur Compile-Zeit monomorphisiert wird (kein Runtime-Overhead).

Lifetimes beschreiben, wie lange eine Referenz gültig bleibt. Meistens leitet der Compiler sie automatisch ab (Lifetime Elision), aber in bestimmten Fällen müssen Sie sie explizit annotieren: fn longest<'a>(x: &'a str, y: &'a str) -> &'a str. An praxisnahen Beispielen arbeiten Sie mit Lifetime-Annotationen in Funktionen und Structs, verstehen die Elision-Regeln und lösen typische Lifetime-Fehler. Dieser Block baut direkt auf dem Ownership- und Borrowing-Wissen von Tag 2 auf.

Nicht alle Daten leben auf dem Stack. Mit Box allokieren Sie Werte auf dem Heap, was für rekursive Datenstrukturen und große Objekte nötig ist. Rc (Reference Counting) ermöglicht mehrere Besitzer im selben Thread, Arc (Atomic Reference Counting) macht das Gleiche thread-sicher. Sie implementieren eine einfache Baumstruktur mit Box und Rc und sehen, wie RefCell Interior Mutability ermöglicht, wenn der Borrow Checker zur Compile-Zeit zu streng ist.

Rust's "fearless concurrency" ist kein Marketing: der Compiler verhindert Data Races zur Compile-Zeit. Sie starten Threads mit std::thread::spawn, kommunizieren über mpsc-Channels (Multiple Producer, Single Consumer) und schützen geteilte Daten mit Mutex und Arc. An einem konkreten Beispiel parallelisieren Sie eine Berechnung und vergleichen die sequentielle mit der parallelen Laufzeit. Send und Sync als Marker-Traits erklären, warum manche Typen thread-sicher sind und andere nicht.

Threads funktionieren gut für CPU-gebundene Arbeit, aber für I/O-intensive Anwendungen (Webserver, API-Clients) ist Async effizienter. Sie schreiben Ihre erste async fn, nutzen .await und verstehen, warum Rust eine externe Runtime wie Tokio braucht (anders als Go mit eingebauter Runtime). Mit Tokio starten Sie asynchrone Tasks, arbeiten mit tokio::select! und sehen, wie das Zusammenspiel von async und Ownership funktioniert. Dieser Block bereitet Tag 4 (Axum-Webserver) vor.

Rust bringt ein eingebautes Test-Framework mit: #[test]-Funktionen, assert!, assert_eq! und assert_ne!. Sie schreiben Unit Tests direkt neben dem Produktionscode (im selben Modul), legen Integration Tests im tests/-Verzeichnis an und messen Code-Coverage mit cargo tarpaulin. Doc-Comments (///) werden zu HTML-Dokumentation und können selbst ausführbare Codebeispiele enthalten, die cargo test automatisch prüft. Keine toten Code-Beispiele in der Doku.

Viele bekannte Entwickler-Tools sind in Rust geschrieben: ripgrep, fd, bat, delta, eza. Sie bauen Ihr eigenes Kommandozeilen-Tool mit der clap-Crate, dem Standard für Argument-Parsing in Rust. Per derive-Macro definieren Sie Subcommands und Flags deklarativ, validieren Eingaben und generieren automatisch Hilfe-Texte. Das Ergebnis: ein kompiliertes Binary, das Sie ohne Runtime auf jedem System ausführen können.

Axum ist das Web-Framework aus dem Tokio-Ökosystem und hat sich als moderner Standard für Rust-Webserver etabliert. Sie definieren Routen mit dem Router, schreiben Handler-Funktionen und nutzen Extractors für Path-Parameter, Query-Strings und JSON-Bodys. Am Ende dieses Blocks läuft Ihr eigener REST-fähiger Server mit mehreren Endpunkten im Dojo.

Serde ist Rust's Serialisierungs-Framework und eines der am häufigsten heruntergeladenen Crates auf crates.io. Mit #[derive(Serialize, Deserialize)] machen Sie Ihre Structs JSON-fähig und binden serde_json für die Verarbeitung ein. Sie erweitern Ihren Axum-Server um JSON-Endpunkte und sehen, wie das Typsystem ungültige Daten bereits beim Deserialisieren abfängt. Danach evaluieren Sie neue Crates: Wie lesen Sie Dokumentation auf docs.rs? Wie prüfen Sie Qualität und Wartungsstatus?

Closures und Iteratoren sind das Rückgrat von idiomatischem Rust-Code. Sie arbeiten mit .map(), .filter(), .collect() und .fold() und sehen, wie der Compiler Iterator-Chains zu effizientem Maschinencode optimiert (Zero-Cost Abstractions). Die drei Closure-Traits (Fn, FnMut, FnOnce) bestimmen, wie Closures Werte aus ihrer Umgebung erfassen, und greifen direkt auf das Ownership-Modell zurück. Nach diesem Block ersetzen Sie manuelle Schleifen durch ausdrucksstarke Iterator-Pipelines.

Zum Abschluss ordnen Sie ein, wo Rust heute steht und welche Vertiefungsrichtungen sich lohnen. Von WebAssembly für Browser-Performance über Embedded Rust auf Mikrocontrollern bis hin zu Beiträgen zum Linux-Kernel (seit Linux 6.1 im Mainline-Kernel, seit Ende 2025 offizieller Bestandteil): Sie erhalten eine Roadmap mit konkreten Ressourcen. Für den Cloud-Kontext zeigen wir, wie Rust-Binaries in Docker-Container verpackt und auf Kubernetes deployed werden, und wie die Verbindung zu unseren Container-Workshops aussieht.