1 / 15
Workshop · Live · 45 Minuten

Rust für Einsteiger

In 45 Minuten zum ersten eigenen Programm — cargo new genügt.

rust-lang.orgTeil 1 von 2
Herzlich willkommen. Heute geht es nicht um jedes Detail von Rust, sondern um die drei Kernideen, die die Sprache tragen. Ziel: ihr verlasst den Raum mit einem laufenden Programm und wisst, warum Rust so gebaut ist, wie es gebaut ist. Wer laptopdabeihat: gerne parallel mittippen.
Kernbotschaft

Rust verlagert ganze Fehlerklassen von der Laufzeit in die Compilezeit.

Vorher

Speicherfehler, Datenrennen, Null-Abstürze zeigen sich erst beim Kunden.

Mit Rust

Der Borrow-Checker weist dieselben Fehler beim Kompilieren aus — bevor das Programm läuft.

Und das ohne Garbage Collector: Ownership ist das Werkzeug, beides zugleich zu erreichen.

Kernbotschaft · kommt am Ende wieder02
Das ist der eine Satz, den ihr mitnehmen solltet. Rusts Alleinstellung ist nicht Geschwindigkeit alone — die haben C und C++ auch. Es ist: Geschwindigkeit UND Speichersicherheit zur Compilezeit, ohne Laufzeit-Müllsammler. Das kostet Lernaufwand oben, zahlt es unten zurück.
Warum überhaupt?

Der Industrie ist die Speichersicherheit das Geld wert.

76→35 %

Memory-Safety-Anteil an Android-Lücken, 2019 → 2022 (Google)

82,2 %

würden Rust wieder nutzen — most admired, 9. Jahr in Folge (SO Survey 2024)

Microsoft (2019): ~70 % aller CVEs sind Speicherfehler · Firefox, Windows, Android bauen Neues in Rust

Quellen: Google Security Blog 2022 · SO Survey 2024 · MSRC 201903
Zwei Zahlen als Beleg, dass das keine Nischenästhetik ist: Google hat in Android den Anteil der Speicherfehler fast halbiert, vor allem durch Rust für neuen Code. Und die Community-Zufriedenheit ist seit neun Jahren ungeschlagen. Abruf-Frage an die Runde: Wer von euch hatte schon einmal einen Null-Pointer- oder Speicherfehler in Produktion?
01

Drei Kernideen

Ownership · Borrowing · Enums statt null

Teil 1 von 2 · ca. 20 Minuten04
Erster Teil: die drei Konzepte, die Rust von allem unterscheiden, was ihr kennt. Alles andere — Syntax, Standardbibliothek — lernt sich fast von allein, wenn diese drei sitzen.
Kernidee 1 · Ownership

Jeder Wert hat genau einen Besitzer — und wird mit ihm gelöscht.

  • Jeder Wert hat eine besitzende Variable — let s = String::from("hi");
  • Zuweisung verschiebt den Besitz (Move) — danach ist die alte Variable unbenutzbar
  • Verlässt der Besitzer seinen Gültigkeitsbereich, wird der Wert sofort freigegeben
Das ist der Garbage Collector — nur ohne Garbage und ohne Collector05
Ownership in einem Satz: Wer besitzt, räumt auch ab. Kein zweiter Programmteil kann versehentlich weiterlegen auf Speicher, der schon weg ist — der Compiler verbietet es. Das erklärt Rusts berühmte Fehlermeldungen: Sie sind nicht Feindseligkeit, sondern die Durchsetzung genau dieser drei Regeln.
Kernidee 2 · Borrowing

Ausleihen statt kopieren — beliebig viele Leser oder genau ein Schreiber.

&T — beliebig viele

fn lang(&s)nur lesen
gleichzeitigmehrere Reader erlaubt
0 KopienReferenz kostet nichts

&mut T — genau einer

