Aller au contenu
Encyclopédie informatique Édition 2026

Compilation et interprétation

Partie 3 sur 4

Niveau de lecture :

5Les langages courants, situés

Le tableau suivant situe quelques langages, en précisant qu’il s’agit de l’implémentation habituelle et que des variantes existent.

LangageChaîne habituelleRemarque
C, C++Compilation directe en code machineVitesse maximale ; gestion de la mémoire à la charge du programmeur (voir le langage C)
Rust, Go, SwiftCompilation directe en code machineCompilateurs modernes ; Rust vérifie la sûreté de la mémoire à la compilation (voir Rust, Go)
Java, Kotlin, C#Bytecode, machine virtuelle, JITPortabilité et bonne vitesse après chauffe
PythonBytecode, machine virtuelleSouplesse ; vitesse pure plus faible (voir Python)
JavaScriptInterprétation puis JIT dans le navigateurMoteurs très optimisés
TypeScriptTranspilation vers JavaScriptVérification de types à la compilation
Interpréteurs de commandesInterprétationSouplesse avant tout (voir le shell)
SQLAnalyse et plan d’exécution par le moteurLe moteur de base de données « compile » chaque requête en plan (voir SQL)

Le dernier exemple rappelle que la notion dépasse les langages de programmation classiques : une requête SQL est analysée, optimisée (le moteur choisit l’ordre des opérations) puis exécutée, comme dans un compilateur.

6Du programme à l’exécutable : le parcours concret

Voyons ce qui se passe, concrètement, quand on construit un petit programme en C composé de deux fichiers. Les noms de commandes varient selon les systèmes ; on se place dans le principe.

  1. Le préprocesseur traite les directives du fichier source (inclure un autre fichier, remplacer des constantes). Il produit un texte C « déplié ».
  2. Le compilateur traite chaque fichier séparément : analyse, optimisation, génération. Il produit un fichier objet par fichier source.
  3. L’éditeur de liens réunit les fichiers objets et les bibliothèques (ici, par exemple, celle qui fournit l’affichage de texte), résout les appels et écrit l’exécutable.
  4. Au lancement, le chargeur du système d’exploitation place l’exécutable en mémoire, charge les bibliothèques dynamiques nécessaires, prépare la pile et le tas, et donne la main à la première instruction (voir les processus).

Cette décomposition en étapes explique les trois familles d’erreurs que rencontre un débutant : l’erreur de compilation (le texte est invalide ou incohérent : le compilateur refuse), l’erreur d’édition des liens (une fonction promise n’existe nulle part : « référence non définie »), et l’erreur d’exécution (le programme est valide, mais plante ou se trompe en tournant).

6.1Automatiser : les outils de construction

Dès que le projet grossit, on ne lance pas ces commandes à la main. Des outils de construction (build tools) comme make, CMake, Cargo (pour Rust), Maven ou Gradle (pour Java) décrivent la recette dans un fichier : quels fichiers compiler, avec quelles options, dans quel ordre. Ils ne recompilent que ce qui a changé, ce qui fait gagner un temps considérable sur de gros projets. Ils gèrent aussi les dépendances : les bibliothèques de tiers dont dépend le projet (voir la sécurité de la chaîne d’approvisionnement).

6.2Compiler pour une autre machine

La compilation croisée (cross-compilation) consiste à compiler, sur une machine d’une architecture, un programme destiné à une autre : par exemple, produire sur un ordinateur de bureau le programme d’un petit nano-ordinateur ou d’un objet connecté (voir les objets connectés), trop modeste pour héberger un compilateur. Go, Rust et la plupart des chaînes de compilation modernes l’acceptent. C’est aussi ce qui permet de distribuer des logiciels pour plusieurs systèmes depuis une même chaîne de production.

7Conséquences pour le programmeur

7.1La vitesse

Le code compilé directement est en général le plus rapide, et son temps de démarrage est le plus court. Le code interprété est le plus lent. Les machines virtuelles avec compilation à la volée se placent entre les deux, avec une période de chauffe. Mais gardez deux réserves. D’abord, la vitesse brute ne dépend pas que du modèle : un algorithme mal choisi en C peut être cent fois plus lent qu’un bon algorithme en Python (voir l’algorithmique). Ensuite, beaucoup de programmes passent leur temps à attendre (le réseau, le disque, l’utilisateur) : le gain d’un langage compilé y est invisible. Python s’appuie d’ailleurs sur des bibliothèques écrites en C ou en Rust pour les calculs lourds, ce qui donne à la fois confort et vitesse.

7.2La portabilité

Un exécutable compilé pour une architecture et un système ne tourne pas sur un autre. Pour atteindre plusieurs plateformes, il faut compiler plusieurs fois (ou utiliser un bytecode). C’est ce qui explique qu’un même logiciel existe en versions différentes pour Windows, macOS et Linux, et qu’un changement d’architecture (par exemple le passage de nombreux ordinateurs de l’architecture x86 à l’architecture ARM) oblige à recompiler ou à passer par une couche de traduction.

7.3Le débogage

Quand un programme se comporte mal, on le suit pas à pas avec un débogueur. Un code compilé avec optimisation est difficile à suivre, car le compilateur a réordonné, fusionné ou supprimé des instructions ; on compile alors en mode « débogage », en y ajoutant des informations qui relient le code machine aux lignes du source. Dans un langage interprété, la correspondance est directe, et l’on peut souvent corriger et relancer à chaud.

7.4La taille et la distribution

Un exécutable natif est autonome mais lié à une plateforme. Un programme à bytecode demande d’installer la machine virtuelle. Un script interprété demande l’interpréteur. D’où les solutions modernes de distribution : paquets qui embarquent l’interpréteur, conteneurs qui regroupent le programme et ses dépendances, exécutables autonomes produits par les langages compilés (Go notamment produit volontiers un seul fichier statique).

7.5La fiabilité

Plus un langage et son compilateur détectent d’erreurs à l’avance, moins il en reste à l’exécution. Le typage statique, l’interdiction de certaines constructions dangereuses et, pour Rust, la vérification de la gestion de la mémoire par le compilateur illustrent cette idée : déplacer la détection des erreurs vers la compilation, là où elles coûtent le moins cher.