Tous les articles disponibles au paiement en 4 fois sans frais
37,98 €
Les prix des articles vendus sur Amazon incluent la TVA. En fonction de votre adresse de livraison, la TVA peut varier au moment du paiement. Pour plus d’informations, Veuillez voir les détails.
Retours GRATUITS
Ou livraison accélérée demain 3 avril. Commandez dans les 18 h 40 min. Détails
En stock
37,98 € € () Options sélectionnées incluses. Comprend le paiement mensuel initial et les options sélectionnées. Détails
Prix
Sous-total
37,98 € €
Sous-total
Ventilation du paiement initial
Les frais d’expédition, la date de livraison et le total de la commande (taxes comprises) indiqués lors de la finalisation de la commande.
Expédié par
Amazon
Amazon
Expédié par
Amazon
Vendu par
Amazon
Amazon
Vendu par
Amazon
Retours
Retours de 30 jours et garanties légales
Retournez un produit jusqu’à 30 jours
Demandez le retour d’un produit jusqu’à 14 jours après sa réception, sans motif, pour obtenir un remboursement complet (prix et frais de livraison) au titre du droit légal de rétractation. Amazon.fr permet en plus les retours jusqu’au 30ème jour et le remboursement du prix sans les frais de livraison. Certains produits sont exclus des retours (denrées périssables...). Pour plus d’info sur les retours (exceptions, frais de retour,…), consultez cette page pour les produits expédiés par Amazon et cette page pour ceux expédiés par les vendeurs tiers.

Vous pouvez obtenir gratuitement une réparation, un remplacement ou un remboursement pendant 2 ans après votre achat au titre de la garantie légale de conformité (dysfonctionnement, panne ...). La garantie légale des vices cachés s’applique également. En savoir plus sur les garanties légales.
Politique de retour pour les produits expédiés par Amazon
Paiement
Transaction sécurisée
Votre transaction est sécurisée
Nous nous efforçons de protéger votre sécurité et votre vie privée. Notre système de paiement sécurisé chiffre vos données lors de la transmission. Nous ne partageons pas les détails de votre carte de crédit avec les vendeurs tiers, et nous ne vendons pas vos données personnelles à autrui. En savoir plus
Autres vendeurs sur Amazon
Neuf & D'occasion (5) 
Image du logo de l'application Kindle

Téléchargez l'application Kindle gratuite et commencez à lire des livres Kindle instantanément sur votre smartphone, tablette ou ordinateur - aucun appareil Kindle n'est requis.

Lisez instantanément sur votre navigateur avec Kindle pour le Web.

Utilisation de l'appareil photo de votre téléphone portable - scannez le code ci-dessous et téléchargez l'application Kindle.

Code QR pour télécharger l'application Kindle

Suivre l'auteur

Thorsten Ball
Suivre
Une erreur est survenue. Veuillez renouveler votre requête plus tard.

Writing A Compiler In Go Broché – 10 août 2018

Édition en Anglais de Thorsten Ball (Auteur)
4,8 sur 5 étoiles 99 évaluations
{"desktop_buybox_group_1":[{"displayPrice":"37,98 €","priceAmount":37.98,"currencySymbol":"€","integerValue":"37","decimalSeparator":",","fractionalValue":"98","symbolPosition":"right","hasSpace":true,"showFractionalPartIfEmpty":true,"offerListingId":"GJPhdQnqzhsQOYQHkbILXdd6lG133zM0E6hC1bg3mkqO8p5In1%2BJdmSS0%2FTZESggY%2B8MIp0M207vLpzax940zG5QBgwMsGqnUjmYSnPt1kfDXtO82OR6WrlhiumM%2BRTQnZnGEFpSkro%3D","locale":"fr-FR","buyingOptionType":"NEW","aapiBuyingOptionIndex":0}]}

Options d'achat et paniers Plus

Writing A Compiler In Go - Version 1.2 - Find out more at https://compilerbook.com

