So fühlt sich die Werkbank an.

Bevor wir anfangen

Stell dir vor, wir sitzen nebeneinander an einer Werkbank. Du hast die Tastatur vor dir, ich sitze daneben. Ich sage Dinge wie: „Probier mal …“, „Warte, schau dir die Meldung genau an …“ und „Jetzt bauen wir das aus.“

So ist dieses Buch gedacht. Du bekommst keine fertigen Programme zum Abtippen. Wir fangen jedes Mal mit fast nichts an, lassen es laufen, verändern etwas und schauen, was passiert. Das Programm wächst Schritt für Schritt, und du siehst bei jedem Schritt, warum es so wird, wie es wird.

Für wen ist dieses Buch?

Für dich, wenn du noch nie programmiert hast. Oder wenn du es schon einmal versucht hast und irgendwo hängen geblieben bist. Du brauchst keine Vorkenntnisse. Wenn du weißt, wie man eine Datei speichert und ein Programm startet, kannst du loslegen. Alles andere erkläre ich dir, und zwar langsam. Wenn dir etwas zu ausführlich vorkommt, überspring es einfach. Zu knapp ist für Einsteiger schlimmer als zu ausführlich.

Wenn du schon in einer anderen Sprache programmiert hast, wirst du manches schneller durchblättern. Lass dich nicht täuschen: Rust funktioniert in einigen Dingen grundlegend anders als die meisten Sprachen. Kapitel, die du zu kennen glaubst, verraten oft einen Unterschied im Detail.

Warum Rust?

Programmiersprachen sind Werkzeuge, und jedes Werkzeug hat Stärken. Rust wurde gebaut, damit man schnelle Programme schreiben kann, ohne bei der Sicherheit zu schummeln. Viele schnelle Sprachen lassen dich Fehler machen, die erst beim Ausführen auffallen: Abstürze, kaputte Daten, Sicherheitslücken. Rust verlangt dafür, dass du dem Compiler, dem Übersetzer deines Programms, genau erklärst, was du vorhast. Dafür findet er viele Fehler, bevor das Programm überhaupt läuft.

Das hat einen Preis, und ich verspreche dir, ehrlich darüber zu sprechen: Rust ist am Anfang strenger und anstrengender als andere Sprachen. Du wirst dich manchmal über den Compiler ärgern. Er will meistens etwas Vernünftiges, und seine Meldungen sind für Menschen geschrieben. Dieses Buch bringt dir bei, sie zu lesen.

Was bauen wir?

Wir lernen die Sprache von Grund auf und bauen währenddessen zwei Dinge: kleine Programme mit Fenstern (mit der Bibliothek iced, sprich „eisd“) und das Rezeptbuch, ein Kochbuch mit Vorratsschrank, und ein kleines Spiel, Küchenstress. Beides hält die Theorie in der Praxis fest. Am Ende hast du ein Programm, das du wirklich benutzen kannst, und du verstehst die Sprache so, dass du alleine weiterkommst.

Wie arbeiten wir?

Jedes Kapitel ist in kleine Schritte unterteilt. Damit du dich zurechtfindest, gibt es immer wiederkehrende Abschnitte:

• An der WerkbankHier bauen wir gemeinsam. Du tippst mit.
• HinschauenWir bleiben kurz stehen und schauen uns an, was gerade passiert ist.
• StolperstelleWir provozieren absichtlich einen Fehler. Fehlermeldungen sind in Rust keine Strafe, sondern ein Gespräch mit dem Compiler.
• Jetzt duEine kleine Aufgabe, die du allein probierst, bevor wir weitergehen. Die Lösung steht im Anhang.
• Ehrlich gesagtHier sage ich dir, wo Rust unbequem ist, und warum.
• Ins WerkzeugfachDie Kurzfassung zum Merken. Was hier steht, habe ich dir auch noch einmal in das Cheatsheet im Anhang übertragen.

Eine Bitte noch: Tippe den Code selbst ab, auch wenn es nur drei Zeilen sind. Deine Finger lernen mit, und du machst Tippfehler. An denen lernst du, wie der Compiler mit dir spricht. Kopieren ist erlaubt, aber es ist wie Schwimmen lernen, indem man anderen zuschaut.

