Écrire un compilateur en Go

Introduction

Le livre « Writing a Compiler in Go » est la deuxième partie de la célèbre dilogie de Thorsten Ball, consacrée à la création d'un interpréteur et d'un compilateur pour le langage Monkey. Si le premier livre (« Writing an Interpreter in Go ») apprend à construire un interpréteur, ce volume guide le lecteur plus loin — vers la création d'un compilateur complet, générant du bytecode, et de sa propre machine virtuelle (VM).

Publié en 2019, le livre compte 246 pages et s'adresse aux programmeurs maîtrisant le langage Go (Golang). Il est idéal pour ceux qui souhaitent comprendre en profondeur, par la pratique, comment fonctionnent les compilateurs, le bytecode et les machines virtuelles.

De quoi parle le livre

Thorsten Ball montre, étape par étape, comment transformer l'interpréteur du premier livre en un compilateur. L'idée principale : au lieu d'exécuter directement l'AST (arbre de syntaxe abstraite), nous le compilons en instructions bytecode, puis nous les exécutons sur une machine virtuelle.

Le livre couvre les sujets suivants :

• Conception d'un système d'instructions (opcodes) pour le bytecode.
• Implémentation d'un compilateur qui transforme l'AST en une séquence de bytecode.
• Création d'une machine virtuelle (VM) orientée pile.
• Gestion des variables, fonctions, fermetures, tableaux, dictionnaires et fonctions intégrées.
• Optimisation et débogage du compilateur.
• Test de chaque étape à l'aide de tests unitaires.

Pour qui est ce livre

Le livre s'adresse aux développeurs Go de niveau intermédiaire et avancé, déjà familiers avec les bases du langage et souhaitant approfondir la programmation système. Il sera également utile à tous ceux qui s'intéressent aux compilateurs, aux machines virtuelles et au fonctionnement interne des langages de programmation. Si vous avez lu le premier livre, c'est une suite obligatoire. Sinon, l'auteur recommande de commencer par celui-ci, mais il est possible de s'y attaquer directement, bien que ce soit plus difficile.

Ce que le lecteur apprendra

• Comment fonctionne la compilation de l'AST en bytecode. Vous apprendrez à concevoir un système d'instructions et à écrire du code qui génère du bytecode à partir de l'arbre d'analyse.
• Comment fonctionne une machine virtuelle à pile. Vous implémenterez une VM qui exécute le bytecode, gère la pile, les appels de fonctions et la mémoire.
• Comment gérer les fermetures (closures). L'un des sujets les plus complexes — la capture de variables depuis un contexte externe — est traité de manière très détaillée.
• Comment tester le compilateur et la VM. L'auteur accorde une grande importance aux tests, ce qui rend le livre pratique.
• Comment déboguer le bytecode. Vous apprendrez à afficher une trace et à trouver des erreurs dans le compilateur.

Points forts

• Orientation pratique. Chaque chapitre contient du code que vous pouvez immédiatement exécuter et modifier. Vous ne lisez pas simplement de la théorie, vous écrivez un véritable compilateur.
• Exposé progressif. L'auteur ne surcharge pas le lecteur avec des concepts complexes d'un coup. Chaque nouvel élément est introduit progressivement, avec des exemples et des tests.
• Code Go propre et compréhensible. Le code est écrit dans un style proche du code de production, avec un accent sur la lisibilité et la modularité.
• Immersion profonde dans le sujet. Vous apprendrez non seulement le « comment », mais aussi le « pourquoi » — l'auteur explique les compromis et les approches alternatives.
• Autonomie. Le livre contient tout le nécessaire : de la conception à l'implémentation finale. À la fin, vous obtenez un compilateur et une VM fonctionnels.

À qui est-il recommandé

Le livre sera utile :

• Aux développeurs Go souhaitant élargir leurs horizons et comprendre comment les langages de programmation fonctionnent de l'intérieur.
• Aux étudiants et enseignants de cours sur les compilateurs — comme excellent matériel pratique.
• Aux développeurs d'autres langages (Python, Java, C++) connaissant Go — les concepts sont universels.