Formation en programmation Rust avancée

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

Enseigne les références partagées, les références mutables et l'application des règles par le vérificateur d'emprunt. Construit le modèle mental nécessaire pour écrire des API concurrentes et sécurisées.

Leçon 2 • Syntaxe de base et types primitifs

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

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

Explique les règles de propriété 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 la manière dont le compilateur les utilise pour valider les références. Prépare les étudiants aux API génériques et aux 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 de la programmation générique et de la répartition dynamique.

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

Explore Display, Debug, From, Into, Iterator et les traits standards 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 charges utiles de données et les branches 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 à champ nommé, tuple et unité avec des 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 par rapport à l'abandon. Guide les étudiants pour décider quand une panique est appropriée par rapport au retour 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 sans coût et de la composition d'itérateurs.

Leçon 2 • Traitement des chaînes et des octets

Couvre String, str, les slices d'octets et l'itération consciente d'Unicode. Prépare les étudiants aux tâches d'analyse de texte et d'implémentation de protocoles.

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 motifs de fonctions d'ordre supérieur. Connecte les fermetures aux adaptateurs d'itérateurs 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 threads. Présente les motifs d'acquisition de verrou et les stratégies pour éviter les interblocages.

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 minimales du code. Démontre l'ordonnancement par vol de travail et les motifs de pliage parallèle.

Leçon 3 • Opérations atomiques et motifs sans verrou

Couvre les types atomiques, la sémantique d'ordre mémoire et les opérations de comparaison et d'échange. Permet des structures de données et des compteurs haute performance sans verrouillage.

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 aux 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 motifs 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 et réseau asynchrones

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

Leçon 4 • Principes fondamentaux d'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 aux allocateurs personnalisés et aux 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 no_std

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

Leçon 4 • Rust unsafe et ses invariants

Définit les cinq superpouvoirs du code unsafe et les invariants qui doivent être respectés. Établit la discipline requise avant d'écrire tout bloc unsafe.

Leçon 1 • Conteneurisation et déploiement

Empaquète les binaires Rust dans des images de 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 l'exactitude à tous les niveaux d'une application Rust de production.

Leçon 3 • Architecture de projet et disposition de l'espace de travail

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

Leçon 4 • Profilage des performances et évaluation comparative

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