Cette formation Rust vous permettra de découvrir et maîtriser les fondamentaux du langage Rust.

En trois jours, vous apprendrez à écrire, débugger, tester et maintenir vos programmes tout en explorant les outils incontournables de l’écosystème Rust.

Cette formation Rust se concentre sur la pratique avec des ateliers concrets qui incluent la gestion de la mémoire, la concurrence, et les collections.
​
Elle s'adresse aux développeur·euse·s expérimenté·e·s et souhaitant apprendre un langage de programmation moderne.

Vous souhaitez renforcer vos compétences en programmation système ?

La formation C avancé vous permettra de maîtriser les bonnes pratiques du langage C !

Les objectifs

• Comprendre et écrire du code Rust
• Se repérer dans l'écosystème Rust et découvrir quelques bibliothèques populaires

Pré-requis

• Expérience solide dans au moins un langage de programmation
• Familiarité avec l’utilisation du terminal
• Ordinateur portable à apporter

Le programme de la formation Rust

Jour 1 : Comprendre et utiliser Rust

• Historique et positionnement de Rust ​
• Les Bases du langage​
  • Commentaires
  • Types primitifs (simples et composés)
  • Fonctions
  • Variables (typage, muabilité, constantes)
  • Blocs et shadowing
  • Structures de contrôle
  • Les types structurés (exemple : Duration)
  • Les types énumérés (exemple : Option)
  • Filtrage par motif (pattern matching)
  • Écrire dans la console
• Possession (ownership) et emprunt (borrowing)​
  • Enjeux, contraintes et avantages de la possession (ownership)
  • Fonctionnement de la possession
  • Emprunt (borrowing) grâce aux références
  • Les slices de chaînes de caractères
• Créer des types​
  • Créer des alias de type
  • Créer des types structurés
    • structs
    • tuple structs
    • unit structs
  • Créer des types énumérés (enum)
  • Fonction et méthodes associées
• Généricité et durée de vie (lifetime)​
  • Types de données génériques
  • Créer et implémenter des traits
  • Traits courants de la bibliothèque standard
    • Display, Clone, Add
  • Traits vs. énumération
  • Principe de la durée de vie (lifetime)
  • Manipuler les durées de vie
• Les Collections​
  • Fonctions anonymes (closures)
  • Vec
  • Slices
  • HashSet
  • HashMap
  • Itérateurs

Jour 2 : Écosystème et outillage

• Modules et crates​
  • Paquets et crates
  • Modules (déclaration, import, …)
  • Visibilité des entités
  • Arborescence des modules et des fichiers de code
• Outillage
  • rustup (toolchain, cibles, …)
  • Cargo
    • gestion des dépendances
    • déclarer et utiliser des features
  • rustfmt
  • Clippy
• Tests et documentation​
  • Qualité et tests
  • Écrire et lancer des tests (unitaires et d'intégration) avec Cargo
  • Écrire et générer de la documentation avec Cargo
  • Autres facilités de Cargo : les exemples et les benchmarks
• Gestion des erreurs​
  • Recoverable vs. unrecoverable
  • Faire planter le programme
  • Option
  • Result
  • Gérer les erreurs dans une application
    • unwrap(), expect(), pattern matching, anyhow
  • Créer un type d'erreur structuré dans une bibliothèque
    • String
    • std::error::Error
    • thiserror ​
• Concurrence et asynchronisme
  • Créer des threads
  • Partager des données entre threads (Arc, Mutex, MPSC)
  • Les traits Sync et Send
  • Futures et async/await (et Tokio) ​

Jour 3 : Pratique dirigée

• Sérialisation et désérialisation​
  • Fonctionnement et écosystème de Serde
  • Utiliser serde_json en pratique
  • Écrire un parser avec nom

Exploration et pratique à la carte

​
Suivant le temps restant et les envies des stagiaires, nous explorons des thèmes liés à Rust.
​
Cette exploration peut prendre la forme de discussions, de démonstrations ou de travaux pratiques en semi-autonomie, seul ou en binôme.
​
Exemples de mises en pratique :
​
- Gérer les traces d'exécution avec log et env_logger
- Écrire un programme CLI grâce à clap
- Gérer les dates et le temps avec Chrono
- Écrire une API HTTP avec actix-web
- Faire des requêtes HTTP avec reqwest
- Dialoguer avec une base de données grâce à SQLx
- Passer en mode manuel avec unsafe
- Interfaçage avec C/C++ (FFI)
- Écrire des macros simples
- Continuer à apprendre : quelques sources de veille
- Astuces diverses :
- Choisir un meilleur linker
- Compiler pour un type de CPU précis
- Garder ses dépendances à jour

Le(s) formateur(s)

David SFERRUZZA

Passionné depuis toujours par l'informatique au sens large, David Sferruzza est propulsé par sa curiosité. Celle-ci l'a poussé à faire des études d'ingénieur généraliste pour ensuite se recentrer sur le développement logiciel et ses nombreux domaines connexes.
Notamment adepte de programmation fonctionnelle (Rust, Haskell, Scala, Nix, ...), d'administration système, de pédagogie et de différents mélanges de ces trois ingrédients, il s'est régulièrement lancé des challenges pour continuer à apprendre : homme à tout faire d'une équipe de développeurs (PHP/Laravel, JavaScript), orateur dans des conférences internationales, docteur en génie logiciel, et parfois même rédacteur de contenus absurdes !

Jamais très éloigné de son éditeur de code, il accompagne des startups sur les aspects techniques depuis plusieurs années chez Startup Palace et écrit des logiciels (web, réseau, embarqué, …) pour Le Palace.

Voir son profil détaillé

A propos de Human Coders

Human Coders c'est un centre de formation pour développeurs avec :

• une certification Qualiopi, indispensable pour que vous puissiez obtenir des aides au financement via votre OPCO
• de nombreux clients qui nous font confiance depuis des années
• un manifeste pour garantir des formations à taille humaine, des formateurs passionnés, de véritables workshops...
• 129 formations au catalogue, 1616 sessions depuis nos débuts en 2012 avec une moyenne de satisfaction de 4,6/5
• la possibilité de vous proposer un accompagnement personnalisé ou du conseil après la formation