Modul 1 — Installation, Cargo & dein erstes Programm

Rust ist eine Systemsprache mit Garantien: kein Buffer Overflow, keine Data Race, kein use-after-free — und das alles zur Compile-Zeit, ohne Garbage Collector. Deshalb nutzen Rust die Linux-Kernel-Entwickler, Cloudflare, Dropbox und die meisten der am meisten geliebten Sprach-Umfragen.

Installation mit rustup

Der offizielle Weg ist rustup — ein Toolchain-Manager, der den Compiler rustc, das Build-Tool cargo und die Standardbibliothek-Doku installiert und auf dem neuesten Stand hält:

# Linux / macOS / WSL
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Windows: rustup-init.exe von https://rustup.rs

Danach prüfen:

rustc --version
cargo --version

Merkliste:

• rustup = Werkzeugkasten-Verwaltung
• rustc = der Compiler selbst
• cargo = Projekt-Baukasten (Build, Test, Abhängigkeiten)

Ein Rust-Projekt heißt crate. Cargo legt es an, baut es, testet es:

cargo new hello_rust
cd hello_rust
cargo run     # bauen + ausführen
cargo check   # nur typprüfen, keine Binary — sehr schnell
cargo build   # bauen, Binary liegt in target/debug/

cargo check ist dein Dauerbegleiter beim Schreiben: Es durchläuft Parsing, Typprüfung und Borrow-Checker, erzeugt aber kein ausführbares Programm — deshalb ist es deutlich schneller als cargo build.

src/main.rs nach cargo new:

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

• fn main() — Einstiegspunkt jedes ausführbaren Programms
• println! — ein Makro (erkennbar am !), kein Funktionsaufruf

Platzhalter

Rust kennt zwei Formatierungsarten — inline nach Variablenname und positional:

fn main() {
    let name = "Rust";
    println!("Hello, {name}!");        // inline: greift die Bindung `name`
    println!("{} + {} = {}", 1, 2, 3); // positional: der Reihe nach
}

Beide Zeilen geben Hello, Rust! bzw. 1 + 2 = 3 aus. Inline-Formatierung funktioniert mit jeder Bindung im Scope — super lesbar, deshalb der Alltagsstil in modernem Rust.

Übung: Dein erstes Programm

Variablen sind standardmäßig unveränderlich:

fn main() {
    let x = 5;
    // x = 6;        // ❌ E0384: cannot assign twice to immutable variable
    let mut y = 5;
    y = 6;           // ✅ explizit veränderlich
    println!("{x} {y}");
}

Das ist eine Design-Entscheidung, keine Bevormundung: Unveränderlichkeit ist der Normalfall, Mutabilität muss man hinschreiben — wer Code liest, sieht so sofort, wo sich etwas ändern kann.

Blöcke sind Ausdrücke

Ein Block in geschweiften Klammern wertet zu seinem letzten Ausdruck aus — ohne Semikolon:

fn main() {
    let y = {
        let a = 2;
        a * 3      // kein Semikolon → Wert des Blocks
    };
    println!("{y}"); // 6
}

Genau dieses Prinzip macht später Funktionskörper, if-Ausdrücke und match zu Wert-Lieferanten. Das Semikolon ist in Rust kein Zeilenende, sondern ein Operator, der einen Ausdruck zu einer Anweisung macht (und dabei den Wert wegwirft).

Übungen: Compiler-Fehler entziffern