Rust

Weblink

• Boris Paskhaver Learn to Code with Rust

Phase 1: Grundlagen (Wochen 1-2)

Ziel: Verstehen der Basiskonzepte von Rust und der Toolchain.

• Installation und Setup
  • `rustup`, `rustc` und `cargo`.
  • "Hello World!" Programm.
  • IDE-Setup (z. B. VS Code mit rust-analyzer).
• Grundlegende Syntax
  • Variablen und Mutabilität (`let`, `let mut`).
  • Datentypen (Skalare und Verbundtypen).
  • Funktionen und Kommentare.
• Kontrollstrukturen
  • `if`, `else if`, `else`.
  • Schleifen (`loop`, `while`, `for`).
• Ressourcen: Das offizielle Rust Book (Kapitel 1-3)

Phase 2: Ownership und Borrowing (Wochen 3-4)

Ziel: Meistern des wichtigsten und einzigartigsten Konzepts von Rust.

• Ownership
  • Stack vs. Heap.
  • Ownership-Regeln.
  • Die `String` Typen und Speichermanagement.
• Referenzen und Borrowing (Ausleihen)
  • Mutable und Immutable References.
  • Data Races verhindern.
• Slices
  • String Slices (`&str`).
  • Array Slices.
• Ressourcen: The Rust Book (Kapitel 4), Rustlings Übungen.

Phase 3: Fortgeschrittene Datenstrukturen (Wochen 5-6)

Ziel: Komplexe Datenmodelle erstellen.

• Structs (Strukturen)
  • Definieren und Instanziieren.
  • Methoden und assoziierte Funktionen (`impl` Blöcke).
• Enums (Aufzählungen) und Pattern Matching
  • Enums definieren.
  • Die `Option` und `Result<T, E>` Enums.
  • Der `match` Kontrollfluss.
  • `if let` Syntax.
• Collections (Auflistungen)
  • Vektoren (`Vec`).
  • Strings (`String` vs `&str`).
  • Hash Maps (`HashMap<K, V>`).
• Ressourcen: The Rust Book (Kapitel 5, 6, 8).

Phase 4: Fehlerbehandlung, Generics und Traits (Wochen 7-8)

Ziel: Robusten und wiederverwendbaren Code schreiben.

• Fehlerbehandlung
  • Unrecoverable Errors (`panic!`).
  • Recoverable Errors (`Result`).
  • Propagieren von Fehlern (der `?` Operator).
• Generics
  • In Funktionen, Structs und Enums.
• Traits (Schnittstellen)
  • Traits definieren und implementieren.
  • Trait Bounds.
• Lifetimes (Lebensdauern)
  • Validierung von Referenzen.
• Ressourcen: The Rust Book (Kapitel 9, 10).

Phase 5: Praktische Anwendung und fortgeschrittene Themen (Wochen 9-12)

Ziel: Eigene Projekte bauen und das Ökosystem verstehen.

• Schreiben von automatisierten Tests
  • Unit-Tests und Integrations-Tests.
• Iteratoren und Closures
  • Funktionale Sprachfeatures in Rust.
• Cargo und Crates.io
  • Eigene Libraries schreiben und Abhängigkeiten verwalten.
  • Workspaces.
• Smart Pointers (Optional/Fortgeschritten)
  • `Box`, `Rc`, `RefCell`.
• Nebenläufigkeit (Concurrency)
  • Threads.
  • Message Passing (Channels).
  • Shared State (`Mutex`, `Arc`).

Abschlussprojekt

• Ideen:
  • Ein CLI-Tool (z. B. eine eigene `grep`-Version wie `minigrep` aus dem Buch).
  • Ein einfacher Webserver (z.B. mit dem `axum` oder `actix-web` Framework).
  • Ein kleines TUI-Spiel (z.B. Snake) mit `ratatui`.

Kontinuierliches Lernen

• Rust by Example
• Täglich oder wöchentlich an Rustlings arbeiten.
• Rust-Code von Open-Source-Projekten lesen.