Customer Reviews

Constructing Language Processors for Little Languages

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

 

 

This is a good, basic, "gateway" book on compiler and interpreter design and implementation. It can easily provide the reader with the basic concepts of this tricky topic in a way that will allow the reader to move on to more complicated materials.

Having taken a compiler construction class in college using "Compilers : Principles, Techniques, and Tools", I can say that this book is much easier to understand and I wish we had spent the first 2-3 weeks of the course covering the material therein.

If you are new to compiler construction or are interested in producing a simple interpreter, this book is for you. If you already consider yourself well read in compiler technology, this book may be of questionable value.

Learning how to build good interpreters and compilers is not easy. For a self-taught programmer such as myself it is a hard road with few lights for the path.

Certainly "Compilers: Principles, Techniques and Tools" (sometimes called the "dragon book") is far too complex for the beginner. You need something else first.

Kaplan has made a good effort, certainly for the beginner at this art I have found nothing better. While Mak's "Writing Compilers and Interpreter's" is in some ways a better book I don't like that he uses a top down parser, rather than a shift-reduce parser and doesn't explain why. Mak also relies too much on C++ and tackles a problem too large (A Pascal compiler)

Kaplan doesn't fall into any of those traps. He explains well all his decisions and uses methods that translate well into almost any language. He also devotes some space to yacc and lex - essential for those of us who want something a little easier than building the entire thing from the ground up. This book does, however, travel a little fast for some. The main failing is that Kaplan chooses a problem (manipulating images) where too much time is spent on things specific to the language and the end tool is not that useful to a lot of people. He also gets too complex too quickly.

This book will reward you with some effort on your part. I'd recommend it for anyone who wants to learn how best to define and build a small language who is prepared to do some work understanding the concepts.

I've recently had the need to understand how lex and yacc work. I bought this book probably back in 1999 or so; it's sat on my book shelf ever since, having only gotten about three chapters into it.

Today I pulled it out for kicks, and was delighted to find chapter eight is all about lex and yacc; the first seven chapters lead the reader through the writing of a simple language parser for a language he calls "IML," or Image Manipulation Language. (Think a small database of meta information about a large collection of image files; the language lets you do various manipulations with those files).

Kaplan's writing style is very personal and conversational; the target audience is working programmers. This is always a great combination for programming books. Since the examples are all in standard C, it will be many more years before this book really becomes outdated. Sadly the code examples are on a floppy that comes with the book, so you better have a floppy drive!

This is a small book. It is practical, containing code for a whole compiler (and interpreter), not just code snippets. You can type as you learn, similar to Brinch Hansen's book "Brinch Hansen on Pascal Compilers." I haven't been paid to advertise Brinch, but I'll repeat myself and say that his compiler book is the best. The main difference between these two books is that Brinch shows how to write code for a more generic compiler (which is better if you want to make an advanced compiler), while the book reviewed here is for Domain Specific Languages (DSLs). It's good to own both books, and neither is costly. They're just old and hard to find.

Little Languages contains some theory, but not too much. Terms like "top-down" "bottom-up", "LL(1)", "context-free", "predictive", "recursive-descent" aren't often used. That said, the theory was more difficult to understand than Brinch. Both authors have used the top-down approach.

The theory in Little Languages involves learning about state-machines, and also uses stacks for handling parentheses. This has made the ideas more difficult. State diagrams aren't required, nor are push-down stacks for parentheses. Both concepts are superfluous here. Plain syntax diagrams do the job fine.

Unlike other top-down interpreter/compiler books, this one has a nice introduction to lex and yacc, the best coverage I've seen in a book that isn't devoted entirely to the subject.

The code presented is written in C, which is old-hat, but so is the book. Despite that, the code is well-presented. I find C a WORM language (Write Once, Read Many), in the sense that when your write code with double-indirection, both you and your readers will be lost if they look at the code in a few month's time.

The book has no coverage of "expressions", unlike every other compiler book I've read. However, the author's code is still similar, creating a similar tree structure and using recursion.

I think most computer languages written are likely to be small languages, the topic of this book, rather than large compilers (which have already been written). So, it was refreshing to read a book devoted to small languages (aka DSLs.)

The only reason I haven't given full-stars is that the book's theory is more complex than need be. Still highly recommended. After reading and writing a compiler, or interpreter, with either this book or Brinch's, using a top-down method, you will be ready to tackle more complex books like the Dragon book.