Objectifs de formation
- Maîtriser l’environnement de développement Rust et ses outils.
- Maîtriser la syntaxe fondamentale, les structures de contrôle et les bases de l’ownership.
- Approfondir l’ownership, le borrowing et les règles de gestion de la mémoire.
- Manipuler les types de données, les collections, les fonctions, les closures et les itérateurs.
- Développer des applications modulaires et gérer les erreurs.
- Utiliser les traits, les génériques, les pointeurs intelligents et les mécanismes de concurrence.
- Concevoir, tester et améliorer une application Rust complète en appliquant les bonnes pratiques de qualité.
Programme de la formation
Module 1 – Maîtriser l’environnement de développement Rust et ses outils
- Découvrir les caractéristiques de Rust, ses domaines d’application et son positionnement comme langage système.
- Installer Rust et gérer les toolchains avec Rustup.
- Créer, compiler, vérifier et exécuter un projet avec Cargo ; comprendre Cargo.toml et Cargo.lock.
- Utiliser rustfmt pour formater le code, Clippy pour détecter les problèmes courants et rust-analyzer pour l’assistance dans l’éditeur.
- Consulter la documentation officielle et interpréter les messages du compilateur.
Module 2 – Maîtriser la syntaxe fondamentale, les structures de contrôle et les bases de l’ownership
- Déclarer des variables, comprendre la mutabilité et définir des constantes.
- Utiliser les types primitifs, les expressions, les opérateurs, les conditions, les boucles et les expressions match.
- Comprendre la différence entre expressions et instructions et déclarer des fonctions avec paramètres et valeurs de retour.
- Introduire les notions de pile, de tas, de propriété (ownership), de déplacement et de copie.
- Comprendre les règles fondamentales de l’ownership et leur rôle dans la sécurité mémoire.
- Découvrir les références immuables (&T;), mutables (&mut; T) et les premières règles d’emprunt.
- Réaliser des exercices guidés pour interpréter les erreurs courantes du compilateur liées à la propriété et aux emprunts.
Module 3 – Approfondir l’ownership, le borrowing et les règles de gestion de la mémoire
- Approfondir les transferts de propriété, les mouvements et les copies.
- Maîtriser les règles d’emprunt : références immuables et mutable, portée et restrictions associées.
- Comprendre le rôle du borrow checker et corriger les erreurs liées à la propriété et aux emprunts.
- Comprendre les durées de vie des références et découvrir la syntaxe des lifetimes sans répéter les mêmes notions.
- Relier ownership, borrowing, durée de vie et prévention des accès invalides.
- Appliquer ces concepts à des exercices progressifs avant de manipuler String et les collections.
Module 4 – Manipuler les types de données, les collections, les fonctions, les closures et les itérateurs
- Manipuler String et &str; en s’appuyant sur les notions d’ownership et d’emprunt.
- Utiliser les tableaux, tuples, Vec et HashMap.
- Définir des structures avec struct, des énumérations avec enum et des types personnalisés.
- Implémenter des méthodes avec impl.
- Parcourir, transformer et filtrer des collections avec les itérateurs.
- Créer et utiliser des closures, comprendre leur capture de variables et leur rôle dans le traitement des collections.
- Choisir les structures de données et opérations adaptées au besoin.
Module 5 – Développer des applications modulaires et gérer les erreurs
- Organiser le code en modules et sous-modules et gérer la visibilité des éléments.
- Utiliser Option et Result pour représenter l’absence de valeur et les erreurs.
- Propager les erreurs avec l’opérateur? et distinguer les erreurs récupérables des erreurs non récupérables.
- Créer des erreurs métier et fournir des messages exploitables.
- Ajouter et gérer des dépendances et bibliothèques externes avec Cargo.
- Structurer une application maintenable et séparer les responsabilités.
Module 6 – Concevoir du code réutilisable avec les traits et les génériques
- Définir et implémenter des traits pour décrire des comportements partagés.
- Utiliser les bornes de traits (trait bounds) pour contraindre les types génériques.
- Écrire des fonctions, structures et méthodes génériques.
- Découvrir les traits courants de la bibliothèque standard, notamment Debug, Display, Clone et Iterator.
- Comprendre les bases des traits dynamiques et de la généricité statique.
- Concevoir du code réutilisable tout en préservant lisibilité et sécurité des types.
Module 7 – Utiliser les pointeurs intelligents et la concurrence, puis concevoir et tester une application Rust complète
- Comprendre Box pour l’allocation sur le tas et certains types récursifs.
- Découvrir Rc pour le partage de propriété et RefCell pour l’emprunt vérifié à l’exécution, ainsi que leurs limites.
- Comprendre les bases des threads et les mécanismes de communication entre threads.
- Découvrir Send et Sync et leur rôle dans la sécurité des accès concurrents.
- Définir l’architecture d’une application et intégrer les concepts étudiés.
- Écrire des tests unitaires et des tests d’intégration.
- Utiliser Cargo test, rustfmt, Clippy et rust-analyzer dans une démarche de qualité.
- Compiler en mode développement et en mode release ; examiner les pistes d’amélioration de lisibilité, robustesse et performances.
- Présenter le projet et justifier les choix techniques.
Public cible
- Développeurs souhaitant acquérir des compétences en Rust ;
- développeurs connaissant déjà un langage de programmation ;
- ingénieurs logiciels et professionnels de l’informatique souhaitant développer des applications robustes et sécurisées.
Prérequis
- Maîtriser les bases de l’utilisation d’un ordinateur et d’un système d’exploitation ;
- connaître les variables, conditions, boucles et fonctions ;
- savoir utiliser un éditeur de code ;
- disposer d’un ordinateur compatible avec Rust.
Ressources pédagogiques
- Ordinateur connecté à Internet, Rustup et toolchain Rust.
- Cargo pour la gestion des projets, la compilation, les tests et les dépendances.
- Éditeur compatible avec rust-analyzer ; rustfmt pour le formatage et Clippy pour l’analyse du code.
- Documentation officielle, supports numériques, exemples, exercices et outil de visioconférence si nécessaire.
Modalités d'évaluation
- Évaluation initiale par questionnaire de positionnement.
- Évaluation formative par exercices pratiques et vérification progressive de la compréhension.
- Évaluations intermédiaires sur la syntaxe, l’ownership, le borrowing, les collections, les erreurs, la modularité, les traits, les génériques et les notions avancées abordées.
- Évaluation finale : réalisation individuelle d’une application Rust mobilisant les principales compétences travaillées.
- Critères : conformité fonctionnelle, lisibilité et qualité du code, usage adapté des concepts Rust, gestion des erreurs, tests, robustesse et justification des choix techniques.
- Questionnaire de satisfaction à chaud en fin de formation.
- Émargement électronique ou relevés de présence ; suivi des activités à distance et traçabilité de la progression.
- Conservation des résultats d’évaluation et des travaux pratiques ; remise d’une attestation de fin de formation et d’un certificat de réalisation selon les modalités applicables.
Accessibilité
Identifier les besoins spécifiques en amont et étudier avec le référent handicap les adaptations pédagogiques et techniques possibles.
Créé le 16/10/2026 ● dernière mise à jour le 16/10/2026