- Tapa blanda: 265 páginas
- Editor: Thorsten Ball (7 de agosto de 2018)
- Idioma: Inglés
- ISBN-10: 3982016118
- ISBN-13: 978-3982016115
- Valoración media de los clientes: Sé el primero en opinar sobre este producto
- Clasificación en los más vendidos de Amazon: nº20.691 en Libros en idiomas extranjeros (Ver el Top 100 en Libros en idiomas extranjeros)
Writing An Interpreter In Go (Inglés) Tapa blanda – 7 ago 2018
|Nuevo desde||Usado desde|
"Vuelva a intentarlo"
Los clientes que compraron este producto también compraron
Los clientes que vieron este producto también vieron
Descripción del producto
Reseña del editor
Writing An Interpreter In Go - Version 1.5 - Find out more at https://interpreterbook.com
In this book we will create a programming language together. We'll start with 0 lines of code and end up with a fully working interpreter for the Monkey programming language.
Step by step. From tokens to output. All code shown and included. Fully tested.
Buy this book to learn:
- How to build an interpreter for a C-like programming language from scratch
- What a lexer, a parser and an Abstract Syntax Tree (AST) are and how to build your own
- What closures are and how and why they work
- What the Pratt parsing technique and a recursive descent parser is
- What others talk about when they talk about built-in data structures
- What REPL stands for and how to build one
Why this book?
This is the book I wanted to have a year ago. This is the book I couldn't find. I wrote this book for you and me. So why should you buy it? What's different about it, compared to other interpreter or compiler literature?
- Working code is the focus. Code is not just found in the appendix. Code is the main focus of this book.
- It's small! It has around 200 pages of which a great deal are readable, syntax-highlighted, working code.
- The code presented in the book is easy to understand, easy to extend, easy to maintain.
- No 3rd party libraries! You're not left wondering: "But how does tool X do that?" We won't use a tool X. We only use the Go standard library and write everything ourselves.
- Tests! The interpreter we build in the book is fully tested! Sometimes in TDD style, sometimes with the tests written after. You can easily run the tests to experiment with the interpreter and make changes.
This book is for you if you...
- learn by building, love to look under the hood
- love programming and to program for the sake of learning and joy!
- are interested in how your favorite, interpreted programming language works
- never took a compiler course in college
- want to get started with interpreters or compilers…
- ... but don't want to work through a theory-heavy, 800 pages, 4 pounds compiler book as a beginner
- kept screaming "show me the code!" when reading about interpreters and compilers
- always wanted to say: "Holy shit, I built a programming language!"
No es necesario ningún dispositivo Kindle. Descárgate una de las apps de Kindle gratuitas para comenzar a leer libros Kindle en tu smartphone, tablet u ordenador.
Obtén la app gratuita:
Detalles del producto
Si eres el vendedor de este producto, ¿te gustaría sugerir ciertos cambios a través del servicio de atención al vendedor?
Ninguna opinión de cliente
|5 estrellas (0%)|
|4 estrellas (0%)|
|3 estrellas (0%)|
|2 estrellas (0%)|
|1 estrella (0%)|
Valorar este producto
Opiniones de clientes más útiles en Amazon.com
He talks about Pratt parsers to parse expressions which I learned from this book is a good way to parse expressions.
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.
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.