Alle Beispiele wurden mit Rust 1.99 und iced 0.14 geprüft, und jede Fehlermeldung in diesem Buch stammt vom echten Compiler. Neuere Versionen funktionieren meist genauso, aber Meldungen können sich im Wortlaut etwas ändern.

Ein Wort zu den Fehlern

Du wirst Fehler machen. Wirklich. Jeder Programmierer macht jeden Tag welche, auch nach 20 Jahren. Der Unterschied zwischen Anfängern und Profis ist nicht, dass Profis weniger Fehler machen, sondern dass sie keine Angst vor ihnen haben. Rust hat dafür einen riesigen Vorteil: Seine Fehlermeldungen sind für Menschen geschrieben und schlagen oft schon die Lösung vor. Lies sie, statt wegzuklicken.

Hallo, Rust!

Jetzt wird es ernst, aber nicht schwer. Wir lassen den Computer zum ersten Mal etwas für uns tun.

Ein Projekt anlegen

Ein Programm besteht selten nur aus einer Datei. Rust-Programme leben in einem Projekt, das ist ein Ordner mit ein paar Dateien, die zusammengehören. Cargo legt ihn für uns an.

$ cargo new hallo_rust
$ cd hallo_rust

    Creating binary (application) `hallo_rust` package

„Binary“ heißt hier: ein Projekt, das ein startbares Programm ergibt, im Gegensatz zu einer Bibliothek. Die erste Zeile erzeugt einen neuen Ordner hallo_rust samt Inhalt. Die zweite wechselt hinein.

Was hat Cargo uns hingestellt?

Öffne den Ordner hallo_rust in VS Code (im Menü: Datei, Ordner öffnen). Du siehst:

• Cargo.toml: Der „Steckbrief“ deines Projekts. Schauen wir hinein:

[package]
name = "hallo_rust"
version = "0.1.0"
edition = "2024"

[dependencies]

• [package] beschreibt das Projekt: Name, Version, und die Edition der Sprache.
• [dependencies] ist die Liste der Abhängigkeiten, also der fertigen Bibliotheken, die du benutzt. Sie ist noch leer. Im letzten Kapitel dieses Teils, Kapitel 16, füllen wir sie zum ersten Mal.
• Das Dateiformat heißt TOML. Es besteht aus Abschnitten in eckigen Klammern und Zeilen name = wert.
• src/main.rs: Dein Quellcode. src steht für „source“, also Quelle. Die Endung .rs bedeutet Rust.
• .gitignore: Eine Hilfsdatei für das Versionsverwaltungsprogramm Git. Sie sagt, welche Dateien Git ignorieren soll. Du kannst sie ignorieren.

Später kommen zwei weitere Dinge dazu, wenn du das Projekt baust: ein Ordner target, in den Cargo alle Zwischen- und Endergebnisse legt, und eine Datei Cargo.lock, die genau festhält, welche Versionen von Bibliotheken benutzt wurden. Beide musst du nicht anfassen.

Öffne src/main.rs. Cargo hat sie schon befüllt:

fn main() {
    println!("Hello, world!");
}

Drei Zeilen. Du hast noch nichts geschrieben und besitzt bereits ein lauffähiges Programm.

Starten

$ cargo run

Cargo ruft den Compiler auf, übersetzt dein Programm und startet es. Du siehst etwa:

   Compiling hallo_rust v0.1.0 (...)
    Finished `dev` profile [unoptimized + debuginfo]
              target(s) in 0.17s
     Running `target/debug/hallo_rust`
Hello, world!

Die letzte Zeile ist die Ausgabe deines Programms. Die anderen Zeilen sind Cargos Berichte, was es gerade tut. Lies sie einmal ganz:

• Compiling heißt: Der Compiler hat dein Programm übersetzt.
• Finished dev profile heißt: Fertig, und zwar im Entwicklungsmodus. Dieser Modus übersetzt schnell, schaltet viele Prüfungen ein und optimiert wenig. Im Kapitel 35 lernst du den Gegenpart kennen.
• Running nennt die Datei, die gestartet wird: target/debug/hallo_rust. Das ist dein Programm. Du kannst es auch ohne Cargo direkt aus dem Terminal starten: ./target/debug/hallo_rust (unter Windows target\debug\hallo_rust.exe).

