Contactez-nous

Rust : de zéro à opérationnel

Apprenez Rust, le langage de programmation moderne axé sur la sécurité et la performance. Idéal pour débutants, cette formation vous rendra rapidement opérationnel avec les compétences essentielles pour développer des applications robustes et efficaces.

Table des matières

  1. Introduction et mise en place accélérée
    1. Pourquoi Rust ? Philosophie et atouts clés
      1. Sécurité mémoire sans garbage collector : la promesse de Rust
      2. Performance, contrôle et concurrence : les piliers
      3. L'importance croissante de Rust dans l'industrie (systèmes, web, embarqué)
    2. Vocabulaire essentiel du débutant en Rust
      1. Cargo, crate, module : organiser son code
      2. Le compilateur (rustc) : votre premier allié
      3. Ownership, borrowing, lifetimes : les concepts uniques (aperçu)
    3. Installation et configuration de l'environnement de développement
      1. Installer Rust avec `rustup` (Windows, macOS, Linux)
      2. Configuration de l'éditeur de code (VS Code avec `rust-analyzer` recommandé)
      3. Votre premier "Hello, world!" avec `cargo new`
  2. Les fondations indispensables de Rust
    1. Variables, mutabilité et types de données scalaires
      1. Déclarer des variables avec `let` et `mut`
      2. Types entiers, flottants, booléens et caractères
      3. Opérations de base et inférence de type
    2. Types de données composés essentiels
      1. Les chaînes de caractères : `String` et `&str` (introduction)
      2. Les tuples : regrouper des valeurs de types différents
      3. Les tableaux (arrays) : collections de taille fixe
    3. Fonctions et structures de contrôle
      1. Définir et appeler des fonctions (paramètres et valeurs de retour)
      2. Conditions `if/else` et expressions
      3. Boucles : `loop`, `while`, et `for` pour l'itération
    4. Introduction pratique à l'ownership
      1. Les trois règles de l'ownership (possession)
      2. Déplacement (move) vs. copie (copy) des données
      3. Emprunts (borrowing) : références immuables (`&T`) et mutables (`&mut T`)
  3. Processus de développement Rust : le minimum viable
    1. Créer et gérer un projet avec Cargo
      1. Initialiser un nouveau projet : `cargo new` vs `cargo init`
      2. Le fichier `Cargo.toml` : manifeste du projet et dépendances
      3. Structure typique d'un projet : `src/main.rs` et `src/lib.rs`
    2. Compiler, exécuter et vérifier son code
      1. Compiler avec `cargo build` (mode debug et release)
      2. Exécuter avec `cargo run`
      3. Vérifier rapidement avec `cargo check`
  4. Outils essentiels pour être productif immédiatement
    1. Cargo : votre couteau Suisse
      1. Ajouter des dépendances externes (crates) depuis crates.io
      2. Commandes utiles : `test`, `fmt`, `clippy` (introduction)
    2. `rust-analyzer` : l'assistant indispensable dans votre IDE
      1. Autocomplétion et suggestions de code
      2. Navigation dans le code et diagnostics en temps réel
  5. Anticiper et gérer les défis et erreurs courantes
    1. Comprendre les messages du compilateur Rust
      1. Anatomie d'un message d'erreur typique
      2. Identifier les erreurs de type et de syntaxe
    2. Les pièges classiques de l'ownership et du borrowing
      1. Erreur : "cannot borrow `x` as mutable more than once at a time"
      2. Erreur : "use of moved value"
      3. Introduction aux durées de vie (lifetimes) : pourquoi elles existent (sans syntaxe complexe)
    3. Introduction à la gestion des erreurs avec `Option` et `Result`
      1. Le type `Option<T>` pour les valeurs optionnelles (`Some`, `None`)
      2. Le type `Result<T, E>` pour les opérations pouvant échouer (`Ok`, `Err`)
      3. Utilisation basique de `unwrap()` et `expect()` (et leurs dangers)
  6. Bonnes pratiques fondamentales pour un code de qualité
    1. Formater et analyser son code automatiquement
      1. Utiliser `cargo fmt` pour un style de code cohérent
      2. Utiliser `cargo clippy` pour des suggestions d'amélioration et détecter les anti-patterns
    2. Ecrire des tests unitaires simples
      1. L'annotation `#[test]` et l'organisation des tests
      2. Les macros d'assertion : `assert!`, `assert_eq!`, `assert_ne!`
      3. Lancer les tests avec `cargo test`
    3. Documenter son code efficacement (bases)
      1. Commentaires de documentation : `///` pour les items, `//!` pour les modules
      2. Générer et consulter la documentation avec `cargo doc --open`
  7. Mise en pratique guidée : vos premiers projets Rust
    1. Projet 1 - Jeu de devinette en ligne de commande
      1. Objectif : créer un jeu où l'utilisateur devine un nombre secret
      2. Compétences mises en oeuvre : lecture d'entrée utilisateur, génération de nombres aléatoires (crate `rand`), boucles, conditions, gestion simple d'erreurs
      3. Etapes guidées de développement
    2. Projet 2 - Mini outil CLI de gestion de tâches (en mémoire)
      1. Objectif : créer un programme pour ajouter et lister des tâches simples
      2. Compétences mises en oeuvre : utilisation de `struct` pour modéliser une tâche, `Vec<T>` pour stocker les tâches, manipulation de chaînes, fonctions, interaction basique avec l'utilisateur
      3. Etapes guidées et pistes d'amélioration simple