Apprendre Rust de zéro jusqu'à un vrai outil en ligne de commande : ownership, emprunts, enums, gestion d'erreurs, traits, génériques, durées de vie, itérateurs, tests, threads et async avec Tokio.
Rust est un langage compilé, typé statiquement, sans ramasse-miettes. Compilé veut dire que le code devient un exécutable natif avant de tourner. Sans ramasse-miettes veut dire qu'aucun processus ne passe en arrière-plan libérer la mémoire : c'est le compilateur qui décide, dès la compilation, à quel moment chaque valeur est libérée. Ce mécanisme s'appelle l'ownership, et il occupe tout le chapitre 3.
Le résultat : des programmes aussi rapides qu'en C ou C++, sans les erreurs qui font planter ces langages (pointeur invalide, double libération, accès concurrent à une donnée). Si votre code compile, ces familles de bugs sont exclues.
| Domaine | Exemples réels |
|---|---|
| Outils en ligne de commande | ripgrep, fd, bat, uv, Ruff |
| Infrastructure et réseau | Le proxy Pingora de Cloudflare, Firecracker d'AWS |
| Systèmes | Pilotes du noyau Linux, composants de Windows et d'Android |
| WebAssembly | Code qui tourne dans le navigateur à vitesse quasi native |
| Outillage JavaScript | Turbopack, Rolldown, SWC, Biome |
Le point commun : des programmes où la performance et la fiabilité comptent toutes les deux. Pour un script jetable ou une API CRUD classique, Rust est souvent trop lourd. Go est plus simple pour écrire une API, et Python reste imbattable pour un script de dix lignes.
Mon avis : Rust vaut l'effort dès qu'un programme doit tourner longtemps sans surveillance, ou qu'il doit être rapide. Le compilateur strict devient alors un collègue qui relit chaque ligne.
L'installation officielle passe par rustup, qui gère les versions du compilateur et des outils.
# macOS, Linux, WSL
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | shSur Windows, téléchargez rustup-init.exe depuis rustup.rs. L'installateur propose d'installer les outils de compilation C++ de Visual Studio : acceptez, Rust en a besoin pour l'édition de liens.
Vérification :
rustc --version
cargo --versionRust sort une nouvelle version toutes les six semaines. Mettre à jour se fait en une commande :
rustup updateOn n'appelle presque jamais rustc directement. cargo crée les projets, compile, lance les tests, télécharge les dépendances.
cargo new bonjour
cd bonjourbonjour/
├── Cargo.toml
├── .gitignore
└── src/
└── main.rsCargo.toml décrit le projet :
[package]
name = "bonjour"
version = "0.1.0"
edition = "2024"
[dependencies]L'edition fixe les règles du langage utilisées pour ce projet. Rust ne casse jamais le code existant : une nouvelle édition, tous les trois ans, ne s'applique qu'aux projets qui la demandent. L'édition 2024 est la plus récente, c'est celle du cours.
Et src/main.rs :
fn main() {
println!("Bonjour, monde !");
}fn main est le point d'entrée. println! se termine par un point d'exclamation parce que c'est une macro, pas une fonction : elle est développée en code au moment de la compilation, ce qui lui permet de vérifier le format de la chaîne.
| Commande | Effet |
|---|---|
cargo run | Compile et lance le programme |
cargo check | Vérifie que le code compile, sans produire d'exécutable. Beaucoup plus rapide |
cargo build --release | Compile avec les optimisations, dans target/release/ |
cargo test | Lance les tests |
cargo fmt | Formate le code selon le style officiel |
cargo clippy | Linter : signale le code correct mais maladroit |
cargo add serde | Ajoute une dépendance dans Cargo.toml |
cargo doc --open | Génère et ouvre la documentation du projet et de ses dépendances |
cargo run Compiling bonjour v0.1.0 (/home/william/bonjour)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.42s
Running `target/debug/bonjour`
Bonjour, monde !Une habitude à prendre tout de suite : cargo check en boucle pendant que vous écrivez, cargo run quand ça compile. Et cargo clippy avant chaque commit. Clippy enseigne le Rust idiomatique mieux que n'importe quel livre.
Une différence de taille avec Python ou JavaScript : un binaire compilé en mode dev est lent. Pour mesurer une performance, utilisez toujours --release. L'écart peut dépasser un facteur 10.
Installez rust-analyzer, le serveur de langage officiel. Il existe en extension pour VS Code, et il est intégré à RustRover, Zed, Helix et Neovim. Il affiche les types déduits en ligne, les erreurs au fil de la frappe et propose les imports. Sans lui, Rust est pénible. Avec, le compilateur devient une conversation.
Le compilateur Rust est célèbre pour ses messages d'erreur. Écrivons un bug exprès :
fn main() {
let x = 5;
x = 6;
println!("{x}");
}error[E0384]: cannot assign twice to immutable variable `x`
--> src/main.rs:3:5
|
2 | let x = 5;
| - first assignment to `x`
3 | x = 6;
| ^^^^^ cannot assign twice to immutable variable
|
help: consider making this binding mutable
|
2 | let mut x = 5;
| +++Le message localise l'erreur, explique la cause et propose la correction. rustc --explain E0384 donne une explication longue avec exemples. Prenez le temps de lire chaque erreur en entier : c'est le meilleur professeur de Rust.
Créez un projet salut, et faites-lui afficher votre prénom et le résultat de 6 * 7. Lancez ensuite cargo build --release et retrouvez l'exécutable dans target/release/. Lancez-le directement, sans Cargo.
fn main() {
let prenom = "Ada";
println!("Salut {prenom}, 6 x 7 = {}", 6 * 7);
}{prenom} insère la variable du même nom, {} insère l'argument suivant.
Rust s'installe en une commande et Cargo fait le reste. La vraie courbe d'apprentissage commence au chapitre 3 avec l'ownership. Avant, le chapitre suivant pose les bases : variables, types, fonctions et boucles.