Formation Rust avancé

L'apprentissage s'effectue, pour chaque module, à 60% par des exercices pratiques et à 40% par des présentations. A la fin de la formation, les stagiaires sont autonomes dans leurs développement en Rust et seront capables de :

• Appliquer les concepts de base du langage dans le contexte d’un projet concret.
• Utiliser les concepts de la programmation avancée : constantes calculées, réflexivité, mémoire non-move.
• Appliquer les mécanismes de l’asynchronisme sur un exemple concret d’application.
• Mettre en place des structures adaptées à la programmation pour l’embarqué.
• Implémenter une application backend Rust pour le web.
• Utiliser WebAssembly comme cible côté backend ou frontend.

001 - Introduction

Ce module inaugural assure une mise à niveau homogène du groupe en révisant les connaissances fondamentales de Rust : système d'ownership et de borrowing, traits et généricité, gestion d'erreurs avec Result, collections standards, et bases du multi-threading. Cette révision rapide mais ciblée permet de s'assurer que tous les participants maîtrisent les prérequis nécessaires avant d'aborder les concepts avancés de la formation. Des exercices pratiques permettront d'identifier et de combler rapidement les éventuelles lacunes.

• Révision des connaissances Rust de base

002 - Programmation avancée I

Ce module explore les fonctionnalités de Rust qui sortent du cadre "safe" habituel et permettent l'intégration avec l'existant. Vous découvrirez le système de macros pour la métaprogrammation et la génération de code à la compilation, indispensable pour réduire le boilerplate. L'interopérabilité C/C++/Rust sera couverte en profondeur : Foreign Function Interface (FFI) pour appeler des bibliothèques C/C++ depuis Rust, et inversement exposer des API Rust consommables depuis C/C++, avec gestion des conventions d'appel, des layouts mémoire, et des différences de modèles d'erreurs. Enfin, nous aborderons "Unsafe Rust", le sous-ensemble permettant de contourner certaines vérifications du compilateur (déréférencement de pointeurs bruts, appels de fonctions unsafe, implémentation de traits unsafe), essentiel pour la programmation système et l'interfaçage matériel, tout en comprenant comment minimiser et encapsuler correctement le code unsafe.

• Macros
• Utiliser C/C++ depuis Rust
• Utiliser Rust depuis C/C++
• Unsafe Rust

003 - Programmation avancée II

Ce module approfondit des concepts avancés du système de types de Rust, nécessaires pour la conception de bibliothèques sophistiquées et le développement système. Vous maîtriserez le typage de self (self, &self, &mut self, Box, Rc) pour contrôler finement la sémantique d'ownership des méthodes. Les fonctions const permettent d'effectuer des calculs à la compilation, ouvrant la voie à de l'optimisation et de la vérification au compile-time. La réflexivité avec les types Any et TypeId permet l'introspection de types à l'exécution. Enfin, nous explorerons Pin et Unpin, concepts subtils mais cruciaux qui garantissent qu'une valeur ne sera jamais déplacée en mémoire, fondamental pour la programmation asynchrone et les structures auto-référentielles.

• Typage de self
• Constantes calculées (fonctions const)
• Réflexivité (Any et TypeId)
• Mémoire non-move (pin et unpin)

004 - Programmation asynchrone

L'asynchronisme en Rust adopte un modèle unique : des abstractions de haut niveau (async/await) compilées vers un code zero-cost sans runtime imposé. Ce module explore le modèle de concurrence asynchrone de Rust et son fonctionnement interne. Vous apprendrez à écrire des fonctions async qui retournent des Future, à composer ces futures, et à gérer la communication entre tâches asynchrones (channels async, shared state). Les Stream, équivalent asynchrone des itérateurs, seront également couverts. Nous comparerons les principaux runtimes asynchrones (Tokio, async-std, smol) et leurs compromis, et vous saurez choisir et configurer le runtime approprié à votre cas d'usage, qu'il s'agisse de serveurs réseau haute performance ou d'applications embarquées contraintes.

• Modèle de concurrence
• Fonctions async et futures
• Communicaton entre futures
• Stream
• Runtimes async

005 - Préparation à l'embarqué

Programmer pour des systèmes embarqués impose des contraintes drastiques : absence de système d'exploitation, mémoire limitée (parfois quelques KB), pas de bibliothèque standard. Ce module vous prépare à ces défis en explorant la programmation no_std, qui n'utilise que le noyau minimal du langage (core). Vous apprendrez à évaluer et adapter des bibliothèques pour la compatibilité no_std, à programmer sans allocateur dynamique (pas de Vec, String, Box), et quand nécessaire, à implémenter votre propre allocateur et panic handler personnalisés. La cross-compilation vers des architectures embarquées (ARM Cortex-M, RISC-V) sera pratiquée, ainsi que le débogage sur cible réelle. Enfin, nous verrons comment la programmation asynchrone s'adapte à l'embarqué avec des executors légers sans allocation (Embassy, RTIC).

• Programmation no-std
• Compatibilité no-std des librairies
• Programmation sans allocateur/allocation
• Écriture du panic handler
• Écriture d'un allocateur
• Cross-compilation et cible embarquée
• Asynchrone embarqué

006 - Rust et WebAssembly

Rust et WebAssembly forment un duo puissant, permettant d'écrire des applications web performantes et du code partagé frontend/backend. Ce module couvre d'abord Rust côté backend : création de serveurs HTTP avec les frameworks majeurs (Actix-web, Axum, Rocket), gestion des routes, middleware, et accès aux bases de données (diesel, sqlx). Nous explorerons ensuite WebAssembly (Wasm) pour le backend comme alternative aux conteneurs. La seconde partie se concentre sur Rust dans le navigateur : compilation vers Wasm, interfaçage avec JavaScript via wasm-bindgen, manipulation du DOM, et communication bidirectionnelle JS/Rust. L'asynchronisme dans le contexte Wasm sera abordé, ainsi que l'accès à WebGL pour les graphismes haute performance, ouvrant la voie aux jeux, visualisations 3D et applications scientifiques dans le navigateur.

• Rust côté backend
  • serveur et framework HTTP
  • accès base de données
  • wasm pour le backend
• Rust dans le browser avec WebAssembly
  • communication js/rust
  • asynchrone
  • webgl