This is the sequel to Writing An Interpreter In Go. We're picking up right where we left off and write a compiler and a virtual machine for Monkey.

Runnable and tested code front and center, built from the ground up, step by step — just like before. But this time, we're going to define bytecode, compile Monkey and execute it in our very own virtual machine. It's the next step in Monkey's evolution. It's the sequel to … a programming language.

Writing A Compiler In Go is the sequel to Writing An Interpreter In Go.
It starts right where the first one stopped, with a fully-working, fully-tested Monkey interpreter in hand, connecting both books seamlessly, ready to build a compiler and a virtual machine for Monkey. In this book, we use the codebase (included in the book!) from the first part and extend it. We take the lexer, the parser, the AST, the REPL and the object system and use them to build a new, faster implementation of Monkey, right next to the tree-walking evaluator we built in the first book.

The approach is unchanged, too. Working, tested code is the focus, we build everything from scratch, do baby steps, write tests firsts, use no 3rd-party-libraries and see and understand how all the pieces fit together.It's a continuation in prose and in code. Do you need to read the first part before this one? If you're okay with treating the code from the first book as black box, then no. But that's not what these books are about; they're about opening up black boxes, looking inside and shining a light. You'll have the best understanding of where we're going in this book, if you know where we started.

Learn how to write a compiler and a virtual machine
Our main goal in in this book is to evolve Monkey. We change its architecture and turn it into a bytecode compiler and virtual machine.We'll take the lexer, the parser, the AST and the object system we wrote in the first book and use them to build our own Monkey compiler and virtual machine … from scratch! We'll build them side-by-side so that we'll always have a running system we can steadily evolve.What we end up with is not only much closer to the programming languages we use every day, giving us a better understanding of how they work, but also 3x faster. And that's without explicitly aiming for performance.

Here's what we'll do:
  • We define our own bytecode instructions, specifying their operands and their encoding. Along the way, we also build a mini-disassembler for them.
  • We write a compiler that takes in a Monkey AST and turns it into bytecode by emitting instructions
  • At the same time we build a stack-based virtual machine that executes the bytecode in its main loop
We'll learn a lot about computers, how they work, what machine code and opcodes are, what the stack is and how to work with stack pointers and frame pointers, what it means to define a calling convention, and much more.

We also
  • build a symbol table and a constant pool
  • do stack arithmetic
  • generate jump instructions
  • build frames into our VM to execute functions with local bindings and arguments!
  • add built-in functions to the VM
  • get real closures working in the virtual machine and learn why closure-compilation is so tricky
Diapositive précédente des détails du produit
  1. Nombre de pages de l'édition imprimée 
    352 pages
  2. Langue
    Anglais
  3. Date de publication
    10 août 2018
  4. Dimensions
    17.78 x 2.03 x 25.4 cm
  5. ISBN-10
    398201610X
  6. ISBN-13
    978-3982016108
Diapositive suivante contenant les détails du produit
Économisez 3 € sur les frais de livraison de livres
Choisissez le point de retrait éligible qui vous convient lors de la commande et profitez de la livraison gratuite de livres neufs expédiés par Amazon. En savoir plus

Produits fréquemment achetés ensemble

Writing A Compiler In Go
Cet article : Writing A Compiler In Go
37,98€
En stock
Expédié et vendu par Amazon.
+
Writing An Interpreter In Go
37,98€
En stock
Expédié et vendu par Amazon.
+
Crafting Interpreters
52,70€
En stock
Expédié et vendu par Amazon.
Prix total: $00
Pour voir notre prix, ajoutez ces articles à votre panier.
Détails
Ajouté au panier
spCSRF_Treatment
Choisir les articles à acheter ensemble.

