Formation avancée en programmation Rust

Leçon 1 • Règles d'Emprunt et de Référence

Enseigne les références partagées et mutables ainsi que l'application du vérificateur d'emprunt. Développe le modèle mental nécessaire pour écrire des API concurrentes et sûres.

Leçon 2 • Syntaxe de Base et Types Primitifs

Couvre les types scalaires, les types composés, les expressions et le contrôle de flux. Fournit le vocabulaire syntaxique nécessaire avant l'introduction des concepts de possession.

Leçon 3 • Règles de Possession et Sémantique de Déplacement

Explique les règles de possession de Rust et comment les valeurs se déplacent entre les portées. Permet directement une gestion sécurisée de la mémoire sans ramasse-miettes.

Leçon 4 • Durées de Vie et Syntaxe d'Annotation

Introduit les paramètres de durée de vie et comment le compilateur les utilise pour valider les références. Prépare les étudiants pour les API génériques et les structures de données à longue durée de vie.

Leçon 1 • Traits et Polymorphisme

Définit les traits comme des contrats de comportement partagés et les implémente sur des types personnalisés. Fournit la base pour la programmation générique et la répartition dynamique.

Leçon 2 • Traits de la Bibliothèque Standard en Profondeur

Explore Display, Debug, From, Into, Iterator et les traits standard associés. Connecte les types personnalisés aux conventions idiomatiques de l'écosystème Rust.

Leçon 3 • Énumérations et Filtrage par Motif Exhaustif

Couvre les variantes d'énumération avec des données et les branches de match exhaustives. Permet la modélisation de machines d'état et de conditions d'erreur sans pointeurs nuls.

Leçon 4 • Structures et Méthodes Associées

Définit les structures avec champs nommés, les structures tuple et unit avec blocs impl. Établit le bloc de construction principal pour la modélisation de domaine en Rust.

Leçon 1 • Paniques, Déroulement et Abandon

Distingue les erreurs récupérables des paniques et explique le déroulement (unwinding) par rapport à l'abandon. Guide les étudiants pour décider quand la panique est appropriée par rapport au renvoi d'erreurs.

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

Enseigne la définition d'énumérations d'erreur spécifiques au domaine et l'implémentation du trait Error. Permet un rapport d'erreur précis et lisible par machine dans les API de bibliothèque.

Leçon 3 • Crates de Gestion d'Erreurs

Introduit thiserror pour les erreurs de bibliothèque et anyhow pour les erreurs d'application. Réduit le code passe-partout tout en maintenant des informations d'erreur structurées.

Leçon 1 • Itérateurs et Adaptateurs Personnalisés

Implémente Iterator sur des types personnalisés et construit des structures d'adaptateur réutilisables. Approfondit la compréhension de l'abstraction à coût nul et de la composition d'itérateurs.

Leçon 2 • Traitement des Chaînes de Caractères et des Octets

Couvre String, str, les tranches d'octets et l'itération consciente d'Unicode. Prépare les étudiants pour les tâches d'analyse syntaxique de texte et d'implémentation de protocole.

Leçon 3 • Aperçu des Collections Standard

Passe en revue Vec, HashMap, HashSet, BTreeMap, VecDeque et leurs compromis. Fournit le vocabulaire pour choisir la collection adaptée à chaque cas d'utilisation.

Leçon 4 • Fermetures et Fonctions d'Ordre Supérieur

Couvre les modes de capture des fermetures, les traits Fn et les modèles de fonctions d'ordre supérieur. Connecte les fermetures aux adaptateurs d'itérateur et aux API basées sur les rappels.

Leçon 1 • État Partagé avec Mutex et RwLock

Utilise Arc, Mutex et RwLock pour partager un état mutable entre les threads. Démontre les modèles d'acquisition de verrou et les stratégies d'évitement d'interblocage.

Leçon 2 • Rayon et Parallélisme de Données

Applique la crate Rayon pour paralléliser les pipelines d'itérateurs avec des modifications de code minimales. Démontre l'ordonnancement par vol de travail et les modèles de fold parallèle.

Leçon 3 • Opérations Atomiques et Modèles sans Verrou

Couvre les types atomiques, la sémantique d'ordonnancement mémoire et les opérations compare-and-swap. Permet la création de structures de données et de compteurs haute performance sans verrou.

Leçon 4 • Threads et Traits Send et Sync

Crée des threads OS et explique les traits marqueurs Send et Sync. Établit les garanties à la compilation qui empêchent les courses de données.

Leçon 1 • Annulation, Délais d'Attente et Gestion des Erreurs

Implémente l'annulation de tâches, les délais d'attente et les modèles de concurrence structurée. Garantit que les services asynchrones se dégradent gracieusement en cas de défaillance.

Leçon 2 • Exécuteur Tokio et Création de Tâches

Configure l'exécuteur Tokio et crée des tâches concurrentes. Connecte les fondamentaux asynchrones à un ordonnanceur multi-thread prêt pour la production.

Leçon 3 • E/S Asynchrones et Réseau

Utilise les API asynchrones TCP, UDP et d'E/S fichier de Tokio pour des opérations non bloquantes. Développe les compétences nécessaires à l'implémentation de services réseau.

Leçon 4 • Fondamentaux de Async et Await

Explique les futures, la syntaxe async/await et le modèle d'exécuteur. Fournit les bases conceptuelles avant d'introduire un exécuteur spécifique.

Leçon 1 • Pointeurs Bruts et Mémoire Manuelle

Couvre la création de pointeurs bruts, le déréférencement et l'allocation manuelle avec l'API d'allocateur. Prépare les étudiants pour les allocateurs personnalisés et les cibles embarquées.

Leçon 2 • Pointeurs Intelligents Personnalisés

Implémente Deref, Drop et des types de pointeurs intelligents personnalisés à partir de zéro. Approfondit la compréhension du fonctionnement interne de Box, Rc et Arc.

Leçon 3 • Environnements Embarqués et Sans-Standard (No-Std)

Configure les crates no_std, utilise core et alloc, et cible le matériel nu (bare-metal). Démontre l'applicabilité de Rust au-delà des systèmes d'exploitation hôtes.

Leçon 4 • Rust Non Sûr (Unsafe) et ses Invariants

Définit les cinq super-pouvoirs unsafe et les invariants qui doivent être respectés. Établit la discipline requise avant d'écrire un bloc unsafe.

Leçon 1 • Conteneurisation et Déploiement

Empaquète les binaires Rust dans des images conteneur minimales et configure des pipelines CI. Livre un artefact déployable à partir d'un projet Rust de production.

Leçon 2 • Stratégies de Test et Organisation des Tests

Couvre les tests unitaires, les tests d'intégration, les tests de documentation et les tests basés sur les propriétés. Garantit la correction à tous les niveaux d'une application Rust de production.

Leçon 3 • Architecture de Projet et Structure de l'Espace de Travail

Organise les espaces de travail Cargo multi-crates, les indicateurs de fonctionnalités et la gestion des dépendances. Établit une structure de projet évolutive pour le développement en équipe.

Leçon 4 • Profilage de Performance et Évaluation de Performance

Utilise Criterion pour les micro-évaluations et perf ou flamegraph pour le profilage. Identifie et élimine les goulots d'étranglement dans les chemins de code chauds.