Com­pi­la­teur et in­ter­pré­teur : ex­pli­ca­tions et dif­fé­rence

Il convient d’observer deux choses lorsque l’on choisit un langage de pro­gram­ma­tion : d’une part, ce langage doit offrir tous les éléments né­ces­saires à la réa­li­sa­tion du projet logiciel prévu. D’autre part, la pro­gram­ma­tion et la mise en œuvre de ce projet doivent être aussi simples que possible. Dans ce cadre, la bonne li­si­bi­lité et la sim­pli­cité du code sont des atouts décisifs, car ces ca­rac­té­ris­tiques sim­pli­fient non seulement l’ap­pren­tis­sage du code, mais aussi l’uti­li­sa­tion quo­ti­dienne d’un langage de pro­gram­ma­tion.

Pour que les ins­truc­tions d’un programme écrit puissent ensuite être comprises par un or­di­na­teur ou un pro­ces­seur, le code source des langages de pro­gram­ma­tion modernes doit tout d’abord être transposé dans une forme lisible par machine. Selon le langage de pro­gram­ma­tion, cette opération est effectuée par un com­pi­la­teur ou un in­ter­pré­teur. Mais à quoi cor­res­pon­dent ces deux outils exac­te­ment ? Et en quoi sont-ils dif­fé­rents ?

Un in­ter­pré­teur est un programme in­for­ma­tique qui traite le code source d’un projet logiciel pendant son fonc­tion­ne­ment – c’est-à-dire pendant son exécution – et joue le rôle d’interface entre le projet et le pro­ces­seur. Dans ce cadre, un in­ter­pré­teur procède toujours ligne de code par ligne de code, de façon à ce que les dif­fé­rentes ins­truc­tions soient lues, analysées et préparées pour le pro­ces­seur dans l’ordre. Ce principe s’applique également aux ins­truc­tions ré­cur­rentes qui sont à chaque fois ré-exécutées lorsque leur tour est arrivé. Pour traiter le code du logiciel, les in­ter­pré­teurs utilisent leurs propres bi­blio­thèques internes : lorsqu’une ligne de code source est convertie dans les commandes lisibles par machine cor­res­pon­dantes, elle est di­rec­te­ment transmise au pro­ces­seur.

Le processus de con­ver­sion est uni­que­ment achevé lorsque l’ensemble du code a été in­ter­prété. Il n’est in­ter­rompu que si une erreur survient pendant le trai­te­ment, chose qui simplifie con­si­dé­ra­ble­ment la gestion des erreurs, car la ligne de code posant problème est im­mé­dia­te­ment iden­ti­fiée lorsque l’erreur survient.

Un com­pi­la­teur est un programme in­for­ma­tique qui traduit l’ensemble du code source d’un projet logiciel en code machine avant son exécution. C’est uni­que­ment après cette tra­duc­tion que le projet sera exécuté par le pro­ces­seur qui dispose de toutes les ins­truc­tions sous forme de code machine avant le début du projet. De cette façon, le pro­ces­seur a à dis­po­si­tion tous les éléments né­ces­saires pour exécuter le logiciel en question, traiter les données et générer le résultat. Dans de nombreux cas, une étape in­ter­mé­diaire décisive a toutefois lieu pendant le processus de com­pi­la­tion : avant la tra­duc­tion dé­fi­ni­tive en code machine, la plupart des com­pi­la­teurs con­ver­tis­sent en effet le code source en code in­ter­mé­diaire (également appelé « code objet ») qui est souvent adapté à dif­fé­rentes pla­te­formes et peut être utilisé par un in­ter­pré­teur.

Lors de la gé­né­ra­tion du code, les com­pi­la­teurs dé­fi­nis­sent l’ordre dans lequel les ins­truc­tions seront trans­mises au pro­ces­seur. Si les ins­truc­tions ne sont pas in­ter­dé­pen­dantes, le com­pi­la­teur peut même traiter les ins­truc­tions en parallèle.

Le com­pi­la­teur et l’in­ter­pré­teur servent tous deux à trans­po­ser le code du logiciel dans une forme lisible par machine exé­cu­table. Sans cette tra­duc­tion, les pro­ces­seurs des or­di­na­teurs ne pour­raient pas exécuter les pro­grammes dans des langages comme C, C++, PHP, Python ou Ruby. C’est la raison pour laquelle ces outils sont in­dis­pen­sables à l’uti­li­sa­tion de PC, d’or­di­na­teurs portables et de smart­phones. Les pré­sen­ta­tions suc­cinctes ef­fec­tuées pré­cé­dem­ment ont déjà montré qu’il existait des dif­fé­rences im­por­tantes entre les com­pi­la­teurs et les in­ter­pré­teurs. Il convient d’en tenir compte dans le choix du langage de pro­gram­ma­tion adapté au nouveau logiciel. Le tableau suivant résume les prin­ci­paux points de com­pa­rai­son entre les « com­pi­la­teurs et les in­ter­pré­teurs » :

Les dif­fé­rences entre les com­pi­la­teurs et les in­ter­pré­teurs nous indiquent également les points forts et les points faibles de chaque solution en ce qui concerne la tra­duc­tion du code du programme : les pro­grammes in­ter­pré­tés sont exé­cu­tables im­mé­dia­te­ment et bé­né­fi­cient d’un lancement nettement plus rapide. Par ailleurs, le dé­ve­lop­pe­ment est nettement plus simple que pour une ap­pli­ca­tion compilée, car le processus de débogage (c’est-à-dire la cor­rec­tion des erreurs) fonc­tionne de la même façon que la tra­duc­tion, à savoir ligne par ligne. Dans le cas d’un logiciel compilé, il est tout d’abord né­ces­saire de convertir l’in­té­gra­lité du code avant de pouvoir corriger les erreurs ou de lancer l’ap­pli­ca­tion. Cependant, une fois le programme lancé, le com­pi­la­teur n’est plus né­ces­saire alors qu’un in­ter­pré­teur utilise toujours de la puissance de calcul.

Il existe par ailleurs une solution hybride qui permet de parer aux points faibles de ces deux solutions : le « com­pi­la­teur just-in-time » (angl. pour « à temps ») ou « com­pi­la­teur à la volée ». Ce type de com­pi­la­teur par­ti­cu­lier rompt avec l’approche tra­di­tion­nelle du com­pi­la­teur et traduit le code du programme pendant le fonc­tion­ne­ment, à l’instar d’un in­ter­pré­teur. De cette façon, la vitesse d’exécution élevée (permise par le com­pi­la­teur) est complétée par un processus de dé­ve­lop­pe­ment simplifié.

L’exemple le plus connu de langage basé sur le principe de la com­pi­la­tion à la volée est Java : en tant que composant de l’en­vi­ron­ne­ment d’exécution Java (JRE), un tel com­pi­la­teur à la volée permet d’améliorer la per­for­mance des ap­pli­ca­tions Java en con­ver­tis­sant le code binaire généré pré­cé­dem­ment en code machine au moment de l’exécution.