Détails sur le produit

  • Éditeur ‏ : ‎ Thorsten Ball (10 août 2018)
  • Langue ‏ : ‎ Anglais
  • Broché ‏ : ‎ 352 pages
  • ISBN-10 ‏ : ‎ 398201610X
  • ISBN-13 ‏ : ‎ 978-3982016108
  • Poids de l'article ‏ : ‎ 522 g
  • Dimensions ‏ : ‎ 17.78 x 2.03 x 25.4 cm
  • Commentaires client :
    4,8 sur 5 étoiles 99 évaluations

À propos de l'auteur

Suivez les auteurs pour obtenir de nouvelles mises à jour et des recommandations améliorées.
Thorsten Ball

Thorsten Ball

Brief content visible, double tap to read full content.
Full content visible, double tap to read brief content.

Découvrez d'autres livres de l'auteur et des auteurs similaires, lisez des recommandations de livres et plus encore.

Commentaires client

4,8 étoiles sur 5
99 évaluations globales

Évaluer ce produit

Partagez votre opinion avec les autres clients
Écrire un commentaire client

Meilleures évaluations de France

  • Franck Jeannin
    5,0 sur 5 étoiles Coup de maitre
    Avis laissé en France le 14 septembre 2018
    Achat vérifié
    « Writing a compiler in Go » est le digne successeur de “Writing an interpreter in Go” et le talent de l’auteur pour rendre simple des choses complexes ne se dément pas.
    Comme pour le premier opus, le cheminement est extrêmement progressif (sans pour autant prendre de raccourcis) et le style très agréable.
    A la fin du livre vous aurez réellement écris 100% d’un compilateur (byte code et machine virtuelle) sans utiliser aucun outil externe et aucune librairie autre qu’une toute petite portion de la librairie standard Go.

    Même si vous ne pratiquez pas ou n’aimez pas Go (ce qui serait vraiment dommage), vous pouvez faire abstraction du langage utilisé, ce livre reste un des rares ouvrages accessible sur le sujet et rien ne vous empêche de porter le code dans votre langage préféré (quelqu’un la fait pour Rust sur le premier volume).

    J’ai vraiment hâte de découvrir ce que sera son prochain livre. Suggestions (improbables) : « Writing a micro-processor in VHDL » ?!? « Writing an operating system in Monkey » ?!?
    2 personnes ont trouvé cela utile
    Utile
     Signaler

Meilleurs commentaires provenant d’autres pays

