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.
Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required.
Read instantly on your browser with Kindle for Web.
Using your mobile phone camera - scan the code below and download the Kindle app.
Customers who read this book also read
Page 1 of 1 Start overPage 1 of 1
About the author
Follow authors to get new release updates, plus improved recommendations.
Reviews with images
Great coverage of the fundamentals of bytecode generation and execution
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.
Top reviews from the United States
There was a problem filtering reviews right now. Please try again later.
Reviewed in the United States on September 29, 2020
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.
Great coverage of the fundamentals of bytecode generation and execution
Reviewed in the United States on September 29, 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.Reviewed in the United States on September 29, 2020
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 in this review
Reviewed in the United States on April 12, 2020
Reviewed in the United States on January 10, 2020
Reviewed in the United States on March 30, 2021
Top reviews from other countries
Sam Brown
So THAT's how compilers work
Reviewed in the United Kingdom on September 12, 2020