Formation Rust Intermédiaire et Avancée

Leçon 1 • Ownership Rules et Move Semantics

Couvre l'invariant de possesseur unique, les types par déplacement vs. par copie, et l'ordre de libération. Établit la base de sécurité mémoire dont dépend tout le cours.

Leçon 2 • Interior Mutability Patterns

Explique Cell, RefCell et leur vérification de prêt à l'exécution pour les cas où les règles de compilation sont trop restrictives. Fait le pont entre les fondamentaux de la possession et les schémas avancés d'état partagé.

Leçon 3 • Slices, References et String Types

Distingue les types str, String et slice ainsi que leur sémantique de référence. Renforce les concepts de prêt à travers la manipulation pratique de chaînes et de tableaux.

Leçon 4 • Borrowing et Reference Rules

Enseigne les références partagées et exclusives, les règles d'alias et les retours du vérificateur de prêt. Prépare directement les étudiants aux annotations de durée de vie dans les sections suivantes.

Leçon 1 • Types Associés et Familles de Types

Distingue les types associés des paramètres génériques et montre quand chacun est approprié. Prépare les étudiants à lire et écrire correctement les traits d'itérateur et d'opérateur.

Leçon 2 • Generic Types et Monomorphization

Couvre les structures, énumérations et fonctions génériques ainsi que les compromis de coût de la monomorphisation. Fournit le vocabulaire nécessaire pour comprendre les limites de traits et la spécialisation.

Leçon 3 • Trait Objects et Dynamic Dispatch

Explique dyn Trait, les vtables, les règles de sécurité des objets et les implications de performance. Équipe les étudiants pour choisir délibérément entre la répartition statique et dynamique.

Leçon 4 • Trait Bounds et Where Clauses

Enseigne les limites en ligne, les clauses where et les limites de traits de rang supérieur pour des API flexibles. Permet directement les schémas de traits avancés couverts dans les sections suivantes.

Leçon 1 • Panic, Unwinding et Recovery

Distingue les erreurs récupérables des paniques, explique le déroulement vs. l'arrêt et couvre catch_unwind. Complète le tableau de la gestion des erreurs avec des stratégies de sécurité pour les cas limites.

Leçon 2 • Error Libraries et Ergonomics

Examine thiserror pour dériver des types d'erreur et anyhow pour les erreurs au niveau application. Enseigne quand utiliser chaque approche selon le contexte bibliothèque vs. application.

Leçon 3 • L'Opérateur Point d'Interrogation

Explique comment ? se désucre, les conversions From et la sémantique de retour anticipé en détail. Permet aux étudiants d'écrire du code de propagation concis à travers plusieurs types d'erreur.

Leçon 4 • Result et Option Combinators

Couvre map, and_then, unwrap_or et les combinateurs associés pour une gestion ergonomique des erreurs. Établit des schémas idiomatiques avant d'introduire l'opérateur point d'interrogation.

Leçon 1 • Iterator Trait et Lazy Evaluation

Implémente le trait Iterator depuis zéro et explique le chaînage d'adaptateurs paresseux. Montre comment les abstractions à coût zéro éliminent les allocations intermédiaires.

Leçon 2 • Closure Capture et Fn Traits

Explique Fn, FnMut, FnOnce, la capture par référence vs. par déplacement et la taille des fermetures. Fournit la connaissance des traits nécessaire pour passer des fermetures à travers les frontières des API.

Leçon 3 • Custom Iterators et Adapters

Construit des itérateurs personnalisés avec état et des structures d'adaptateur qui enveloppent des itérateurs existants. Renforce les compétences de possession et de durée de vie tout en étendant l'écosystème des itérateurs.

Leçon 4 • Adaptateurs d'Itérateur Courants

Couvre map, filter, flat_map, zip, enumerate et take en profondeur avec des exemples réels. Développe l'aisance avec le vocabulaire des adaptateurs utilisé dans tout le code Rust idiomatique.

Leçon 1 • Combinaison de Pointeurs Intelligents

