An der Werkbank
Hier bauen wir gemeinsam. Du tippst mit, ich sage dir, was du siehst und warum.
Band 1 · Rust 1.99 · iced 0.14
Rust lernen. An der Werkbank, nicht im Hörsaal.
Du tippst, ich erkläre, wir probieren aus und lernen auch aus Fehlern. Ohne Vorkenntnisse zum eigenen Programm mit Fenster, gespeicherten Daten und Installer für Windows, macOS und Linux.
- 808 Seiten
- 119 Kapitel
- ab 14 Jahren
- Linux · Windows · macOS
- 808Seiten
- 119Kapitel in 16 Teilen
- 100+Aufgaben mit Lösungen
- 3Systeme getestet
- 0Vorkenntnisse nötig
Warum dieses Buch
„Rust ist nichts für Anfänger“? Stimmt so nicht.
Rust ist streng. Aber Strenge ist eine Hilfe, wenn sie jemand erklärt und den Weg mit dir geht. Genau das macht dieses Buch.
Rust ist am Anfang strenger und anstrengender als andere Sprachen. Du wirst dich manchmal über den Compiler ärgern. Dieses Buch bringt dir bei, seine Meldungen zu lesen. aus „Bevor wir anfangen“
Du bekommst keine fertigen Programme zum Abtippen. Jedes Kapitel startet mit fast nichts, du lässt es laufen, veränderst etwas und siehst sofort, was passiert. So wächst das Programm Schritt für Schritt.
Die Methode
Sechs Bausteine, die in jedem Kapitel wiederkehren
Du weißt immer, wo du gerade stehst: An der Werkbank, Hinschauen, Stolperstelle, Jetzt du, Ehrlich gesagt und Ins Werkzeugfach.
Hinschauen
Kurz stehen bleiben und begreifen, was gerade passiert ist, bevor es weitergeht.
Stolperstelle
Wir provozieren absichtlich einen Fehler. Fehlermeldungen sind in Rust keine Strafe, sondern ein Gespräch mit dem Compiler.
Jetzt du
Eine kleine Aufgabe zum Alleinprobieren. Die Lösung steht im Anhang, aber erst nach deinem Versuch.
Ehrlich gesagt
Wo Rust unbequem ist, steht das da. Mit Begründung, warum es trotzdem Sinn ergibt.
Ins Werkzeugfach
Die Kurzfassung zum Merken am Kapitelende, zusätzlich gesammelt als Cheat-Sheet im Anhang.
Das Werkstück
Du lernst nicht auf Vorrat. Du baust echte Programme.
Theorie bleibt hängen, wenn sie gleich gebraucht wird. Deshalb wächst das Wissen an Projekten, die sich benutzen lassen.
Kapitel 15 · Terminal
Zahlenraten
Dein erstes vollständiges Programm: Eingabe, Entscheidungen, Schleifen und Fehlerbehandlung.
Kapitel 16–25 · iced
Das erste Fenster
Vom leeren Fenster zu Zähler, Eingabefeldern, Schaltern, mehreren Ansichten und langen Listen.
Kapitel 26 & 31
To-Do-Liste mit Gedächtnis
Erst mit Filter, dann mit Speicherung, sodass beim nächsten Start alles wieder da ist.
Kapitel 36 · Spiel
Küchenstress
Ein kleines Spiel mit Zeitdruck, das sich über das ganze Buch weiterentwickelt: läuft weich, in Wellen, mit Stammkundschaft.
Kapitel 37–112
Das Rezeptbuch
Ein Kochbuch mit Vorratsschrank, das mit jedem Teil mitwächst und am Ende im Fenster mit Suche, Portionen-Regler und Einkaufsliste läuft.
Kapitel 113–119
Ausliefern
Release-Fassung, Icons, App-Bündel und Disk-Image für macOS, Installer für Windows und Linux, automatische Builds.
So fühlt sich das an
Verständlich erklärt, ohne Fachchinesisch
Jeder Begriff wird beim ersten Auftreten erklärt: Quelltext, Compiler, Terminal, Prompt. Vorausgesetzt wird nur, dass du eine Datei speichern und ein Programm starten kannst.
Das Beispiel rechts stammt aus Kapitel 2 („Hallo, Rust!“) und zeigt das Tempo: kleine Schritte, die sofort etwas sichtbar machen.
fn main() {
let name = "Volker Daehn";
let beruf = "Tischler";
let ort = "Hamburg";
println!("+------------------------+");
println!("| {name}");
println!("| {beruf}");
println!("| {ort}");
println!("+------------------------+");
}Inhalt
16 Teile vom ersten Terminal bis zum fertigen Programm
Klick dich durch den Plan. Jeder Teil baut auf dem vorherigen auf.
1GrundlagenKapitel 1–16
Werkzeug einrichten, Variablen, Zahlen, Schleifen, Funktionen, Structs, Enums, erster Kontakt mit Ownership, Option und Result. Dazu Zahlenraten im Terminal und das erste Fenster.
2Das Fenster wird lebendigKapitel 17–26
Wie iced denkt, Zähler, Layout, Eingabe, Auswahl-Widgets, mehrere Ansichten, lange Listen. Gesellenstück: eine To-Do-Liste mit Filter.
3Zeit, Hintergrund und GedächtnisKapitel 27–31
Fenster einrichten, Zeit und Tasten, Warten ohne Einfrieren, Farben und Themes. Die To-Do-Liste bekommt ein Gedächtnis.
4Aufräumen, Zeichnen und WeitergebenKapitel 32–36
Programm auf mehrere Dateien verteilen, eigene Zeichnungen mit canvas, Fehler, die Nutzer verstehen, Programm weitergeben. Feierabend-Projekt: Küchenstress.
5Das Rezeptbuch – Zahlen, Text und EntscheidungenKapitel 37–42
Das Rezeptbuch entsteht: Zahlen und Mengen, Text, Urteile, Sammlungen, Rezept und Vorrat als eigene Typen.
6Besitz und AusleihenKapitel 43–50
Das Herz von Rust: Stack und Heap, Ownership in der Tiefe, Verweise, Slices, Lebenszeiten und die ehrliche Frage, wann clone() okay ist.
7FehlerKapitel 51–55
Absturz oder Rückgabe, das Fragezeichen, eigene Fehlertypen, Umwandlung mit From.
8Traits und GenericsKapitel 56–64
Traits, derive, Generics, Schranken, Trait-Objekte, Operatoren überladen, Newtype-Muster.
9Iteratoren und ClosuresKapitel 65–71
Closures in der Tiefe, der Iterator-Trait, Adapter und Verbraucher, eigene Iteratoren.
10Speicher und Smart PointerKapitel 72–78
Box, Drop und Deref, Rc, Cell und RefCell, Cow. Das Rezeptbuch bekommt Teilrezepte.
11NebenläufigkeitKapitel 79–84
Threads, Kanäle, Arc und Mutex, Atomics und ein erster Blick auf async.
12Module, Crates und QualitätKapitel 85–92
Module, Pakete und Workspaces, Features, Tests, Dokumentation, clippy und rustfmt.
13PraxisKapitel 93–100
Dateien und Pfade, Terminal-Ein- und Ausgabe, Kommandozeile, Datenformate mit serde, Datum und Zeit, Protokollierung. Feierabend-Projekt: die Bestenliste.
14Makros und unsafeKapitel 101–106
Eigene Makros, Standard-Makros, prozedurale Makros, unsafe und Fremdfunktionen mit C.
15Das Rezeptbuch im FensterKapitel 107–112
Alles kommt zusammen: Plan und Modell, Liste, Detail und Tabelle, Portionen-Regler, Suchen und Filtern, Einkaufen und Kochen.
16AusliefernKapitel 113–119
Release-Fassung, Speicherorte, Icons für drei Systeme, macOS-Bündel und Signatur, Windows und Linux, Versionen und automatische Builds.
Anhang A: LösungenB: FehlercodesC: Glossar Deutsch–EnglischD: SpickzettelE: WeiterlesenF: Cheat-Sheet
Passt das zu dir?
Für wen das Buch gedacht ist (und für wen nicht)
Das Buch ist für dich, wenn …
- du noch nie programmiert hast, oder irgendwo hängen geblieben bist.
- du schon eine andere Sprache kannst und verstehen willst, was Rust anders macht.
- du ab 14 Jahren Lust hast, etwas Echtes zu bauen.
- du lieber mitbaust, als nur zu lesen.
- du ehrliche Antworten magst, auch zu den unbequemen Seiten von Rust.
Eher nicht, wenn …
- du nur eine knappe Referenz suchst. Dafür gibt es Spickzettel und Cheat-Sheet, aber das Buch ist zum Durcharbeiten gedacht.
- du Web-Backends und Netzwerk-Frameworks suchst. Band 1 setzt auf Desktop-Programme mit iced. Netzwerk und async in der Tiefe sind für Band 2 geplant.
Mehr von der Rust-Werkstatt
Weiterbauen, nachschlagen, üben
Das Buch ist das Herzstück. Drumherum wächst auf rust-werkstatt.de, was du zum Weitermachen brauchst, und das meiste davon kostenlos.
Die Werkstatt: gemeinsam bauen
Hier bauen wir zusammen echte Programme, von der leeren Datei bis zum fertigen Werkzeug oder Spiel. Erst überlegen wir, was als Nächstes kommt und worauf wir achten müssen, dann tippen wir es ein und schauen, ob es läuft. Jede Etappe baut auf der vorigen auf, am Ende steht der komplette Code zum Vergleichen.
Der Einstieg · 6 Etappen · komplett
Wattläufer
Ebbe im Wattenmeer: Unter dem Sand verstecken sich Krebse, und nur die Zahlen verraten, wo. Unser Minesweeper, gebaut in sechs gemütlichen Etappen mit gut 300 Zeilen Code. Der wichtigste Krebs ist Ferris, das Rust-Maskottchen.
Zum Projekt →
13 Etappen · Netzwerk · komplett
Fährmann
Ein FTP/SFTP-Client im Look des Norton Commander: links dein Rechner, rechts der Server, dazwischen fährt der Fährmann deine Dateien hin und her.
- Ganze Ordner samt Zugriffsrechten kopieren
- Verschlüsselt übertragen per SFTP
- Fortschrittsbalken, klare Fehlermeldungen, gespeicherte Verbindungen
Für Fortgeschrittene · 10 Etappen · komplett
Baulöwe
Hotelketten gründen, Aktien kaufen, die Konkurrenz schlucken: ein Wirtschaftsspiel mit drei Computergegnern vom Touristen bis zum Hai. Die Iso-Grafik entsteht komplett aus Rust-Code, ohne eine einzige Bilddatei. Läuft als Desktop-App auf Linux, macOS und Windows.
Zum Projekt →Ganz neu bei iced? Der Wattläufer ist der sanfteste Einstieg, jedes Projekt funktioniert aber auch für sich allein. Alle Werkstatt-Projekte ansehen →
Notizen: kurz und in sich abgeschlossen
cargo fmt & cargo clippy erklärt
Zwei Kommandos, die in praktisch jedem Rust-Projekt zur Grundausstattung gehören, aber unterschiedliche Aufgaben haben: Das eine formatiert deinen Code, das andere liest ihn und macht Verbesserungsvorschläge. Die Notizen sind kurze Beobachtungen zu Compiler-Eigenheiten, Sprach-Neuerungen und nützlichen Werkzeugen, ohne festen Rhythmus.
// vorher
fn restenergie(kapazitaet:f64,verbrauch_pro_stunde:f64,stunden:f64)->f64{
kapazitaet-verbrauch_pro_stunde*stunden}
// nachher
fn restenergie(kapazitaet: f64, verbrauch_pro_stunde: f64, stunden: f64) -> f64 {
kapazitaet - verbrauch_pro_stunde * stunden
}Reinlesen und üben
Leseprobe
Die Einleitung „Bevor wir anfangen“ und das komplette Kapitel 2 „Hallo, Rust!“: dein erstes Rust-Programm, inklusive absichtlichem Fehler.
Leseprobe lesen →Rustlings auf Deutsch
Die kleinen Rustlings-Übungen, ins Deutsche übersetzt. Zum Üben in kleinen Häppchen, während das Buch beim Verstehen hilft.
Auf GitHub ansehen →Das Buch
Als eBook oder gedruckt
Das Buch erscheint zuerst über tolino media. Die Entscheidung ist eine Frage der Gewohnheit: Am Bildschirm tippt es sich bequemer mit, auf Papier lässt sich gut blättern.
eBook
Erscheint in Kürze
- Quelltexte bleiben farbig
- Suchen, Kopieren, Lesezeichen
- Praktisch neben dem Editor
Printbuch
Erscheint in Kürze
- Klassisch gedruckt, schwarz-weiß
- Zum Blättern, Anstreichen, Notieren
- Ohne Bildschirm-Ablenkung
Ausblick · Band 2
Die Spezialwerkstatt: Rust-Oberflächen mit Dioxus
Band 1 legt das Fundament: die Sprache, das Denken in Besitz und Ausleihen und die ersten Fenster mit iced. Band 2 baut darauf auf und setzt für die grafische Oberfläche auf Dioxus.
Dioxus beschreibt eine Oberfläche als Komponenten, der Zustand liegt in sogenannten Signals. Die Sprache bleibt dieselbe Rust, die du aus Band 1 kennst. Nur die Art, ein Fenster zu beschreiben, ist eine andere.
Geplante Themen (Stand heute)
- Datenbanken mit SQLite
- Netzwerk & async in der Tiefe
- Anmeldung mit OAuth
- Tray-Icons & Benachrichtigungen
- Mehrere Fenster
- Eigene Komponenten
- Mehrsprachigkeit & Zahlenformate
- Barrierefreiheit
- Automatische Updates
- Web-Auftritt mit WebAssembly
- Fremdfunktions-Schnittstelle
- Leistungsmessung
Erscheinungstermin und endgültiger Umfang stehen noch nicht fest. Aktuelles gibt es hier auf rust-werkstatt.de.
use dioxus::prelude::*;
fn main() {
dioxus::launch(App);
}
#[component]
fn App() -> Element {
let mut count = use_signal(|| 0);
rsx! {
h1 { "Zähler: {count}" }
button { onclick: move |_| count += 1, "Hoch" }
button { onclick: move |_| count -= 1, "Runter" }
}
}Häufige Fragen
Gut zu wissen
Kann ich vorher reinlesen?
Brauche ich Vorkenntnisse?
Nein. Du solltest wissen, wie man eine Datei speichert und ein Programm startet. Alles andere, vom Terminal bis zum Compiler, wird erklärt. Wenn dir etwas zu ausführlich vorkommt, überspring es einfach.
Welches Betriebssystem brauche ich?
Linux, Windows oder macOS. Alle Programme und Fehlermeldungen wurden mit Rust 1.99 und iced 0.14 unter Linux (Fedora 44), Windows 11 und macOS geprüft. Die Einrichtung wird für alle drei Systeme Schritt für Schritt gezeigt.
Ist das Buch bei neueren Rust-Versionen noch brauchbar?
Ja, in aller Regel. Neuere Versionen funktionieren meist genauso, nur der Wortlaut mancher Compiler-Meldungen kann sich etwas ändern.
Wurde das Buch von einer KI geschrieben?
Das Buch stammt von Volker Dähn. Statt eines klassischen Lektorats wurde der Text von einer KI (Claude von Anthropic) lektoriert und korrigiert. Das steht offen im Impressum des Buches, und alle Programme wurden tatsächlich auf drei Systemen geprüft.
Wie passt Rustlings.de dazu?
Rustlings sind kleine Übungsaufgaben zum Rust-Lernen, die Volker ins Deutsche übersetzt hat. Die Empfehlung: Rustlings zum Üben in kleinen Häppchen, das Buch zum Verstehen und Mitbauen. Du findest alles im Repository rustlings.de auf GitHub.
Gibt es einen zweiten Band?
Ja, er ist in Planung und setzt für die Oberfläche auf Dioxus. Mehr dazu im Abschnitt Band 2. Einen Erscheinungstermin gibt es noch nicht.
Ich habe einen Fehler gefunden. Was nun?
Schreib mir. Rückmeldungen sind ausdrücklich erwünscht und helfen, das Buch besser zu machen.
Such dir ein Problem. Dann bauen wir die Lösung.
Am Ende des Buches kannst du Programme schreiben, die Fenster zeichnen, Daten speichern, Fehler ehrlich behandeln und sich für drei Systeme verteilen lassen. Und du hast gelernt, dem Compiler zuzuhören.