Formation Rust

Leçon 1 • Principes Essentiels du Contrôle de Flux

Enseigne les structures if/else, les boucles et la correspondance de motifs. Permet aux étudiants d'orienter l'exécution d'un programme par le biais de branchements et d'itérations.

Leçon 2 • Fonctions et Modules

Définit les signatures de fonctions, les types de retour et la visibilité des modules. Établit les modèles d'organisation du code utilisés tout au long du cours.

Leçon 3 • Syntaxe de Base et Types de Données

Introduit les variables, les types scalaires et les types composés. Construit le vocabulaire nécessaire pour exprimer la logique dans tous les chapitres suivants.

Leçon 4 • Cargo et Structure de Projet

Explore les commandes Cargo, Cargo.toml et la disposition des espaces de travail. Les étudiants acquièrent les compétences en gestion de projet nécessaires pour tous les exercices pratiques.

Leçon 1 • Références et Emprunt

Introduit les références partagées et mutables avec les règles d'emprunt. Les étudiants apprennent à passer des données sans transférer la propriété.

Leçon 2 • Règles de Propriété et Sémantique de Déplacement

Explique l'invariant de propriétaire unique et les déplacements de valeurs. Aborde directement les erreurs de compilation les plus courantes pour les débutants en Rust.

Leçon 3 • Annotations de Durée de Vie

Enseigne la syntaxe explicite de durée de vie pour les fonctions et les structures. Permet aux étudiants de résoudre les erreurs de durée de vie que le compilateur ne peut pas inférer automatiquement.

Leçon 4 • Types Tranche

Couvre les tranches de chaîne et les tranches de tableau en tant que vues de référence. Relie les concepts d'emprunt à des modèles pratiques d'accès aux données.

Leçon 1 • Méthodes et Fonctions Associées

Ajoute du comportement aux structures via les blocs impl et les constructeurs. Fait le pont entre la modélisation des données et l'encapsulation de type orientée objet en Rust.

Leçon 2 • Définir et Utiliser les Structures

Couvre les structures nommées, tuples et unitaires avec accès aux champs. Fournit l'outil principal pour regrouper des données connexes tout au long du cours.

Leçon 3 • Correspondance de Motifs Avancée

Étend match à la déstructuration, aux gardes et à la liaison. Permet une gestion concise et exhaustive de formes de données complexes.

Leçon 4 • Énumérations et Type Option

Introduit les énumérations avec variantes de données et le type Option<T>. Élimine les erreurs de pointeur nul en codant l'absence de manière explicite dans le système de types.

Leçon 1 • Traits de la Bibliothèque Standard

Passe en revue Display, Debug, From, Into, Iterator et Clone. L'intégration de ces traits permet aux types personnalisés d'interopérer avec l'ensemble de l'écosystème.

Leçon 2 • Bornes de Trait et Clauses Where

Contraint les génériques avec des bornes de trait et la syntaxe where. Permet au compilateur de vérifier que les types génériques prennent en charge les opérations requises.

Leçon 3 • Fonctions et Structures Génériques

Introduit les paramètres de type pour les fonctions, les structures et les énumérations. Permet d'écrire des algorithmes qui opèrent sur n'importe quel type compatible.

Leçon 4 • Dispatch Dynamique avec les Objets Trait

Oppose le dispatch statique à dyn Trait pour le polymorphisme à l'exécution. Les étudiants choisissent la stratégie de dispatch appropriée pour chaque scénario de conception.

Leçon 1 • L'Opérateur ? et la Propagation

Enseigne l'opérateur ? pour une propagation concise des erreurs dans les fonctions. Réduit considérablement le code passe-partout dans les fonctions qui appellent plusieurs opérations sujettes aux erreurs.

Leçon 2 • Types d'Erreur Personnalisés

Covers defining error enums, implementing std::error::Error, and conversions. Enables libraries to expose meaningful, structured error information.

Leçon 3 • Gestion des Erreurs dans les Applications

Introduit anyhow pour l'agrégation d'erreurs et le contexte au niveau de l'application. Fait le pont entre les erreurs typées de style bibliothèque et les messages de diagnostic destinés à l'utilisateur.

Leçon 4 • Panique et Erreurs Irrécupérables

Explique panic!, assert! et le déroulement de la pile. Établit quand un crash est approprié par rapport au moment où les erreurs doivent être propagées.

Leçon 1 • Itérateurs Personnalisés

Guide les étudiants dans l'implémentation d'Iterator sur des structures personnalisées. Approfondit la compréhension du système de traits et permet une itération spécifique au domaine.

Leçon 2 • Fermetures et Capture

Explique la syntaxe des fermetures, les modes de capture et les familles de traits Fn. Permet de passer un comportement en tant que valeur aux itérateurs et aux fonctions d'ordre supérieur.

Leçon 3 • Vec, HashMap et HashSet

Couvre la création, l'insertion, la recherche et la suppression pour les collections de base. Fournit les structures de données utilisées dans la majorité des programmes Rust réels.

Leçon 4 • Itérateurs Consommateurs et Collect

Couvre les consommateurs fold, sum, count, collect et partition. Convertit les pipelines paresseux en résultats concrets et en collections.

Leçon 1 • Passage de Messages avec les Canaux

Enseigne les canaux mpsc pour la communication inter-threads. Démontre le modèle de concurrence par passage de messages comme alternative à l'état partagé.

Leçon 2 • Principes Essentiels du Runtime Tokio

Couvre la configuration de l'exécuteur Tokio, les tâches asynchrones et les primitives d'E/S asynchrones. Permet aux étudiants de construire de vraies applications réseau avec le runtime asynchrone dominant.

Leçon 3 • Primitives de Synchronisation

Passe en revue Mutex asynchrone, RwLock, Semaphore et Notify de Tokio. Équipe les étudiants pour coordonner les tâches concurrentes sans conditions de course.

Leçon 4 • Fondamentaux d'Async/Await

Introduit le trait Future, async fn et la syntaxe .await. Fournit le modèle conceptuel pour les E/S non bloquantes dans les applications Rust.

Leçon 1 • Blocs et Fonctions Unsafe

Explique les cinq super-pouvoirs unsafe et comment les encapsuler. Les étudiants apprennent à minimiser la surface unsafe et à documenter les invariants de sécurité.

Leçon 2 • Interface de Fonctions Étrangères (FFI)

Couvre les blocs extern, l'ABI C et l'appel de bibliothèques C depuis Rust. Permet l'intégration avec des bases de code natives existantes et des bibliothèques système.

Leçon 3 • Pointeurs Bruts et Disposition Mémoire

Introduit *const T et *mut T, l'arithmétique des pointeurs et l'alignement mémoire. Fournit la base pour la FFI et la gestion manuelle de la mémoire.

Leçon 4 • Allocateurs Personnalisés et Gestion de la Mémoire

Introduit le trait GlobalAlloc, jemalloc et l'allocation par arène. Permet un contrôle mémoire fin pour les applications critiques en termes de performances.