Montre Rc<RefCell<T>> et Arc<Mutex<T>> pour l'état mutable partagé. Connecte la mutabilité intérieure du Chapitre 1 aux scénarios multi-possesseurs.

Leçon 2 • Mise en œuvre de pointeurs intelligents personnalisés

Construit un pointeur intelligent personnalisé en implémentant Deref, DerefMut et Drop. Approfondit la compréhension du fonctionnement interne des pointeurs de la bibliothèque standard.

Leçon 3 • Memory Layouts et Allocators

Examine le layout des structures, le remplissage, l'alignement et l'interface de l'allocateur global. Équipe les étudiants pour optimiser l'utilisation de la mémoire et intégrer des allocateurs personnalisés.

Leçon 4 • Reference Counting avec Rc et Arc

Compare Rc pour la possession partagée mono-thread et Arc pour la possession partagée multi-thread. Prépare les étudiants à la programmation concurrente en introduisant les contraintes de sécurité des threads.

Leçon 1 • Atomic Operations et Lock-Free Patterns

Explique les types atomiques, l'ordonnancement mémoire et le compare-and-swap pour les algorithmes sans verrou. Prépare les étudiants à raisonner sur les modèles de mémoire matérielle dans le code critique en performance.

Leçon 2 • Parallel Iterators et Data Parallelism

Introduit le parallélisme de données via les schémas d'itérateurs parallèles et les ordonnanceurs à vol de travail. Connecte les compétences d'itérateur du Chapitre 4 à l'optimisation de performance multi-cœur.

Leçon 3 • Message Passing avec Channels

Implémente des schémas producteur-consommateur en utilisant les canaux mpsc et explique la contre-pression. Fournit une alternative sûre à l'état partagé pour la communication inter-threads.

Leçon 4 • Primitives de synchronisation d'état partagé

Couvre Mutex, RwLock, Condvar et Barrier pour coordonner l'accès des threads aux données partagées. S'appuie sur Arc du Chapitre 5 pour implémenter des structures de données concurrentes sûres.

Leçon 1 • Async et Await Syntax

Couvre async fn, les blocs async, .await et comment ils se composent en pipelines plus grands. Développe l'aisance pratique avant d'introduire les détails de l'exécuteur et du runtime.

Leçon 2 • E/S asynchrone et Réseautage

Implémente des clients et serveurs TCP asynchrones utilisant des E/S non bloquantes et des flux asynchrones. Applique la connaissance de l'exécuteur à des scénarios réels de programmation réseau.

Leçon 3 • Async Patterns et Pitfalls

Aborde les erreurs courantes en asynchrone : appels bloquants dans un contexte asynchrone, sécurité d'annulation et limites Send. Équipe les étudiants pour déboguer et optimiser le code asynchrone en production.

Leçon 4 • Futures et the Future Trait

Explique le trait Future, Poll, Waker et la transformation en machine d'état des fonctions asynchrones. Fournit la base conceptuelle pour tous les schémas asynchrones qui suivent.

Leçon 1 • The Unsafe Keyword et Superpowers

Définit les cinq opérations unsafe, le contrat unsafe et le principe de surface unsafe minimale. Établit le modèle mental pour tous les sujets unsafe qui suivent.

Leçon 2 • Mettre en œuvre les abstractions non sécurisées

Construit des abstractions sûres sur du code unsafe, y compris un tampon minimal de type Vec. Montre comment encapsuler les invariants pour que les appelants n'aient jamais besoin d'unsafe.

Leçon 3 • Exposer Rust vers C et auditer le code unsafe

Exporte des fonctions Rust pour la consommation en C et introduit des outils pour auditer le code unsafe. Complète le tableau FFI et inculque une discipline de révision de sécurité.

Leçon 4 • Raw Pointers et Pointer Arithmetic

Couvre la création de *const T et *mut T, le déréférencement et les règles d'arithmétique de pointeurs. Prépare les étudiants à la gestion manuelle de la mémoire et à la manipulation de pointeurs FFI.