fn dran(&mut s)schreiben
exklusivkein Reader parallel
zur LaufzeitDatenrennen unmöglich
Die Borrow-Regeln sind Rusts Datenrennen-Versicherung06
Die Kehrseite der Ownership wäre: alles ständig kopieren. Borrowing ist der Ausweg. Die Regel merkt ihr euch als Share-or-mutate: viele dürfen lesen ODER einer darf schreiben — nie beides gleichzeitig. Genau diese Einebnung prüft der Borrow-Checker, und genau sie macht Datenrennen in sicherem Rust strukturell unmöglich.
Werkzeug · Cargo

Ein Befehl baut, testet und paketiert — das erste Programm dauert 30 Sekunden.

$ cargo new hallo
$ cd hallo && cargo run
   Compiling hallo v0.1.0
Hello, world!
  • cargo new — Projekt + Git + Struktur
  • cargo run / test / build
  • cargo add serde — Abhängigkeiten aus crates.io
rustup.rs installiert Rust + Cargo in einem Rutsch07
Hier ist der Moment zum Mitmachen: cargo new, cargo run, fertig. Cargo ist npm, pip und make in einem — nur dass Abhängigkeiten versioniert in einer Lockfile stehen und Builds reproduzierbar sind. Alles, was heute folgt, könnt ihr in genau diesem Projekt ausprobieren.
Kernidee 3 · Enums statt null

Es gibt kein null — Abwesenheit ist ein Typ, den der Compiler sieht.

enum Option<T> { Some(T), None }

match finde_nutzer(id) {
    Some(u) => begruesse(u),
    None   => meldung("kein Treffer"),
}
  • match muss alle Fälle behandeln
  • Vergessen einen Fall? Kompilierfehler, nicht Bug
  • Der millionenschwere NullReference-Fehler stirbt hier
Dasselbe Muster für Fehler: Result<T, E> — Folie 1008
Tony Hoare nannte null seine Milliardendollar-Mistake. Rusts Antwort ist kleines Stück Typtheorie: Some oder None, und match zwingt euch, beide zu behandeln. Das schöne: Der Fehlerfall steht in der Signatur — ihr seht einer Funktion an, ob sie schiefgehen kann, ohne Doku zu lesen.
02

In der Praxis

Fehler · Abgrenzung · Lernpfad

Teil 2 von 2 · ca. 20 Minuten09
Zweiter Teil: was ihr im Alltag wirklich braucht — Fehlerbehandlung, wo Rust seine Grenzen hat, und ein Lernpfad für die nächsten zwei Wochen.
Praxis · Fehler

Fehler sind Werte in der Signatur — kein try/catch.

fn lies_datei(p) -> Result<String, Error>
let ih = lies_datei("cfg.toml")?;
  • Result<T, E>: Ok oder Err — in der Signatur sichtbar
  • ?-Operator reicht Fehler in einer Zeile nach oben
Wer Fehler sehen will, sieht sie — in jeder Signatur10
Exceptions haben ein Problem: Man sieht einer Funktion nicht an, dass sie werfen kann. Rust macht Fehler zum Wert. Das Fragezeichen ist reiner Zucker für: war es Err, returne Err — sonst gib den Wert frei. Einsteigertipp: Anfangs fühlt sich das zäh an; nach einer Woche ist es die glaubwürdigste Fehlerbehandlung, die ihr je hattet.
Praxis · Wiederverwendung

Generics kosten zur Laufzeit nichts.

trait Summierbar { fn summe(&self) -> f64 }
fn gesamt<T: Summierbar>(p: &[T]) -> f64
  • Verhalten als Trait, Implementierung je Typ
  • Monomorphisierung: generischer Code wird zu schnellem Spezialcode
C++-Templates mit Sicherheitsnetz · Java-Generics ohne Laufzeitkosten11
Traits kurz halten: Für den Einstieg reicht das Bild Interface plus ableitbare Implementierungen. Wichtig ist nur die Punktlandung: Generics werden zur Compilezeit in konkreten Code übersetzt — ihr zahlt keine virtuellen Aufrufe, nur weil ihr generisch schreibt.
Einordnung

