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.

Un ordinateur ne comprend qu’une seule chose : une suite de 0 et de 1. Il exécute les instructions , sans intuition ni interprétation, même lorsqu’elles n’ont pas de sens. Toute la programmation consiste à traduire des intentions humaines vers ce langage strictement littéral. L’outil qui réalise cette traduction s’appelle le compilateur.

L’analogie de la recette de cuisine peut aider à éclairer son rôle. Transmettez une recette à quelqu’un qui ne parle pas votre langue et prend chaque mot au premier degré : il faut tout préciser, sans rien laisser d’implicite. Le compilateur effectue ce travail. Il prend le texte lisible écrit par le programmeur et le transforme en instructions que le processeur exécute directement.

Prenons le programme le plus simple, celui qui affiche un message. En Rust, il s’écrit ainsi :

fn main() {

    println!("Bonjour, l'été !");

}

fn main indique le point de départ du programme, et println! demande d’afficher un texte. Ces quelques mots restent proches du langage courant. Le compilateur, lui, les convertit en un grand nombre d’instructions élémentaires pour le processeur. Le programmeur lit « affiche bonjour » ; la machine reçoit une description d’une précision totale.

Il existe deux grandes façons d’exécuter un programme. Dans les langages interprétés, un logiciel lit le code et l’exécute au fur et à mesure, ligne après ligne, à la manière d’un interprète qui traduit une conversation en direct. Python fonctionne ainsi. Dans les langages compilés, l’ensemble du code est traduit d’un bloc, une fois pour toutes, en un fichier autonome et rapide, comme un texte traduit puis imprimé. Rust appartient à cette seconde catégorie, ce qui contribue à sa rapidité d’exécution.

Le compilateur de Rust se distingue par sa sévérité. Beaucoup de compilateurs se contentent de traduire et laissent passer les problèmes qui ne les empêchent pas de produire un résultat. Celui de Rust inspecte le code à la recherche de risques avant de valider quoi que ce soit. Une mémoire mal gérée, une valeur utilisée là où elle ne devrait plus l’être : dans ces cas, il refuse de compiler et renvoie le programmeur à sa copie.

Cette exigence déroute au début, puis on en comprend la logique. Ce que le compilateur interdit d’écrire correspond, dans d’autres langages, à des erreurs qui se manifesteraient plus tard, une fois le logiciel entre les mains des utilisateurs. D’où une formule répandue dans la communauté : « si ça compile, ça marche ». Elle n’est pas littéralement vraie, mais elle l’est assez souvent pour être significative.

Le compilateur de Rust est par ailleurs réputé pour la clarté de ses messages. Plutôt qu’un laconique « erreur ligne 12 », il décrit le problème, désigne l’endroit exact et suggère fréquemment une correction. Beaucoup de débutants, et j’en ai fait partie, disent avoir progressé en lisant attentivement ces messages et en comprenant la correction implicitement ou non suggérée.

Le prochain épisode s’intéresse à la matière première de tout programme, les variables, et à une question qui distingue les langages entre eux : faut-il déclarer à l’avance le type de donnée que l’on manipule ? Rendez-vous le 28 juillet pour les parties 3 et 4...