5-Tages Seminar Einführung in Rust

Dieses 5-tägige Rust-Seminar bietet eine fundierte Einführung in die Grundlagen von Rust, darunter Speicherverwaltung (Ownership, Borrowing), der Standardbibliothek und Fehlerbehandlung. Die Teilnehmer lernen, wie man sauberen und sicheren Rust-Code schreibt, Module importiert und die umfangreichen Funktionen der Rust-Standardbibliothek nutzt.

Tag 1: Grundlagen von Rust

• Installation und Einrichtung
  • Rust Toolchain installieren (rustup)
  • Erstellen eines Projekts mit cargo
  • Die Struktur eines Rust-Projekts verstehen (src, Cargo.toml, target)
• Grundlegende Syntax und Datentypen
  • Variablen, Konstanten und Mutabilität
  • Primitive Datentypen: Integer, Float, Boolean, Char
  • Zusammengesetzte Datentypen: Arrays, Tuples
  • Rust’s Typensystem: Statisch typisierte Sprache
• Control Flow
  • Bedingte Anweisungen: if, else, match
  • Schleifen: loop, while, for
  • Pattern Matching für komplexere Fallunterscheidungen
• Erste Rust Programme schreiben
  • Erstellen eines "Hello World" Programms
  • Grundlegende Kontrolle über den Ablauf eines Programms

Tag 2: Arbeiten mit Funktionen und der Standardbibliothek

• Funktionen in Rust
  • Deklaration und Aufruf von Funktionen
  • Rückgabewerte und Parameter
  • Funktionen mit mehreren Parametern und Rückgabewerten
• Rust-Module und Import von Bibliotheken
  • Einführung in Module (mod) und deren Verwendung
  • Wie man Funktionen und Module in Rust importiert
  • Die Strukturierung von Code durch Module und Crates
  • Überblick über use und pub für Imports
• Einführung in die Rust Standardbibliothek
  • Was ist die Standardbibliothek? Warum und wie wird sie genutzt?
  • Nützliche Module der Standardbibliothek: std::collections, std::io, std::fs
  • Beispiele für den Einsatz der Standardbibliothek
  • Umgang mit Ein- und Ausgaben (z.B. stdin, stdout, stderr)

Tag 3: Speicherverwaltung - Ownership, Borrowing und Lifetimes

• Ownership
  • Was ist Ownership? Grundprinzipien von Rusts Speicherverwaltung
  • Move-Semantik in Rust
  • Stack und Heap in Rust: Wo werden Daten gespeichert?
• Borrowing und Referenzen
  • Einfache Referenzen und Mutability
  • Regeln für Borrowing: Nur eine mutable Referenz zur gleichen Zeit, mehrere immutable Referenzen
• Lifetimes
  • Einführung in das Lifetimes-Konzept: Warum Lifetimes wichtig sind
  • Wie Rust Lifetimes nutzt, um Speicherprobleme zu vermeiden
  • Arbeiten mit expliziten Lifetimes

Tag 4: Fortgeschrittene Speicherverwaltung und Datentypen

• Datenstrukturen in Rust
  • Structs: Definition und Verwendung von Structs
  • Enums: Unterschied zu Structs und wann sie verwendet werden sollten
  • Pattern Matching mit Enums
• Fortgeschrittene Referenzierung und Ownership
  • Wie man mit komplexeren Ownership-Situationen umgeht
  • Versteckte Fallstricke vermeiden: Doppelte Freigabe und Datenrennen
• Box, Rc, Arc, und Smart Pointers
  • Einführung in Smart Pointers und deren Verwendung in Rust
  • Unterschied zwischen Box, Rc, und Arc
  • Wann und warum man Smart Pointers verwendet

Tag 5: Fehlerbehandlung und Best Practices

• Fehlerbehandlung in Rust
  • Unterschied zwischen panischen Fehlern (panic!()) und Resultaten (Result, Option)
  • Einführung in den Umgang mit Result und Option
  • Das ?-Operator für einfache Fehlerbehandlung
• Einführung in Rust’s Best Practices
  • Idiomatischer Rust-Code: Wie man Rust auf die „richtige“ Weise schreibt
  • Code-Organisation und Strukturierung: Modules, Crates, und Libraries
  • Rust-Formatter und Linter: rustfmt und clippy
• Praxisübungen und Abschlussprojekt
  • Implementierung eines kleinen Programms, das die gelernte Speicherverwaltung, Fehlerbehandlung und Nutzung der Standardbibliothek kombiniert