Customer Reviews

Modern Compiler Implementation in ML

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

 

 

This book covers a remarkably broad territory of compiler issues, with a good balance of clarity and depth. It spends long enough on each topic to work through examples of functioning code, but doesn't dwell on any for so long that the reader loses interest. A decent set of variations on language design, runtime organization, and machine architecture are also discussed and implemented.

An important caveat is that readers ought to know some dialect of ML. If not, this book does not teach it; there are alternative renditions of the same text in C and Java, but I have not read them. Apparently many reviewers find those confusing. The java rendition, for example, has many angry reviewers. Possibly disgruntled students who had a hard time with their coursework, possibly people with valid complaints about the text.

All I can say is that I quite enjoyed it, and return to it regularly for its clear presentation, when working with related algorithms.

Appel explains the structure of a compiler in a very clear and precise fashion, including a lot of quite modern techniques. *However* it is only clear and precise if you have a rough high-level understanding of compilers and a good knowledge of ML beforehand. (If you understand one of the two, it is an excellent book for learning the other but you will need to do some thinking for yourself.)

If you're looking to learn about compilers from the very beginning, buy something else (I liked "Crafting A Compiler" as a starting point). If you're wanting to get a lot more precise about the way you build compilers, buy this book.

I love this book. Having experimented with compiler construction for some time (though never seriously), and being a long-time ML user, Modern Compiler Implementation in ML was the perfect companion to my compiler-construction project. I largely ignored the "Tiger" language described in the book - I had my own ideas about what I wanted to create. Relying on the book to give you code for a whole compiler is asking far too much. The general concepts are explained, and then reinforced with sample code. I suspect the people who have complained bitterly about this book are actually just looking for a source code print out.

All in all, very worthwhile. Read a chapter, try to implement the concepts, and then either re-read the same chapter, or move on.

This book aims at teaching the reader how to write compilers and interpreters. Compared to other books (most notably the Dragon book - Aho, Sethi & Ullman: Compilers - Principles, Techniques and Tools) the structure and organization of the compiler he teaches are better and more in sync with modern compiler research. So although ML is not a language that is used much in practice it is well choosen for teaching compilers.

The first part of the book is intended for undergraduate Computer Science university student and the second part is for graduate students. I have only read the first part and browsed the second part. The first part is founded on the development of a compiler - the Tiger compiler - and that is the main flaw of the book. The Tiger compiler is fairly advanced and it is built up one phase at the time (see the chapter headings in the synopsis). A undergraduate reader who has never read anything about compiler design before will be very confused. The book is good in the way that it presents many good compiler design ideas and I learned some from it, but for me it was not the first book on compiler. I just think that the first part of the book has too steep a learning curve - even if you are proficient with ML, which is an absolute must. Recommended for serious readers who already know something about compiler construction before reading it. For other people I recommend the older but somewhat outdated book: Aho, Sethi & Ullman: Compilers - Principles, Techniques and Tools.

Appel very clearly describes, step by step, the implementation of a compiler, and explains as well the reasons why ML is a good language to use. If you don't like ML (which is, incidentally, a "real language"), there are Java and C versions of the book.

This book merits four stars: it covers lots of relevent subjects and tackles them to a good depth.
The book is about writing the compiler in ML. That's where I feel the book fails to shine: the design stays shallow. Arguably, high abstraction would have been hard to write about.

The book is very clear, well written and the author guides the reader with simplicity through all the steps required to implement a compiler. The code in ML to implement the most important routines is given with complete explanations.

For the other side the writing style is not enlightening, I did not fall in love of this book, but it is an excellent book for learning and understand.

This book has a lot of valuable information with regard to the construction of a compiler, that fact is overshadowed by the amazingly poor editting.

This is supposedly the "first edition reprint with corrections", but it seems like the vast majority of errors are yet to be corrected.

When you write a text, the idea is to convey some sort of information. This text did nothing of the sort. Often the text is highly ambigious. The code the text gives is hard to understand, and if you are trying to implement a compiler while reading the text, prepare for a nightmare's worth of problems. Any type of implementation related to this text is a complete joke. Be prepared to waste a lot of time trying to figure out what the author should have said or said in a way that is very confusing. In addition to implementation part of the text being laughable, the theory portion is equally bad. Answering simple questions on the reading is very difficult due to the poor writing. I can think of no other book in which I have put so much time, and have gotten such little information.

This book is a textbook that forces you to work on a toy language called Tiger, then take you step by step thru the Lexer, Parser, Semantic Analyzer ... That is good organization; problem is, it purposely omits a lot of details so you have to burn a lot of your time trying to figure out what exactly **he wants** to have in the implementation. That is bad because it can get exceedingly hard, and as what other readers have said, it is very hard to understand what he is trying to say.

Basically, don't buy the book. Go look for something of commercial worth. This book will drive you crazy and make you lose your interest in compilers. The author is making the subject much harder than it actually should be.

If you are a university professor thinking about using this book as a textbook, please spare the souls of your students and rather come up with something reasonably easy to understand. Please. Really. I'm serious.

Ok, I hope I have shed some light for the potential buyers so they'll not buy something to frustrate themselves (horribly).

(Best thing is, he doesn't give you the model solutions to his projects, so you'll be forced to write his programs or give up halfway, no other choices. Not good at all)