Techniques de création d’interpréteurs

 (craftinginterpreters.com)
3 points par GN⁺ 2024-07-13 | 1 commentaires | Partager sur WhatsApp
  • Crafting Interpreters est un livre conçu pour permettre aux lecteurs qui veulent créer leur propre langage de suivre de bout en bout l’implémentation complète d’un langage de script
  • Il couvre dans un même fil les concepts de conception de langages comme le parsing et la sémantique, jusqu’aux aspects d’implémentation à l’exécution comme la représentation en bytecode et le garbage collection
  • Le lecteur part de main() et implémente lui-même un langage doté de typage dynamique, de portée lexicale, de fonctions de première classe, de fermetures, de classes et d’héritage
  • En faisant écrire directement quelques milliers de lignes de code propre et rapide, l’ouvrage met l’accent sur la compréhension du fonctionnement interne plutôt que sur le seul résultat final
  • Il est proposé en version imprimée, eBook, PDF et web, et sur le web tous les chapitres, textes complémentaires et illustrations peuvent être lus gratuitement

Portée de l’implémentation du livre

  • Crafting Interpreters s’adresse aux lecteurs qui veulent créer leur propre langage de programmation ou comprendre comment les langages sont conçus et implémentés
  • Le livre traite ensemble des sujets clés nécessaires à l’implémentation d’un langage de script complet
    • parsing
    • sémantique
    • représentation en bytecode
    • garbage collection
  • L’implémentation commence à main() et s’étend progressivement jusqu’à un langage doté des fonctionnalités suivantes
    • syntaxe riche
    • typage dynamique
    • portée lexicale
    • fonctions de première classe
    • fermetures
    • classes
    • héritage

Manière de lire et résultat obtenu

  • Au lieu de simplement regarder le code d’exemple, le lecteur suit la structure interne d’un processeur de langage en écrivant lui-même chaque ligne
  • Le code final représente quelques milliers de lignes et vise une implémentation propre et rapide
  • Plutôt que de séparer les concepts de haut niveau et l’implémentation bas niveau, le livre est conçu pour les faire comprendre ensemble au fil de la réalisation d’un même langage

Formats proposés

  • Version imprimée

  • eBook

  • PDF

  • Web

    • Il est proposé avec un design responsive adapté du desktop au téléphone, et tous les chapitres, textes complémentaires et illustrations peuvent être lus gratuitement
    • Read Now

À lire aussi

