Writing An Interpreter In Go 1st Edition

A good book for getting started on writing an interpreter. By the end of this book, you have a functioning little language and interpreter for the author's homegrown language called Monkey.You learn the basics of lexing, parsing (using Pratt Parsing) and evaluation (tree walking) and how you can use these techniques in developing an interpreter.This is a great book for getting started writing an interpreter and shows that it isn't some sort of magic. The code is written in Go, however, the techniques are covered in enough depth so that you can easily translate them.I dock it one star because I felt the author could have left out writing all of the tests and left that to the downloadable code. While testing your code is a good thing, I feel that it's coverage in the book was a little too much. Leaving this out would have left a little more room to add more language features or perhaps show how to handle right associativity with the Pratt Parser.

I've read many books and web articles on writing compilers and interpreters and this is one of the most accessible yet. The author describes step by step how to construct a Top Down Operator Precedence or Pratt Parser. The book contains a lot of simple elegant code that is a joy to read. The book contains just enough theory to help you understand , but not too much that you get overwhelmed. Recommend to any one interested in how parsers work. I would love it if the author writes a second volume focused on optimization or compiling down to native instruction.

This is probably the 9th book about compilers I bought and read in the last two years... And I loved it. The author is really honest with his introduction on why he wrote the book and what is expected to cover on it so you are completely warned from the beginning.This is not a book to learn Go (there are better books about it) neither a book about how to design a programming language (there are many other academic books about it) or a book about different parsing algorithms (for that I recommend Language Implementation Patterns by Parr) but it is a book about writing an interpreter in Go, exactly as the title says, and I love it.

Just like the author says in the beginning, the book is intended to be a practical guide to programming language design, and fill the void between step-by-step tutorials and academic volumes. The book definitely delivers on the promise - it builds the interpreter from the ground up, from lexer to parser to evaluator, with tests written first to give the reader an immediate view of what's coming. I especially liked the fact that the author doesn't cut corners on writing test harness for the code, and doesn't abuse the "<such and such> is left as an exercise for the reader" phrase - that alone is an indicator of thoroughness and no-nonsense approach to writing. Also, be sure to download the "lost chapter" from the link at the end of the book - coming from the C/C++ background, this was an eye opener for me on what a good macro system can do.Looking forward to reading his Compiler book.

Text is out of date. Some examples couldn't be followed for this reason. As the examples build off of each other, this has led to a failure to complete the book.

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.

The most straightforward, step-by-step, and simple learning tool to master lexing, parsing, and evaluating your own programming language. The author has a gift for teaching these complex programming subjects in an easily understandable way. An awesome book indeed!

Great book on creating a compiler and/ or interpreter. I went and learned the Go programming language elsewhere so I could read and understand the book. Keep in mind, even though the book is about writing an interpreter in Go, you can easily apply this to your programming language you want to use like I did.He talks about Pratt parsers to parse expressions which I learned from this book is a good way to parse expressions.

This book is excellent. It is well written, and the code extracts compile and work. That is not something I can say about all the computer books I have had over the years.I am an experienced developer who has read many computer books, including ones on compilers and interpreters. This one is probably at the top of my list of well written computer programming books.This book is different. It takes a practical approach. It uses a very modern language. It also uses modern compiler theory, for example incorporating Vaughn Pratt's innovative algorithm for finite state parsing. The author has clearly put in the necessary effort to get the prose and code properly proof read and edited. The writing style makes the subject interesting, and the code snippets actually work. Each section builds on the previous to iterate on the solution. I took the author's advice and coded along with the book, which means I got good practice in the Go language, and as I made minor mistakes and corrected them, I gained deeper understanding of the material.This book is not really a book on compiler theory. There are other books way better for that. I have read some of those books and this book is a much better read. It keeps you interested and yet covers just enough theory to accomplish the goal stated in the title. It is by a programmer for programmers. There is plenty of code in the book, so it might not be for you if you don't like reading and writing code. I would highly recommend this book for those that do.

It does exactly what it says on the tin! You will learn to write a fully functioning interpreter in Go. I enjoyed reading this book and doing the exercises but I had a few gripes with the tutorial style. For example, you will write a piece of code only to be told it really doesn't do things properly and then have to re-write it to perform as expected. I don't really like this style of learning and would prefer to work with the finished function instead because it's not too hard to get your head round. Another grip was the omission of loops. I would have like to have seen a for loop implemented instead of a hashmap. Overall it's a good book and really shows you that writing an interpreter is really not that hard.

This book positions itself in between a blog post and an academic textbook, but it is more closely related to a blog post in its tone. A lot of the choices in the code don't make sense, but then that's very subjective and with all code there are many ways to do things.If this had gone through a proper edit, it would be a great book.

Really nicely put together and well written in a logical simple style that makes it a pleasure to follow. Thorsten illustrates some of the joy and elegance of programming small clever things, before we got bogged down in frameworks and enterprise jargon. Go is also a perfect choice for the underpinning. Especially like the fact he ignores obvious shortcuts like borrowing a parser generator and shows you how to roll your own.

Der Autor hat einen netten Interpreter geschrieben und auch die Gestaltung des Buches ist für Amazon-Press vulgo Eigenverlag recht gut.Allerdings leidet das Buch daran, dass Th. Ball jede Theorie weiträumig umgeht. Ich habe z.B. im Buch keine formale Syntax der Sprache Monkey gesehen. Dadurch wird die Darstellung teilweise sehr umständlich und auch geschwätzig. N. Wirth hätte den Inhalt des Buches in 10 Seiten dargestellt. Aber gut, Wirth übertreibt es wieder an Kompaktheit. Man kann auch argumentieren: Es gibt genügend andere Bücher die den formalen Teil des Compilerbaus behandeln. Mich hat aber speziell die Umsetzung dieser Konzepte in Go interessiert.Bei der Definition der Sprache "Monkey" ist mir unklar, warum jedes Statement mit dem reservierten Wort "let" beginnt. Es macht den Parser einfacher, aber es ist doch ein sehr unschönes Konstrukt und es geht auch ohne das dauernde "let".Die Bewertung hängt davon ab, welchen Massstab man anlegt. Als ambioniertes Amateurprojekt verdient das Buch mehr Sterne. Mein Massstab war jedoch die vorhandene Compiler bzw. Interpreter Literatur. Da gibt es eindeutig Besseres.