Saga écrite par Benoît Prieur

Série estivale en six épisodes, à raison d’une publication par semaine. Sans prérequis particulier : de quoi comprendre les principes de la programmation moderne à travers l’exemple de Rust, un langage en pleine progression.

S’il ne fallait retenir qu’une notion de Rust, ce serait la possession. C’est elle qui explique en grande partie sa réputation. Reprenons le problème. Pendant son exécution, un programme réserve en permanence des espaces dans la mémoire de l’ordinateur pour y ranger ses données : une image, un texte, une liste de clients. Lorsqu’une donnée ne sert plus, il faut libérer sa place, faute de quoi la mémoire se sature. La difficulté est de savoir quand un espace peut-il être rendu en toute sécurité pour le programme, et qui en décide.

Deux approches ont longtemps coexisté, avec chacune ses limites.

La première confie toute la gestion au programmeur. C’est la voie du C. Elle est efficace, mais exigeante : oublier de libérer un espace fait gonfler le programme jusqu’à la panne ; le libérer trop tôt, alors qu’une autre partie du code s’en sert encore, provoque des plantages et des failles de sécurité. Ces erreurs comptent parmi les plus fréquentes de l’histoire du logiciel.

La seconde approche délègue le travail à un dispositif automatique, le ramasse-miettes (garbage collector). Il parcourt régulièrement la mémoire pour repérer ce qui ne sert plus et le récupérer. C’est le choix de Java ou de Python. Le confort est réel, mais ce nettoyage interrompt brièvement le programme de temps à autre, ce qui peut gêner les applications où chaque milliseconde compte.

Rust propose une troisième voie : ni gestion manuelle, ni dispositif automatique, mais un ensemble de règles vérifiées par le compilateur avant l’exécution.

La première règle : chaque donnée appartient à une seule variable, son propriétaire. Quand le propriétaire disparaît, parce que le programme quitte la portion de code où il existait, sa donnée est libérée automatiquement. La libération est donc garantie, au moment précis où elle doit avoir lieu, sans intervention.

Un exemple concret. Lorsqu’on confie une donnée à une nouvelle variable, la propriété se déplace :

let a = String::from("glace");

let b = a;          // la propriété passe de a à b

println!("{b}");    // b fonctionne

// println!("{a}"); // refusé : a ne possède plus rien

La dernière ligne, laissée en commentaire, serait rejetée par le compilateur : puisque a a cédé sa donnée à b, il n’a plus le droit de l’utiliser. Ce contrôle, effectué avant l’exécution, écarte à lui seul toute une famille d’erreurs.

La seconde règle organise le prêt. On peut donner accès à une donnée sans en céder la propriété, comme on prête un livre, mais sous une condition stricte : soit plusieurs parties du code peuvent la lire en même temps, soit une seule peut la modifier, jamais les deux à la fois. Cette règle interdit qu’une donnée soit modifiée pendant qu’une autre partie la consulte.

Le composant du compilateur qui applique ces règles s’appelle le borrow checker, le « vérificateur d’emprunts ». Il occupe une place centrale dans le travail quotidien en Rust. Ses refus paraissent d’abord excessifs, puis on constate qu’ils correspondent, dans un autre langage, à des bugs qui se seraient manifestés plus tard, en production. La contrainte imposée à l’écriture est le prix d’une catégorie entière d’erreurs évitées.

Le résultat est le point fort du langage. Rust obtient la sécurité mémoire des langages à ramasse-miettes, sans ramasse-miettes, et la vitesse des langages à gestion manuelle, sans leurs pièges. Toutes les vérifications ont lieu à la compilation ; une fois le programme lancé, il n’y a ni dispositif de nettoyage ni interruption, puisque les règles ont déjà été respectées.

C’est cette idée, rendue accessible dans un langage généraliste, qui distingue Rust. Elle constitue une réponse construite à un problème posé depuis un demi-siècle, plutôt qu’un simple ajout de confort.

Le prochain épisode quitte les concepts pour la pratique : ce qu’est une bibliothèque standard, et pourquoi certains langages sont livrés avec beaucoup plus d’outils que d’autres.

Rendez-vous dès le 3 août pour la suite et la fin de notre saga Rust par Benoït.