LFD480: Programming in Rust
Rust idiomatisch programmieren: Ownership, Concurrency, Testing und Deployment praxisnah anwenden
Die wichtigsten Themen
Ownership und Borrowing sicher anwenden
Cargo, Crates und Module nutzen
Fehlerbehandlung mit Result und Option
Tests, Profiling und Benchmarks erstellen
Concurrency mit Threads und Async
Deployment für Container und Architekturen
Überblick Offizielle Schulungsumgebung mit praxisnahen Labs · Offizielle digitale Linux Foundation-Unterlagen in englischer Sprache · Instructor-led Training mit erfahrenem Dozenten...
In dieser 4-tägigen LFD480 Schulung lernst du die Rust-Programmiersprache systematisch und praxisnah, vom ersten Programm bis zu fortgeschrittenen Konzepten für sichere, performante und wartbare Software. Der Kurs vermittelt idiomatisches Rust mit zentralen Sprachkonzepten wie Ownership, Borrowing, Lifetimes, starkem Typsystem, Pattern Matching, Fehlerbehandlung, Traits, Generics, Closures und Iteratoren. Damit eignet sich das Training besonders für Entwicklerinnen und Entwickler, die Rust für Systemprogrammierung, Web-Backends, API-Clients und -Server, Embedded-nahe Anwendungen oder nebenläufige Programme einsetzen möchten.
Ein besonderer Schwerpunkt liegt auf Hands-on-Labs und dem praktischen Arbeiten mit Cargo, Crates, Modulen, Unit Tests, Doc Tests, Integration Tests, Debugging, Benchmarking und Profiling. Fortgeschrittene Themen wie Smart Pointer, Concurrency, asynchrone Programmierung, Foreign Function Interface, Unsafe Rust, Cross-Compiling sowie der Einsatz von Rust in Containern und Kubernetes werden fachlich fundiert behandelt. Für Teams, die Rust mit Linux- und Container-Workloads verbinden, ergänzt die Schulung vorhandenes Know-how aus dem Linux / UNIX Shellprogrammierung Grundkurs und dem Docker Grundkurs sinnvoll.
Leistungsumfang:
- Offizielle Schulungsumgebung mit praxisnahen Labs
- Offizielle digitale Linux Foundation-Unterlagen in englischer Sprache
- Instructor-led Training mit erfahrenem Dozenten
- Certificate of Completion und Digital Badge nach erfolgreicher Teilnahme
- Verpflegung bei Präsenzterminen
Die Themen Einordnung von Rust, Einsatzgebiete und Sprachphilosophie · Rust-Release-Zyklus und Werkzeugumgebung · Installation und Konfiguration der Rust-Umgebung · Aufbau eines Rust-Programms...
Rust-Grundlagen und Entwicklungsumgebung
- Einordnung von Rust, Einsatzgebiete und Sprachphilosophie
- Rust-Release-Zyklus und Werkzeugumgebung
- Installation und Konfiguration der Rust-Umgebung
- Aufbau eines Rust-Programms
- Arbeiten mit Cargo und Projektstrukturen
- Variablen, Konstanten und grundlegende Syntax
Typsystem, Ownership und Programmfluss
- Primitive Datentypen und Copy Trait
- Strings, String Slices und Besitzmodell
- Ownership, Borrowing und zentrale Ownership-Regeln
- Rust als Expression Language
- Bedingungen mit if und match
- Schleifen, break und continue
Komplexe Datentypen und Collections
- Tuples, Structs und Enums
- Vectors und HashMaps
- Initialisierung, Zugriff und Iteration von Collections
- Best Practices für HashMaps
- Entfernen und Aktualisieren von Collection-Einträgen
Funktionen, Fehlerbehandlung und Pattern Matching
- Funktionen und Funktionssignaturen
- Panic und nicht wiederherstellbare Fehler
- Result und Option für robuste Programme
- Advanced Pattern Matching
- Upstream Error Handling
- Sinnvoller Umgang mit unwrap und unwrap_or_else
Tests, Debugging und Code-Qualität
- Unit Testing in Rust
- Doc Testing
- Integration Testing
- Debugging von Rust-Programmen
- Benchmarking und Profiling
- Performance-Analyse mit geeigneten Werkzeugen
Objektorientierte Konzepte in Rust
- Structs und Methoden
- Encapsulation und Composition over Inheritance
- Traits und Generics
- Static Dispatch mit Generics
- Dynamic Dispatch mit Trait Objects
- Typische Anwendungsfälle für Traits
Closures, Iteratoren und Lifetimes
- Closures und typische Einsatzmuster
- Iteratoren und Iterator Consumers
- Transformationen mit map
- Aggregation und Summierung mit Iteratoren
- Lifetimes und Referenzgültigkeit
- Praktische Bedeutung von Lifetimes im Code-Design
Crates, Module und größere Projekte
- Code-Organisation in Rust
- Crates und Module
- Datei- und Verzeichnisstrukturen
- Einbindung externer Bibliotheken
- Arbeiten mit dem Rust-Ökosystem
- Programmieren größerer Codebasen mit Rust
OS-Funktionen und systemnahe Programmierung
- Umgebungsvariablen
- Datei-I/O
- Prozesse und Prozesssteuerung
- Einbindung von inotify
- Systemnahe API-Clients und -Server
Smart Pointer und Nebenläufigkeit
- Box für Heap-Allokation und rekursive Strukturen
- Rc und Arc
- Cell und RefCell
- Mutex und RwLock
- Threads und Message Passing
- Shared State Concurrency und Atomic Operations
Async, Container und Cross-Compiling
- Asynchrone Programmierung in Rust
- Rust in Containern mit Podman
- Rust-Anwendungen in Container- und Kubernetes-Umgebungen
- Cross-Compiling mit Rust
- Deployment für x86_64, ARM64 und RISCV64
Fortgeschrittene Rust-Techniken
- Foreign Function Interface für C-Code
- Unsafe Rust und sichere Abgrenzung
- Ausgewählte fortgeschrittene Rust-Themen
- Dokumentation und Pflege von Rust-Code
Zielgruppe
- Systemprogrammiererinnen und Systemprogrammierer, die Rust für performante und speichersichere Software einsetzen
- Anwendungsentwicklerinnen und Anwendungsentwickler mit Erfahrung in C, C++, Java, JavaScript oder Go
- Backend- und API-Entwicklungsteams, die robuste Services, Clients oder Server in Rust realisieren
- DevOps- und Plattform-Teams mit Bedarf an Rust für Container, Kubernetes und Multi-Architektur-Deployments
Das lernst du
- Idiomatic Rust Code mit Ownership, Borrowing und Lifetimes sicher entwerfen
- Robuste Programme mit Result, Option, Pattern Matching und strukturierter Fehlerbehandlung entwickeln
- Eigene Crates, Module und größere Rust-Projektstrukturen mit Cargo organisieren
- Rust-Anwendungen mit Unit Tests, Doc Tests, Integration Tests, Debugging und Profiling absichern
- Nebenläufige Programme mit Threads, Message Passing, Shared State und Async-Konzepten umsetzen
- Rust-Anwendungen für Container, Kubernetes und Zielarchitekturen wie x86_64, ARM64 und RISCV64 vorbereiten
So arbeiten wir
- Instructor-led Training mit fachlichen Erklärungen, Live-Demonstrationen und geführten Übungen
- Hands-on-Labs in der offiziellen Schulungsumgebung der Linux Foundation
- Schrittweiser Aufbau vom ersten Rust-Programm bis zu fortgeschrittenen Sprachfeatures
- Praxisübungen zu Cargo, Testing, Debugging, Profiling, Concurrency, Containern und Cross-Compiling
- Code-Reviews, Diskussion typischer Fehlerbilder und Transfer auf eigene Entwicklungsprojekte
Empfohlene Vorkenntnisse
- Programmiererfahrung in mindestens einer Sprache wie C, C++, Java, JavaScript oder Go
- Grundverständnis von Betriebssystemfunktionen, Prozessen und Datei-I/O
- Technisches Englisch zum Arbeiten mit Herstellerunterlagen und Laboranleitungen
- Für die Labs ein System mit x86_64, ARM64 oder RISCV64, mindestens 4 GiB RAM und 50 GiB freiem Speicher
- Für Container- und Kubernetes-Labs ist zusätzlicher Arbeitsspeicher empfehlenswert
- Linux-Grundlagen sind hilfreich, zum Beispiel aus dem Linux Grundkurs
Dein Fahrplan
- Einordnung von Rust, Einsatzgebiete und Entwicklungsumgebung
- Erstes Rust-Programm und Arbeiten mit Cargo
- Variablen, Konstanten, primitive Datentypen und Strings
- Ownership, Borrowing und grundlegende Speichersemantik
- Programmfluss mit if, match, loops, while und for
- Hands-on-Labs zu Syntax, Ownership und Programmfluss
Organisatorisches
Lernformate
Unsere Seminare bieten dir maximale Flexibilität: Du kannst zwischen Live-Online und Vor Ort in unseren modernen Schulungszentren im D-A-CH Raum wählen. Beide Formate garantieren dir die gleiche hohe Qualität und interaktive Lernerfahrung.
Schulungsarten
Wir bieten dir verschiedene Schulungsarten: Offene Seminare, Firmenseminare für Teams und Inhouse-Schulungen direkt bei dir vor Ort. So findest du genau das Format, das zu deinen Bedürfnissen passt.
Uhrzeiten
09:00-17:00 Uhr
Aktuelle Software
In unseren offenen Kursen arbeiten wir mit der aktuellsten Software-Version. So lernst du direkt mit den Tools und Features, die du auch in deinem Arbeitsalltag verwendest - praxisnah und zukunftsorientiert. Bei Inhouse- und Firmenschulungen bestimmt ihr die Version.
Deine Vorteile
Zufriedenheitsgarantie
Wir sind von unserer Qualität überzeugt. Sollte ein Training einmal nicht deinen Erwartungen entsprechen, bieten wir dir an, den Kurs kostenlos zu wiederholen oder ein anderes Training zu besuchen. Ohne Risiko, ohne Diskussion.
Inklusivleistungen
Deine Teilnahme beinhaltet: Schulungsmaterial, Zertifikat, Verpflegung (bei Präsenzveranstaltungen) und persönliche Betreuung durch unsere Trainer und unser Orga-Team. Alles aus einer Hand - keine versteckten Kosten.
Lernen von Experten
Unsere Trainer sind zertifizierte und erfahrene Profis mit jahrelanger Berufserfahrung. Sie vermitteln dir in den Kursen nicht nur theoretisches Wissen, sondern teilen ihre Erfahrungen aus realen Projekten und helfen dir, das Gelernte direkt in deiner täglichen Arbeit anzuwenden. Das ist kein Werbeversprechen, sondern unser Anspruch. Am besten siehst du das in unseren Bewertungen, z.B. auch bei Google.
Keine Vorkasse
Du zahlst erst nach dem Seminar. Keine Vorkasse, keine Vorauszahlung - so kannst du sicher sein, dass du nur für das bezahlst, was du auch wirklich erhalten hast. Die Rechnung erhältst du erst nach Kursbeginn.
Max. 8 Teilnehmende
Wir setzen auf kleine Gruppen, damit du die Aufmerksamkeit bekommst, die du verdienst. So haben wir mehr Zeit für deine individuellen Fragen und können gezielt auf deine Bedürfnisse eingehen.
Termine & Buchung
Leider haben wir aktuell keine Termine geplant. Es wird wahrscheinlich bei uns etwas schief gelaufen sein - bitte kontaktiere uns und wir finden den passenden Termin.
Nicht der passende Termin dabei?
Wir finden eine Lösung: anderer Termin, mehrere Teilnehmer, Inhouse-Schulung oder individuelle Beratung.
Lieber gleich das ganze Team schulen?
Diese Schulung gibt es auch exklusiv für dein Unternehmen, bei euch vor Ort, an unseren Standorten oder Live-Online. Inhalte und Termine nach Maß.
Inhouse-Schulung
Wir kommen zu euch: diese Schulung maßgeschneidert in euren Räumen, für Unternehmen und Behörden.
- Inhalte exakt auf euch zugeschnitten
- Termine nach euren Bedürfnissen
- Günstiger ab mehreren Teilnehmern
- Vertraute Umgebung, kein Reiseaufwand
Firmen-Seminar
Exklusiv für dein Team an einem unserer Standorte oder Live-Online, individuell angepasst.
- Geschlossene Gruppe aus eurem Haus
- Individuelle Terminplanung
- An unseren Standorten oder Live-Online
- Angepasste Inhalte
Fragen und Antworten zu LFD480: Programming in Rust
Ist die LFD480 Schulung für Rust-Einsteiger geeignet?
Ja, wenn du bereits programmieren kannst. Die Schulung startet mit Rust-Grundlagen, setzt aber Erfahrung in einer anderen Programmiersprache wie C, C++, Java, JavaScript oder Go voraus. Ohne Programmiererfahrung ist der Kurs nicht als Einstieg in Softwareentwicklung gedacht.
Welche Rust-Themen werden in der Schulung besonders vertieft?
Vertieft werden unter anderem Ownership, Borrowing, Lifetimes, Traits, Generics, Fehlerbehandlung, Cargo, Crates, Testing, Debugging, Profiling, Smart Pointer, Concurrency, Async-Programmierung, FFI, Unsafe Rust, Container und Cross-Compiling.
Gibt es in LFD480 praktische Übungen?
Ja. Die Schulung arbeitet mit offiziellen Hands-on-Labs der Linux Foundation. Du übst die wichtigsten Sprachkonzepte direkt im Code und wendest sie auf typische Aufgaben aus Systemprogrammierung, API-Entwicklung, Testing und Deployment an.
Brauche ich Linux-Kenntnisse für Programming in Rust?
Grundlegende Betriebssystemkenntnisse sind wichtig, da im Kurs auch OS-Funktionen, Datei-I/O, Prozesse, Container und Cross-Compiling behandelt werden. Wenn du deine Linux-Basis vorher festigen möchtest, passt der Linux Grundkurs als Vorbereitung.
Wird Rust mit Docker oder Kubernetes behandelt?
Ja. Der Kurs behandelt den Einsatz von Rust in Containern sowie die Bereitstellung in Container- und Kubernetes-Umgebungen. Für eine tiefere Container-Praxis ist ergänzend der Linux Container Workshop sinnvoll.
Erhalte ich nach LFD480 eine offizielle Zertifizierung?
LFD480 ist ein offizielles Linux Foundation Training mit Certificate of Completion und Digital Badge nach erfolgreicher Teilnahme. Eine eigenständige Zertifizierungsprüfung ist für dieses Seminar nicht Bestandteil der Kursbeschreibung.
Weitere häufig gestellte Fragen und Antworten findest du in den FAQs .
Unser Qualitätsversprechen: Wissen, das in der Praxis funktioniert
Aus der Praxis für die Praxis
Schluss mit theoretischem Ballast. Wir trainieren dich für reale IT-Herausforderungen, nicht für Multiple-Choice-Tests. Unsere Trainer vermitteln dir genau das Wissen, das am nächsten Montagmorgen im Job wirklich funktioniert.
Individuell statt "Schema F"
Deine Fragen passen nicht ins Standard-Skript? Bei uns schon. Wir verzichten auf starre Lehrpläne und geben deinen konkreten Projekt-Fragen Raum. Unsere Trainer passen die Inhalte flexibel an das an, was dich und dein Team aktuell weiterbringt.
Maximale Freiheit: Remote oder vor Ort
Lerne so, wie es in deinen Alltag passt - ohne Reise-Stress und Zeitverlust. Egal ob remote, hybrid oder präsent vor Ort: Wir garantieren dir ein nahtloses und effektives Lernerlebnis, egal von wo du dich zuschaltest.
Mit Zufriedenheitsgarantie
Wir sind von unserer Qualität überzeugt - und wollen, dass du es auch bist. Sollte ein Training einmal nicht deinen Erwartungen entsprechen, bieten wir dir an, den Kurs kostenlos zu wiederholen oder ein anderes Training zu besuchen. Ohne Risiko, ohne Diskussion.
Über 20.000 Unternehmen und Behörden vertrauen auf uns