Rust ersetzt C und C++ — nicht eure Skriptsprache.

Rust wählt, wenn …

Laufzeitvorhersehbar, keine GC-Pausen
RandSystemnähe, Embedded, hohe Last
Preisein Fehler ist teuer oder gefährlich

Anders bleibt, wenn …

TempoSkript, Prototyp, Ad-hoc-Analysis
Teamviele Python/JS-Kräfte, wenig Zeit
OkGC-Pausen und Laufzeit egal sind
Gleiche Zeilenlogik links und rechts — der Unterschied ist die Bedingung, nicht die Form12
Wichtige Erwartungskorrektur: Rust zu lernen, um Dashboards zu bauen, ist das falsche Werkzeug. Der Wert entsteht dort, wo Kontrolle über Speicher und Laufzeit zählt — Services unter Last, CLIs, WebAssembly, Embedded. Für alles andere bleiben Python und Co. völlig in Ordnung.
Ehrlich bleiben

Der berechtigte Einwand: Rust ist anstrengend zu lernen.

»Ich kämpfe wochenlang mit dem Borrow-Checker, und alles kompiliert ewig — dafür schreibe ich dreimal so viel Code.«

  • Kampf ist real, aber zeitlich: die Kurve steigt in Woche 1–2, dann flacht sie ab
  • Compilezeit ist der Testlauf: was andere zur Laufzeit debuggen, fällt hier beim Bauen
  • clone() ist erlaubt: erst korrekt, dann optimieren — keine Schande
Einwand benannt und entkräftet — zwei-seitige Botschaft13
Diesen Einwand höre ich immer, und er ist ehrlich: Ja, die ersten zwei Wochen fühlen sich wie ein Kampf mit dem Compiler an. Aber der Kampf hat eine Richtung — jede Fehlermeldung lehrt eine Regel, und irgendwann schreibt ihr sie instinktiv korrekt.clone() als Escape-Hatch ausdrücklich erlauben.
Nach dem Workshop

Zwei Wochen bis zum ersten eigenen nützlichen Programm.

Tag 1–3rustup.rs · The Book, Kap. 1–6 · cargo new
Woche 1Rustlings-Übungen · Ownership sitzen lassen
Woche 2kleines echtes CLI-Projekt statt Tutorial

The Book (doc.rust-lang.org/book) · Rustlings (github.com/rust-lang/rustlings)

Maßstäbliche Achse: Anfang zählt doppelt14
Konkreter Pfad, kein Program: Das Buch ist kostenlos und das beste Sprachtutorial, das ich kenne — aber Kapitel für Kapitel lesen, nicht in einem Zug. Rustlings sind kleine Lückentext-Übungen mit Compilern als Prüfer. Und ab Woche zwei: ein echtes, kleines, eigenes Projekt. Am besten ein Werkzeug, das ihr selbst braucht.
Zum Mitnehmen

Rust verlagert ganze Fehlerklassen von der Laufzeit in die Compilezeit.

Die Frage an euch: Welches Programm in eurem Umfeld verdient diese Sicherheit?

Heute Abend

rustup.rs installieren, cargo new, cargo run — 30 Sekunden Mutprobe.

Diese Woche

The Book Kap. 1–6 und die ersten zehn Rustlings.

Kernbotschaft — Wiederholung zum Schluss15 / 15
Kernbotschaft noch einmal, wortgleich zu Folie zwei — Verankerung durch Wiederholung am Anfang und Ende. Und die Abschlussfrage in die Runde: welches eigene Programm verdient Compilezeit-Sicherheit? Wer eine Antwort hat, hat auch ein Lernprojekt. Danke — Fragen jetzt oder jederzeit.

Sprechnotiz · Folie 1