Formation en développement Rust

Leçon 1 • Types composés et collections

Présente les tuples, tableaux, structures et énumérations en tant que conteneurs de données. Prépare les étudiants à modéliser des données réelles avant l'introduction de la propriété.

Leçon 2 • Installation et configuration de la chaîne d'outils

Configurez Rust via rustup, gérez les versions de la chaîne d'outils et paramétrez les éditeurs. Établit la base de développement nécessaire pour tout travail ultérieur.

Leçon 3 • Cargo et le système de modules

Explique les commandes Cargo, la structure de Cargo.toml et les règles de visibilité des modules. Permet de démarrer des projets structurés et multi-fichiers.

Leçon 4 • Syntaxe de base et types primitifs

Couvre les variables, la mutabilité, les types scalaires et les expressions de base. Fournit la base syntaxique sur laquelle repose chaque chapitre ultérieur.

Leçon 1 • Annotations de durée de vie

Présente la syntaxe des durées de vie, les règles d'élision et les paramètres de durée de vie dans les structures. Permet d'écrire des fonctions qui renvoient des références de manière sécurisée.

Leçon 2 • Pointeurs intelligents

Explore Box, Rc, Arc, RefCell et leurs cas d'utilisation. Étend les motifs de propriété à l'allocation sur le tas et aux scénarios de propriété partagée.

Leçon 3 • Règles de propriété et sémantique de déplacement

Définit les trois règles de propriété et explique la sémantique de déplacement vs. copie. Forme le noyau conceptuel sur lequel repose tout raisonnement du vérificateur d'emprunts.

Leçon 1 • Traits de la bibliothèque standard en profondeur

Couvre les traits Iterator, From/Into, Display et la surcharge d'opérateurs. Intègre de manière transparente les types personnalisés avec l'écosystème de la bibliothèque standard.

Leçon 2 • Fonctionnalités avancées du système de types

Présente les types associés, les génériques constants et les motifs de nouveaux types. Permet de créer des API précises et expressives qui empêchent les erreurs à la compilation.

Leçon 3 • Définition et implémentation de traits

Couvre les définitions de traits, les méthodes par défaut et l'implémentation de traits sur des types personnalisés. Permet un comportement polymorphe essentiel à la conception idiomatique en Rust.

Leçon 4 • Objets de trait et répartition dynamique

Explique dyn Trait, les règles de sécurité des objets et les compromis de surcharge de la vtable. Permet le polymorphisme à l'exécution lorsque la répartition statique est insuffisante.

Leçon 1 • Types d'erreur personnalisés

Explains implementing std::error::Error, enum-based errors, and error context. Produces descriptive, structured errors suitable for library and application code.

Leçon 2 • Paniques, déroulement et assertions

Couvre panic!, assert!, catch_unwind et les stratégies abort vs. unwind. Clarifie quand les paniques sont acceptables et comment les contenir.

Leçon 3 • Combinateurs et opérateur ?

Enseigne map, and_then, unwrap_or et l'opérateur de propagation ?. Permet des chaînes de propagation d'erreur concises et lisibles dans des fonctions réelles.

Leçon 1 • Collecte et consommation des itérateurs

Couvre collect, fold, reduce, sum et partition. Convertit des chaînes paresseuses en résultats concrets et valeurs agrégées.

Leçon 2 • Itérateurs personnalisés et motifs avancés

Implémente Iterator sur des types personnalisés et explore les motifs de style générateur. Étend la composition d'itérateurs aux structures de données spécifiques à un domaine.

Leçon 3 • Fermetures et modes de capture

Explique la syntaxe des fermetures, les traits Fn/FnMut/FnOnce et la capture par référence vs. par valeur. Permet de passer un comportement en tant que valeur dans l'ensemble du code.

Leçon 4 • Adaptateurs d'itérateur fondamentaux

Enseigne map, filter, flat_map, zip, enumerate et take. Construit le vocabulaire des adaptateurs nécessaire pour les pipelines de traitement de données réels.

Leçon 1 • Threads et état partagé

Couvre thread::spawn, join handles, Send/Sync traits, and Mutex-guarded state. Établit des motifs de multi-threading sécurisés appliqués par le compilateur.

Leçon 2 • Motifs de concurrence et pièges

Examine les interblocages, la famine, l'annulation asynchrone et la concurrence structurée. Développe le jugement pour choisir le modèle de concurrence approprié à chaque cas d'utilisation.

Leçon 3 • Passage de messages avec les canaux

Enseigne les canaux mpsc, les motifs multi-producteurs et la conception d'acteurs basée sur les canaux. Fournit une alternative à l'état partagé pour la communication inter-threads.

Leçon 4 • Utilisation pratique de l'exécuteur Tokio

Couvre la configuration de Tokio, le lancement de tâches, select! et les primitives d'E/S asynchrones. Relie la théorie asynchrone à l'exécuteur de production le plus utilisé.

Leçon 1 • Pointeurs bruts et blocs unsafe

Couvre *const T, *mut T, les règles de déréférencement et la portée des blocs unsafe. Établit le principe de surface minimale pour le code unsafe.

Leçon 2 • Disposition mémoire et allocation

Explique les attributs repr, l'alignement, le bourrage et l'API d'allocateur global. Permet un contrôle précis de la disposition des données pour la performance et la compatibilité FFI.

Leçon 3 • Assembleur en ligne et intrinsèques

Couvre la syntaxe de la macro asm!, les contraintes de registre et les intrinsèques SIMD. Permet des optimisations au niveau matériel lorsque la sortie du compilateur est insuffisante.

Leçon 4 • Abstractions sécurisées sur du code unsafe

Démontre l'encapsulation de parties internes unsafe derrière des API publiques sécurisées. Produit des composants réutilisables et audités qui préservent les garanties de sécurité de Rust en externe.

Leçon 1 • Configuration, journalisation et observabilité

Présente la gestion de configuration, la journalisation structurée avec tracing et l'émission de métriques. Fournit une visibilité à l'exécution essentielle au fonctionnement des services de production.

Leçon 2 • Profilage de performance et optimisation

Couvre les benchmarks avec criterion, les flamegraphs, le profilage d'allocations et les indications au compilateur. Identifie et élimine les goulets d'étranglement avec des techniques basées sur les données.

Leçon 3 • Empaquetage, déploiement et publication

Couvre la compilation croisée, la conteneurisation Docker, la réduction de taille des binaires et les profils de publication. Produit des artefacts déployables optimisés pour les environnements cibles.

Leçon 4 • Stratégies de test et intégration CI

Enseigne les tests unitaires, les tests d'intégration, les tests basés sur les propriétés et les pipelines CI. Assure que l'exactitude du code est vérifiée automatiquement à chaque modification.