LFD480 Programming in Rust

Seminarinformationen

Seminar - Ziel

In dieser 4-tägigen Schulung "LFD480 Programming in Rust" erhalten Sie eine umfassende Einführung in die Rust-Programmiersprache und erweitern Ihr Wissen bis hin zu fortgeschrittenen Konzepten. Der Kurs beginnt mit einer gründlichen Übersicht über Rust und führt Sie schrittweise durch zentrale Themen wie Programmfluss, komplexe Datentypen, Fehlerbehandlung, objektorientierte Programmierung, Closures, Iteratoren, Lifetimes, Crates und Open-Source-Funktionen.

Sie lernen, wie Sie Unit-Tests durchführen und Ihre Rust-Programme durch Benchmarking optimieren. Fortgeschrittene Themen wie Smart Pointer, Concurrency in Rust und spezifische Rust-Mechanismen werden ebenfalls behandelt. Zudem erhalten Sie Einblicke in die Nutzung von Rust in Containern und werden auf das Cross-Compiling vorbereitet, um die Anwendung in verschiedenen Umgebungen zu ermöglichen.

Teilnehmer - Zielgruppe

• Entwickler
• Programmierer

Kurs - Voraussetzungen

• Erfahrung in einer systemnahen Programmiersprache wie C oder C++
• Verständnis von Software Development Prozessen
• Grundkenntnisse in Linux oder Unix Systemen
• Kenntnisse in Data Structures und Algorithms von Vorteil

Seminardauer

• 4 Tage
• 09:00 Uhr bis 17:00 Uhr

Schulungsunterlagen

• nach Absprache

Seminar-Inhalt / Agenda

Einführung

• Die Linux Foundation
• Linux Foundation Training
• Linux Foundation Zertifizierungen
• Linux Foundation Digital Badges
• Linux Foundation Abonnements
• Laboratory, Lösungen und Ressourcen
• Veränderungen in Linux- und Open-Source-Projekten
• Distribution Details
• Labs

Grundlagen

• Labs

Einführung in Rust

• Geschichte von Rust
• Beliebtheit von Rust
• In Rust programmierte Software
• Die Philosophie hinter Rust
• Warum nicht Rust
• Rust als erste Programmiersprache
• Rust und Software Engineering
• Rusts Release-Zyklus
• Rusts Release-Zeitplan
• Rust REPL
• Installation und Konfiguration der Rust-Umgebung
• Aufbau eines Rust-Programms
• Verwendung von Cargo
• Abenteuer mit Rust
• Labs

Mein erstes Rust-Programm

• Variablen
• Konstanten
• Ownership & Borrowing
• Die drei Ownership-Regeln
• Primitive Datentypen mit dem Copy Trait
• Rust ist eine Ausdruckssprache
• Primitive Datentypen
• Strings & Str
• Objekt- bzw. Owned Strings
• Verständnis von String Slices
• Arrays
• Labs

Programmablauf

• Einführung in Bedingungen
• Bedingungen – if
• Bedingungen – match
• Match-Ausdrücke in Rust
• Schleifen
• Schleifen in Rust
• Die While-Schleife
• Verwendung von Break und Continue in einer For-Schleife
• Labs

Komplexe Datentypen

• Tupel
• Structs
• Enums
• Vektoren
• HashMaps
• Erstellen und Initialisieren einer HashMap
• Fazit
• Methoden zum Zugriff auf Daten in HashMaps
• Best Practices und Anwendungsfälle
• Iterationsreihenfolge von HashMaps
• Entfernen von Daten anhand eines Schlüssels
• Labs

Funktionen in Rust

• Funktionen
• Labs

Fehlerbehandlung in Rust

• Panic
• Beispiel für die Behandlung eines nicht behebbaren Fehlers
• Erweitertes Pattern Matching
• Warum Closures mit unwrap_or_else verwendet werden
• Vor- und Nachteile der Verwendung von unwrap
• Anwendungsfälle und Tipps für unwrap
• Upstream-Fehlerbehandlung
• Verbesserungen der neuen gegenüber der alten Version
• Labs

Testen in Rust

• Testen in Rust
• Unit-Tests
• Doc-Tests
• Integrationstests
• Labs

Debugging in Rust

• Debugging in Rust
• Labs

Objektorientierte Programmierung in Rust

• OOP in Rust
• tructs und Methoden
• Composition statt Inheritance
• Kapselung
• Traits
• Generics – statischer Dispatch
• Das Problem, das Generics lösen
• Object Traits – dynamischer Dispatch
• Labs

Closures

• Einführung in Closures
• Labs

Iteratoren

• Iteratoren
• Tipps zur Verwendung von Iteratoren in Rust
• Elemente mit einem Iterator aufsummieren
• Iterator-Consumer verstehen
• Transformationen mit map anwenden
• Labs

Lifetimes

• Lifetimes
• Labs

Crates

• Code-Organisation in Rust
• Crates in Rust
• Dateistruktur
• Beispiele
• Tipps für die Arbeit mit Crates
• Programmierung großer Projekte mit Rust
• Dateistruktur
• Labs

Betriebssystemfunktionen

• Umgebungsvariablen (ENV vars)
• Datei-E/A (File I/O)
• Hinzufügen von inotify zu Cargo.toml
• Prozesse
• Labs

Benchmarking und Profiling von Rust-Programmen

• Benchmarking
• Profiling
• Labs

Smart Pointer

• Box
• Die Rolle von Box in rekursiven Strukturen
• Rc und Arc
• Cell und RefCell
• Mutex und RwLock
• Labs

Concurrency in Rust

• Concurrency
• Rusts Ansatz zur Nebenläufigkeit
• Threads in Rust
• Message Passing
• Shared-State-Concurrency
• Atomare Operationen
• Asynchrone Programmierung in Rust
• Fazit
• Labs

Verwendung von Rust in Containern

• Rust in Podman-Containern erstellen (Build)
• Labs

Cross-Compiling in Rust

• Einrichten von Rust für Cross-Compiling
• Labs

Fortgeschrittene Themen

• Foreign Function Interface (FFI)
• Unsafe Rust
• Labs

Abschluss und Evaluationsumfrage

• Evaluationsumfrage

Weitere Schulungen zu Thema Linux Foundation