Cours de développement Rust

Leçon 1 • Types composés et collections

Présente les tuples, les tableaux, les structures et les énumérations comme conteneurs de données. Prépare les étudiants à modéliser des données du monde réel 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 configurez les éditeurs. Établit la base de développement requise pour tout le travail subséquent.

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 d'organiser des projets multifichiers dès le départ.

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 dont dépend 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'omission et les paramètres de durée de vie dans les structures. Permet d'écrire des fonctions qui retournent 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 modèles 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 par rapport à la 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 de surcharge d'opérateurs. Intègre les types personnalisés de manière harmonieuse 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 patrons newtype. Permet de créer des API précises et expressives qui empêchent les mauvaises utilisations au moment de 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 central à la conception idiomatique de Rust.

Leçon 4 • Objets traits et dispatch dynamique

Explique la syntaxe dyn Trait, les règles de sécurité des objets et les compromis de surcoût de la table virtuelle. Permet le polymorphisme à l'exécution lorsque le dispatch statique est insuffisant.

Leçon 1 • Types d'erreurs 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'erreurs concises et lisibles dans des fonctions réelles.

Leçon 1 • Collecte et consommation d'itérateurs

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

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

Implémente Iterator sur des types personnalisés et explore les patrons de type générateur. Étend la composition d'itérateurs aux structures de données spécifiques au 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 par rapport au déplacement. Permet de passer un comportement comme valeur dans tout le code.

Leçon 4 • Adaptateurs d'itérateurs de base

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 • Fils d'exécution et état partagé

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

Leçon 2 • Patrons 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é pour chaque cas d'utilisation.

Leçon 3 • Passage de messages avec les canaux

Enseigne les canaux mpsc, les patrons multi-producteurs et la conception d'acteurs basée sur les canaux. Offre une alternative à l'état partagé pour la communication entre fils d'exécution.

Leçon 4 • Environnement d'exécution Tokio en pratique

Couvre la configuration de Tokio, le lancement de tâches, select! et les primitives d'E/S asynchrones. Relie la théorie asynchrone à l'environnement d'exécution 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 l'empreinte minimale pour le code non sécurisé.

Leçon 2 • Disposition mémoire et allocation

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

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

Couvre la syntaxe de la macro asm!, les contraintes de registres 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 non sécurisé

Démontre l'encapsulation d'éléments internes non sécurisés 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 la configuration, la journalisation structurée avec tracing et l'émission de métriques. Fournit une visibilité à l'exécution essentielle pour l'exploitation de services de production.

Leçon 2 • Profilage du rendement et optimisation

Couvre les repères criterion, les flamegraphs, le profilage d'allocation et les indicateurs du compilateur. Identifie et élimine les goulots d'étranglement avec des techniques basées sur les données.

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

Couvre la compilation croisée, la conteneurisation Docker, la réduction de la taille des binaires et les profils de version. 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 la correction du code est vérifiée automatiquement à chaque changement.