Traduire tous les commentaires en français
  • Avi
    5,0 sur 5 étoiles An excellent book!
    Avis laissé aux États-Unis le 2 décembre 2024
    Achat vérifié
    Thorsten has done an amazing job at taking a complicated subject, distilling it down into digestible parts and taking the reader along (a fun) journey to implement a compiler in Go.

    All of the concepts are masterfully introduced at the right time and in small steps. I have no background or knowledge of creating programming languages and I was able to follow along from the first page to the last page with relative ease.

    The author's writing style is very fun and engaging which made it very easy to consume the whole book in just a few days.

    My two favorite parts about the author's coding choices are:
    1) test driven design - tests were written to set the expected outcomes before any non-test code was written
    2) zero external dependencies/modules - *everything* was built using the Monkey interpreter (from the previous book) and the Go standard library (stdlib).

    10/10 I would highly recommend this book.
    Signaler
  • Sam Brown
    5,0 sur 5 étoiles So THAT's how compilers work
    Avis laissé au Royaume-Uni le 12 septembre 2020
    Achat vérifié
    This is a great book for understanding the inner parts of a compiler, especially if:
    1. You are already a programmer
    2. You code along in Go (no previous Go knowledge needed)
    3. You have some interest in compilers
    It is very hands on, and you need to work from beginning to end of the book, which is not how technical books on computers usually work. I found it rewarding getting feedback when the code I had copied actually worked as I went along.
    It is not a comprehensive book about all the various ways a compiler can be written.
    Signaler
  • Sören Schellhoff
    5,0 sur 5 étoiles Sehr guter Einstieg
    Avis laissé en Allemagne le 6 novembre 2019
    Achat vérifié
    Das Buch ist ein guter Einstieg in die Thematik und verfolgt dabei, wie bereits der erste Teil, einen sehr praktischen Ansatz. Ich kannte Go vorher nur sporadisch und konnte den Code dennoch gut verstehen. Für die die sich weitergehende für das Thema interessieren empfehle ich auch einen Blick auf Crafting Interpreters von Bob Nystrom zu werfen. Hier wird ein ähnlicher Ansatz verfolgt, wobei sich das Buch in vielen Kleinigkeiten unterscheidet. In Kombination mit diesem Buch erhält man so noch ein paar mehr Ideen zur praktischen Umsetzung von Interpretern und VM Compilern.
    Signaler
  • Sergey Ten
    5,0 sur 5 étoiles Great coverage of the fundamentals of bytecode generation and execution
    Avis laissé aux États-Unis le 29 septembre 2020
    Achat vérifié
    The book picks up where the previous book, "Writing an Interpreter in Go", left off. The author takes an AST tree produced by the same parser that serves the Interpreter, and builds a bytecode out of it to later feed into a bytecode execution engine that is built in parallel. The book gives the reader all necessary background about the workings of a stack machine, and goes on to building one. The reader then learns about stack maintenance during normal execution flow, as well as calling functions, where the importance of agreeing on a calling convention (passing arguments, returning a value, allocating local variables) is paramount. Another important concept is delayed patching of the code that's been generated to get the conditional and unconditional jump instructions to have correct operands - those come into play while processing if() conditions. At times, the code seems somewhat hackish, but still illustrates the points author tries to explain.

    My only problem is with the Kindle edition, as that it appears to have lost some stack diagrams that were supposed to further illustrate the material discussed. I'm attaching a screenshot from the online reader where there's clearly a picture missing from the page. There are a few of such places - not many, maybe 3-4 or so.
    Image client
    Sergey Ten
    5,0 sur 5 étoiles
    Great coverage of the fundamentals of bytecode generation and execution

    Avis laissé aux États-Unis le 29 septembre 2020
    The book picks up where the previous book, "Writing an Interpreter in Go", left off. The author takes an AST tree produced by the same parser that serves the Interpreter, and builds a bytecode out of it to later feed into a bytecode execution engine that is built in parallel. The book gives the reader all necessary background about the workings of a stack machine, and goes on to building one. The reader then learns about stack maintenance during normal execution flow, as well as calling functions, where the importance of agreeing on a calling convention (passing arguments, returning a value, allocating local variables) is paramount. Another important concept is delayed patching of the code that's been generated to get the conditional and unconditional jump instructions to have correct operands - those come into play while processing if() conditions. At times, the code seems somewhat hackish, but still illustrates the points author tries to explain.

    My only problem is with the Kindle edition, as that it appears to have lost some stack diagrams that were supposed to further illustrate the material discussed. I'm attaching a screenshot from the online reader where there's clearly a picture missing from the page. There are a few of such places - not many, maybe 3-4 or so.
    Images dans cette revue
    Image client
    Signaler
  • kdfuser
    5,0 sur 5 étoiles Very easy to follow, code works as advertized
    Avis laissé aux États-Unis le 12 avril 2020
    Achat vérifié
    I have both the waiig and the wacig books. I followed both books and entered the code myself. It took me about 2 months to finish the books and code in sequence. (It's important that you follow them in sequence.)

    The compiler book went much faster because the basics are the same as the interpreter book. Instead of tree-walk to eval, the compiler emits instructions for the vm to execute. Since early in my career I was an assembly language programmer. The vm's stack architecture is quite natural to me so the vm portion, though new, was easy for me to follow as well.

    Both books are wonderfully written. Code in both book work as advertised. I enjoyed reading and following the code immensely.

    Ever since I left school I wanted to someday write a compiler. I did it! :-) . I am thinking about re-implementing the programs in Python. That should be quite fun, I would think.
    Signaler