Starte das Programm noch einmal mit cargo run. Diesmal fehlt die Zeile mit „Compiling“: Cargo hat gemerkt, dass sich nichts geändert hat, und hat nichts neu übersetzt.

Drei Befehle, ein Unterschied

• cargo run übersetzt (falls nötig) und startet das Programm.
• cargo build übersetzt nur.
• cargo check prüft nur, ob dein Code gültig ist, ohne ein Programm zu erzeugen. Das ist deutlich schneller und genau das, was man beim Tippen oft braucht. Dein Editor ruft es im Hintergrund selbst auf.

Gelegentlich möchtest du ganz von vorn anfangen: cargo clean löscht den Ordner target. Der nächste Lauf übersetzt alles neu.

fn main() {

    println!("Hallo, Werkstatt!");

}

fn main() {
    println!("Hallo, Werkstatt!")
    println!("Zweite Zeile");
}

error: expected `;`, found `println`
 --> src/main.rs:2:34
  |
2 |     println!("Hallo, Werkstatt!")
  |                                   ^ help: add `;` here
3 |     println!("Zweite Zeile");
  |     ------- unexpected token

Mehr aus println! herausholen

println! kann mehr als feste Texte ausgeben. Probiere dieses Programm:

fn main() {
    let name = "Rustifer";
    let alter = 3;
    println!("Hallo, {}!", name);
    println!("Hallo, {name}!");
    println!("{0} ist {1} Jahre alt, {1} Jahre!", name, alter);
    println!("{name:?} und {alter:?}");
    println!("Klammern: {{ und }}");
    print!("ohne Umbruch, ");
    print!("dann weiter\n");
    eprintln!("das geht auf den Fehlerkanal");
}

Die Ausgabe:

Hallo, Rustifer!
Hallo, Rustifer!
Rustifer ist 3 Jahre alt, 3 Jahre!
"Rustifer" und 3
Klammern: { und }
ohne Umbruch, dann weiter
das geht auf den Fehlerkanal

Zeile für Zeile:

• {} ist ein Platzhalter. Der Wert dafür steht hinter dem Text, durch Komma getrennt. Bei mehreren Platzhaltern der Reihe nach.
• {name} setzt den Wert der Variable name direkt ein. Das ist die modernere und meist lesbarere Schreibweise. let kennst du noch nicht, das erklärt das nächste Kapitel. Es legt einen Namen für einen Wert fest.
• {0} und {1} sprechen die Werte hinter dem Text nach Nummer an. So kannst du denselben Wert mehrfach einsetzen.
• {name:?} gibt den Wert in der Debug-Form aus. Bei Text sieht man dadurch die Anführungszeichen. Bei komplizierteren Dingen ist das oft die einzige Möglichkeit, sie anzusehen. Wir benutzen das ständig.
• {{ und }} geben die geschweiften Klammern selbst aus.
• print! ist wie println!, aber ohne Zeilenumbruch. \n ist ein Zeilenumbruch.
• eprintln! gibt auf dem Fehlerkanal aus. Im Terminal sieht man keinen Unterschied. Aber erfahrene Nutzer können Fehler und normale Ausgaben getrennt umleiten. Für Fehlermeldungen ist eprintln! die richtige Wahl.

Kommentare

Manchmal willst du etwas in den Code schreiben, das nur für Menschen gedacht ist. Dafür sind Kommentare da. Der Compiler überliest sie:

fn main() {
    // Ein Kommentar für Menschen
    println!("Hallo"); // auch hinter einer Zeile
    /* Ein langer
       Kommentar */
    println!("Welt");
}

• // kommentiert den Rest der Zeile aus.
• /* … */ kommentiert alles dazwischen aus, auch über mehrere Zeilen.
• Es gibt noch /// für Dokumentationskommentare, die zu einer Funktion gehören. Davon später.

Ein guter Kommentar sagt, warum etwas so ist, nicht was da steht. Was dasteht, sieht man ja.

fn main() {
    let name = "Volker Daehn";
    let beruf = "Tischler";
    let ort = "Hamburg";
    println!("+------------------------+");
    println!("| {name}");
    println!("| {beruf}");
    println!("| {ort}");
    println!("+------------------------+");
}