Customer Reviews

Writing Compilers and Interpreters

5 star:		(13)
4 star:		(5)
3 star:		(1)
2 star:		(1)
1 star:		(4)

 

 

There are several things you should know about this book:

1) The book implements a top-down or recursive-descent parser, as opposed to a standard shift-reduce parser. This is *very* important, as lex/yacc, Visual Parse++, and other parsing tools are efficient shift-reduce macines. Thus, the parser isn't really portable. Even so, I did find the the symbol table design that's used by the parser to be critical for what I needed.

2) The printed material is mostly (say 70%) code listings, thus even though the book is a whopping 838 pages, it would be much slimmer with fewer listings. The code is downloadable from the pusblisher's (Wiley) site.

3) The 30% of text and figures that are in the book could be much more insightful. For example, Chapter 11 - the interactive debugger should at least have some description (screenshots perhaps) of how to use the debugger. (Hint, the commands end with a semi-colon.)

4) Even though this book is C++ oriented, it doesn't use standard containers like linked lists, or trees (maps/sets). The classes have pointers in them that makes the class also act as a its own node in a list or whatever. This makes the design much more confusing than it needs to be.

5) The symbol table implementation has heavy circular dependencies. Quite honestly I don't know of a better implementation (yet). This does, however pose a problem if you'll need to extend the design (to use STL containers, to self-serialize, etc.)

The book has been a godsend, but I couldn't honestly let the 4 and 5 star reviews sit unchallenged. If I had known the above sooner, I could have saved quite a few weekends.

I think an Ideal Writing Compilers book would come bundled with a thirty day version of Visual Parse++ or Dr. Parse, and work from there.

The book describes step-by-step how the author would write a compiler for PASCAL. It could do with some more explanations of the logic behind some of the decisions,as it tends to quickly explain what the following C++ code does,before launching into pages of (well written) programming. If you have been tasked to write a specific compiler, then this book is probably what you want to get. If you are wanting to further your knowledge of the art, then you would be better looking at some of the more weighty volumes.

I bought this book in 1996 when I was a CS graduate student. The course text was the traditional "dragon book" which is a complete nigthmare to understand. I read this book in hopes of better understanding how compilers and interpreters are implemented and to this day I feel like I hit the jackpot.

The book focuses primarily on the practical implementation of language interpreters and compilers and includes the code (C++) for a full featured Pascal interpreter (not just a minimal implementation that interprets a few statements). The author walks the reader through each class virtually line by line and presents the material in a way that any intermediate level C++ developer can easily understand.

Notwithstanding the pragmatic focus of this book, it also provides excellent treatment of the theory of compiler design. While it is at least 5 years old, I still keep this book in my library.

This text fully accomplishes its goal of providing a simple
and practical introduction to this subject. Students and
self-taught programmers having difficulty understanding
compiler theory from texts like the "dragon book" will find
this book very useful in getting started.

Working thru all the well written C++ code also provides
excerise in polishing your C++ programming skills, beyond the
first class introducing C++. Though there is a lot of code,
I feel there is significant "added value" in the presentation
of code segments and textual descriptions which helps novices
grasp implementation of the concepts being discussed.

As every author knows, books like all other projects can be
refined further. One enhancement to this book is that
every chapter should include a (small) section dedicated
discussing the theoretical concepts without any reference
to the code. Alternative approaches and advanced concepts
could be mentioned here with a word about using simple
techniques to stay in line with the goal of the book.

This book gives a very detailed discussion of how to write a compiler using C++. As such it could function as a supplementary textbook for a course in compilers or as one for an advanced course in C++. The author describes in detail every step of the way, and it makes interesting and fun reading. Buy it: it is well worth the price.

This book delivers exactly what it promises--a complete step-by-step example of writing 'a compiler'. The book is simply a description of one way to build one compiler (and interpreter, and debugger, and various useful utilities).

The basics are well presented. First a topic is described, then source code is presented and explained. The results of test runs are shown, and then off to the next topic. Advanced topics, such as optimization, are intentially left out.

When a person is ready to read a first book about compilers, this is a good one. All source code developed/described in the book is available on-line.

I used to think you had to be some kind of super human being to write a compiler.Guess what? I was wrong. If you buy this book and you have good c++ programming skills as well as knowledge of data structures(lists,trees etc) you are well on your way.

Ronald is the man!He breaks the code down into small objects and shows all the code with great insight into what the code is doing. Man, this is how to write a book on such a complex topic. Ronald really shows the benefits of OOP.

Now I feel very confident to take on any programming project. I have over come my fears. I can now get more advanced books on the subject.

The author has written a fine book for the experienced C++ programmer who wants to write a compiler or an interpreter. A lot of time will be needed to get through the book, and some knowledge of Pascal. The author takes great care in introducing the elementary concepts of compilers and code is immediately introduced to implement them. Each chapter then builds on the preceding one, and the author attempts to follow the object-oriented paradigm as much as possible. He uses class diagrams to show how a program's classes are defined and related to one another, and uses object diagrams to show how they behave at runtime. His approach here is a simplified version of the one developed by G. Booch, which is used extensively in modern object-oriented design. The reader interested in the theory of compilers should probably read another book alongside this one. Given the time and effort, a very determined reader could sort through all the source code and gain a thorough practical understanding of how to write a compiler or interpreter.

This was really my 'practical compilerbook' winner (bought in 1999), until I discovered in 2004 "Programming Language Processors in Java: Compilers and Interpreters" by David Watt, which I like more.

If you're looking for a theory book about compiler design I would recommend 'Engineering a compiler' by Cooper et al.

This book offers a nice compiler (including x86 code generator and debugger!!), for a simple language.

The problem is that the compiler is written in C++, and if you are more familiar with Java you could better buy the book I recommened above.

An advantage of this book is that it also covers rare topics, such as debugger implementation.

A disadvantage is that this book show a lot of code. Actually, all code is printed in the book (as far as I know). That's why it's a big bibble.

The greatest disadvantage of this book is that it doesn't introduce new concepts. It offers a recursive descent parser (difficult to maintain), instead of much faster table driven parsers, or recursive descent parsers made by a generator (ANTLR).

However, this is a great starter for C++ people new to compiler design. Java people would I recommend to buy the book of Watt as recommended above.

This book provides a detailed explanation on how compilers and interpretors (a high level concept) reads near human language text, and creates byte code that can be interpreted or executed on your system.

Using Pascal as an example, it begins by building a scanner, defining tokens, and reading a text stream. Complete examples allow the audience to either read through the example while reading the explanation, or copy the code into any C compiler for a quick test drive.

The explanations and the level of complexity increase as he reaches further toward building a full compiler, yet stops short of creating a full Pascal compiler. The reason being .. he gives the audience everything they need to complete the job, and let's them figure it out.

Overall, this is a good book for anyone interested in parsing any type of document. There are no drastic jumps or leaps of intuition that need to be made. It provides a good understanding of how to parse other languages like C, Java, HTML, XML, or otherwise.