1 commentaires

 
GN⁺ 2024-07-13
Commentaires sur Hacker News

  • Je suis l’auteur. Voir des réactions aussi positives à mon livre me réchauffe vraiment le cœur. J’y ai consacré énormément de temps et d’affection, et c’est très gratifiant de voir qu’il a eu l’effet espéré.

    • Je suis ingénieur logiciel autodidacte, et je n’ai commencé la programmation qu’à 21 ans. À mon premier emploi, on m’a demandé de créer un langage de requête simple et son interpréteur. Je ne savais absolument pas ce qu’était un interpréteur, mais j’ai trouvé ce livre en ligne en 2017, et en 3 à 4 jours j’avais un prototype fonctionnel, puis 1 à 2 semaines plus tard un vrai produit.
      Cette ressource m’a donné énormément de confiance, et c’est encore aujourd’hui l’un des projets sur lesquels j’ai préféré travailler.
    • Merci d’avoir écrit ce livre. J’en suis presque à la fin de la première partie, et je le suis juste pour le plaisir en Haskell ; à chaque chapitre, je me rends compte que les “petites astuces malignes” que j’avais imaginées ne l’étaient pas tant que ça face aux exigences des chapitres suivants.
      Je me demande aussi si vous envisagez d’écrire une suite, par exemple sur un compilateur ou un JIT pour Lox. Et lexical analygator est génial, au point d’avoir été montré plusieurs fois dans des présentations internes à mon entreprise avec citation de la source, et il y a même eu à une époque du fan art sur tableau blanc.
    • Game Programming Patterns est excellent aussi. Dans les deux livres, j’ai l’impression qu’il y a un style d’écriture honnête et direct.
      Certains auteurs donnent parfois l’impression qu’ils doivent faire croire que tout ce domaine relève de la magie noire, mais c’est peut-être aussi que je n’étais pas à la hauteur pour comprendre les design patterns du GoF.
    • Je n’ai pas encore fini le livre, mais je vous suis vraiment reconnaissant de l’avoir mis gratuitement en ligne. J’ai acheté la version papier, le PDF et la version Kindle, et je recommande aussi aux autres de soutenir l’auteur de cette manière.
    • Ce livre et Writing An Interpreter In Go font partie des ouvrages que je veux absolument lire quand j’aurai un peu plus de temps. J’ai pas mal d’idées autour de la création d’un langage de composition typographique basique.

  • J’ai lu Crafting Interpreters en créant Crumb(https://github.com/liam-ilan/crumb), et la partie sur les portées et les variables locales a été particulièrement essentielle.
    L’équilibre entre mise en œuvre technique et éclairage conceptuel est excellent, ce qui aide beaucoup même quand on s’éloigne du chemin prévu par le livre. C’est le genre d’écriture technique qui sert de référence tant le niveau est élevé.

    • Vous dites “ingénieur en devenir”, mais vu que vous avez créé Crumb, il y a déjà une bonne nouvelle.
    • On peut déjà vous appeler ingénieur. Pas besoin d’être modeste, et ce n’est pas parce qu’on n’a pas terminé un diplôme d’informatique qu’on ne devient pas ingénieur.
      La documentation est bonne et le projet est chouette.
    • Ça a l’air très bien. Je serais curieux de savoir comment vous avez décidé quels types de données inclure.

  • Ce que j’ai préféré dans ce livre, c’est qu’il vous amène à écrire deux interpréteurs différents pour le même langage.
    Grâce à ça, on comprend beaucoup mieux les aspects plus complexes et plus subtils de la création d’un langage de programmation. En rencontrant d’abord les grandes idées dans la première moitié du livre, puis en les retrouvant dans le second interpréteur une fois qu’on s’y est familiarisé, on assimile vraiment les parties intéressantes. C’est un livre remarquable.

  • Puisqu’on parle aussi d’autres ressources sur les compilateurs, je n’ai pas encore tout regardé, mais la série vidéo d’Immo Landwerth où il construit un compilateur en C# en générant de l’IL, des symboles de débogage, etc., était très bien aussi.
    Ça date d’environ 5 ans, donc ce n’est pas du C# tout récent, plutôt l’époque de .NET Core 3, mais ça ne devrait pas poser de gros problème pour l’essentiel. En revanche, il peut y avoir beaucoup d’avertissements liés à la nullabilité de référence.
    https://www.youtube.com/playlist?list=PLRAdsfhKI4OWNOSfS7EUu...

  • J’ai l’impression que la plupart des programmeurs devraient un jour aller jusqu’au bout de ce livre. Le faire m’a donné une bien meilleure compréhension de ce qui se passe réellement à l’intérieur des compilateurs et des outils de langage.
    C’est l’un des meilleurs guides techniques que j’aie suivis, et il m’a énormément aidé à m’approprier les concepts. Et ces concepts ne servent pas seulement pour les compilateurs.

    • Je me demande à quoi cela peut être utile en dehors des compilateurs. Par exemple pour le parsing de formats de données, peut-être.

  • Un avantage secondaire de ce livre, mais peut-être tout aussi important, c’est qu’il enseigne la clarté.
    Le texte, le code, la structure et le rythme sont tous clairs et essentiels. Le mot “Crafting” lui va parfaitement : on a l’impression d’un livre écrit par un artisan pour d’autres artisans.

  • À mon avis, ce livre devrait être la deuxième ou la troisième étape d’un parcours sur les compilateurs de langages de programmation.
    La première étape, c’est d’essayer seul d’écrire un interpréteur pour un petit langage qu’on a soi-même conçu, sans rien connaître aux interpréteurs ni à la conception de langages. La deuxième, c’est de le réécrire en faisant moins d’erreurs.
    Sans ça, il est difficile d’apprécier toute la subtilité du sujet, et on risque de passer à côté de concepts qui ne semblent pas importants au premier abord.

    • Pour moi, ce livre a justement permis de faire disparaître l’aura mystique de ces sujets, et m’a au contraire permis de commencer les deuxième et troisième étapes.
      Il n’est pas nécessaire de tout réinventer soi-même dès le départ. Se tenir sur les épaules des géants est une chose naturelle.
    • Je ne savais pas par où commencer, et je pensais que ce genre de projet relevait d’une magie au-delà de mes capacités. Puis, en lisant Crafting Interpreters, j’ai compris qu’il me suffisait d’un petit coup de pouce mental.
      Si je n’avais pas lu quelque chose comme CI d’abord, je n’aurais probablement jamais essayé d’écrire moi-même un interpréteur, et je ne serais pas arrivé jusqu’à cette troisième étape.
    • Je me souviens qu’au moment où je commençais tout juste à apprendre Java, je voulais créer mon propre langage. J’avais même implémenté un algorithme de priorité des opérateurs sans aller le chercher ailleurs : je parcourais une liste de tokens en cherchant à chaque fois la sous-expression de plus haute priorité.
      Il n’y avait pas de récursion, je faisais tout manuellement avec des push et pop sur une pile. Le problème, c’est que je ne comprenais pas vraiment le parsing, donc la plus grande partie du langage était implémentée avec string.split et string.replace, et comme on pouvait s’y attendre, j’ai créé des concepts impossibles à imbriquer. Je regrette de ne pas avoir conservé le code source.
    • J’ai fait exactement la même chose. Comme première étape, j’ai créé un langage à la TeX avec définition et substitution de macros.
      Au bout de quelques jours, après avoir rencontré beaucoup trop de bugs, j’ai adopté une approche plus académique et j’ai commencé à lire des livres. Mais c’était quand même une excellente première étape : sans cette tentative, je n’aurais peut-être même pas su que c’était un sujet qui mérite tout un livre.

  • J’ai énormément de respect pour les personnes qui ont ce genre de dévouement, ainsi que pour tous ceux qui maintiennent l’infrastructure de développement, mais je suis soulagé que ma phase « je veux créer un langage » se soit terminée comme un simple intérêt passager
    La charge de travail est vraiment énorme

    • Ce n’est pas forcément obligé d’être un travail colossal. À l’origine, le Lisp-en-Lisp de SICP ou l’interpréteur de calcul lambda écrit en Haskell tiennent sur un seul écran

  • Je me demande s’il existe de bonnes ressources pour créer un langage à typage statique avec des choses comme le polymorphisme paramétrique et une inférence de types de base

    • On m’a demandé plusieurs fois d’écrire un livre de ce genre, mais la grande raison pour laquelle je ne l’ai pas encore fait, c’est que le sujet est trop ouvert
      Avec Crafting Interpreters, j’avais le sentiment qu’on pouvait créer un petit langage autonome capable d’inclure presque tous les concepts que je voulais enseigner : portée des variables, fonctions, closures, classes et dispatch dynamique, contrôle de flux, etc.
      En revanche, pour les systèmes de types, il y a bien trop d’embranchements dans l’espace de conception, sans trajectoire clairement « meilleure ». Y a-t-il du sous-typage, les génériques sont-ils effacés ou réifiés, le code générique est-il spécialisé à la compilation, l’inférence de types est-elle locale ou de type Hindley-Milner : tous ces choix sont des bifurcations
      Quel que soit le choix, on laisse de côté des éléments importants des branches non retenues, et on risque de décevoir les lecteurs qui attendaient une autre voie. Peut-être qu’un ouvrage panoramique plus large comme Types and Programming Languages serait plus approprié, mais on perd alors le plaisir de construire quelque chose de cohérent de bout en bout
    • Il y a Modern Compiler Implementation in ML de A. W. Appel
      Il existe aussi les versions C et Java du même livre, mais elles me semblent moins bonnes. Je recommanderais plutôt de partir sur la version ML
    • Le cœur du polymorphisme paramétrique et de l’inférence de types, au fond, c’est l’implémentation de Algorithm W. Il suffit de trouver une implémentation jouet en ligne et de la manipuler soi-même
      J’ai trouvé que l’implémentation de https://github.com/wh5a/Algorithm-W-Step-By-Step/blob/master... avait un style très daté, alors je l’ai modernisée et remise en forme jusqu’à obtenir https://gist.github.com/kccqzy/fa8a8ae12a198b41c6339e8a5c459.... Ensuite, j’ai volontairement « cassé » différentes parties pour observer comment l’algorithme se dérègle
    • C’est un peu plus théorique, mais suivre lentement le cours de compilation de Coursera a été pour moi un grand déclic. J’ai dû revoir certaines vidéos plusieurs fois
      Je recommande vivement d’essayer, de manière accessible, l’un de ces travaux d’informatique qu’on croit réservés aux magiciens. Une fois qu’on en a mené un ou deux à bien, on se rend compte que c’est difficile, certes, mais qu’il s’agit surtout d’avancer péniblement jusqu’au bout, et cela donne énormément de confiance. Si quelqu’un veut se lancer dans cette voie, il peut me contacter à zellyn@(most things)

  • Je viens tout juste de finir la partie 2, et c’est vraiment un excellent livre. Faire soi-même un ou deux des exercices proposés à chaque chapitre aide énormément à comprendre le contenu