Formation Maîtriser la programmation Rust : Développement sûr et performant

Programme de la formation
Maîtriser la programmation Rust : Développement sûr et performant

• Introduction à Rust et Bases Essentielles

  - Présentation de Rust : philosophie, avantages, cas d'usage.
  - Installation de Rust et son écosystème (Cargo, rustup).
  - Syntaxe de base : variables, types primitifs, fonctions.

• Contrôle de Flux et Gestions des Données

  - Opérateurs et expressions.
  - Structures de contrôle : `if/else`, `loop`, `while`, `for`.
  - Enums et structures (struct) : concepts et implémentation.

• Ownership et Emprunt (Borrowing)

  - Comprendre le concept d'Ownership en Rust.
  - Règles du Borrowing : références immuables et mutables.
  - Durée de vie (lifetimes) : évitons les erreurs de danying pointers.

• Slices et Chaînes de Caractères

  - Introduction aux slices et leur utilité.
  - Gestion des chaînes de caractères : `String` et `&str`.
  - Manipulations courantes : concaténation, sous-chaînes.

• Erreurs : Panic et Result

  - Gestion des erreurs : `panic!` contre `Result<T, E>`.
  - Propagation des erreurs avec `?`.
  - Bonnes pratiques de gestion d'erreurs en Rust.

• Collections Standards

  - `Vec<T>` : tableaux dynamiques.
  - `HashMap<K, V>` : tables de hachage.
  - `String` vs `str` plus en détail.

• Méthodes, Traits et Implémentations
• Génériques et Durées de Vie Avancées

  - Programmation générique en Rust pour des fonctions et structs réutilisables.
  - Contraintes de traits sur les génériques.
  - Cas d'usage avancés des lifetimes.

• Tests en Rust

  - Écriture de tests unitaires avec `#[test_unit]`.
  - Tests d'intégration et tests de documentation.
  - Utilisation de Cargo pour l'exécution des tests.

• Modules, Crates et Ecosystème Cargo

  - Organisation du code avec les modules et le chemin des items.
  - Publication et utilisation de Crates.io.
  - Compréhension avancée de Cargo : workspace, fonctionnalités.

• Concurrence et Sécurité : Threads et Mutex

  - Introduction à la concurrence en Rust.
  - Utilisation des threads pour paralléliser des tâches.
  - Synchronisation avec `Mutex` et `Arc`.

• Programmation Asynchrone et Futures

  - Concepts de la programmation asynchrone (`async/await`).
  - Introduction aux Futures et Executors.
  - Mise en pratique d'un exemple asynchrone simple.