Compilers Books

Programming Language Pragmatics 2nd Edition (PLP2e) is a fantastic book that covers a great deal of information. It starts with explaining lexing and parsing, and then goes into scope, target machine instructions, control flow, data structures, a number of paradigms, and building a runnable program. It touches on pretty much every aspect of computer programming, and with deep and insightful knowledge.

While it's not as specific as some other books (language specific references, compiler construction texts, etc), it is a great beginning and reference for a wide range of topics. The bibliography of this book is incredible. I have marked a large number of papers/books from the bib that I now want to read in full.

The bonus information on the CD is also very good, including all the source code from the book, extra sections, and links to other resources.

This is among my favorite computer science books. I read the first edition straight through from cover to cover, even though I had some prior knowledge of the subject. I have since purchased the second edition, which exceeds the high standards set by the first edition. Scott's book would have made the programming languages course I took as an undergraduate much more enlightening, had it existed at the time.

As a software engineer, I tend to be picky about my books, but this one is very in depth and a good read. You will learn a lot about different programming languages, and why certain languages are better than others for solving different types of prroblems.

Every good programmer should know more than one programming language, that much is almost a consensus. But more than that, every programmer should educate himself about programming languages in general, what they mean and how they work. It's important to know at least the major programming paradigms, because they form the "mental model" of computation that is available to a programmer in a language from that paradigm.

And then it's always illustrative to know about the differences in many common languages, to see where different decisions have been made and what are the consequences. To know that certain legacy languages (e.g. C, Fortran) have features that were not designed because they were the "best" option (for some definition of best), but because the design was constrained by what technology was currently available.

This knowledge is not only required of compiler writers. It should be required of every good programmer. Compiler writers, of course, must know this, and probably in more detail. But Scott's book is a good resource about programming languages, in a level of detail that I believe adequate for all programmers.

There are two main kinds of books on programming languages: they are "survey" and "implementation".

Survey books show how things work in a lot of languages, comparing them along the way. Often the comparison gets down to small details that can affect the meaning, or semantics, of similar programs written in these languages. These books contain one individual chapter for every major topic, and inside such a chapter all languages are compared in relation to the topic. For example, one such chapter covers "subroutines" and then compare a host of different languages on how they implement subroutines.

Implementation books are different: they show how to implement many language features, usually by presenting code for interpreters and compilers. The reader doesn't learn that Ada permits nested subroutines, but instead how nested subroutines really work and how to implement them in a language, for example. A very good book of this kind is "Essentials of Programming Languages" by Friedman, Wand & Haynes.

I normally prefer the implementation books. I'm not really interested if Standard Pascal permits functions to be passed as parameters or not; if I do need to write a Standard Pascal compiler I'll look for a reference manual. I much prefer to know how to implement functions as parameters, and be done with it. Comparing minutiae about extant programming languages can sometimes be very enlightening, and sometimes be mostly dull.

Scott's book, however, really shines because it mixes feature descriptions and implementation details in the presentation. It does the usual routine of comparing a lot of different languages, most of the time the more popular ones like C++ and Java, but it then shows how the implementations differ because of differences in features. The book strikes a good balance between "language design" and "implementation" approaches, although it is clearly slanted towards design, and so more of a traditional "survey" book.

It wins over other survey books by including implementation information about almost every topic, and by the clear writing and style. Also, most survey books concentrate on mainstream imperative languages (nowadays C++, Java, C#) and leave other paradigms to chapters at the end. Scott's book is a bit better in this respect: the presentation often includes Common Lisp, Scheme and Standard ML in the comparisons. There are separate chapters about functional and logic programming too, but considerations about functional programming are spread in the whole book. This is important because paradigms change, and a good programmer must be able to adapt.

It's a good reference for language implementors and good education for most programmers. I look forward to the next editions.

Overall, "Programming Language Pragmatics" (PLP) is a very good book. According to the Preface:

"It aims, quite simply, to be the most comprehensive and accurate languages text available, in a style that is engaging and accessible to the typical undergraduate....

At its core, PLP is a book about how programming languages work. Rather than enumerate the details of many different languages, it focuses on concepts that underlie all the languages the student is likely to encounter, illustrating those concepts with a variety of concrete examples, and exploring the tradeoffs that explain why different languages were designed in different ways."

I'm not knowledgeable enough to pass judgment on "the most comprehensive and accurate" part. But, I'm pretty happy about the book meeting the rest of those goals. I read through the book on my own and have only a few significant gripes:

- Chapters 2 (Programming Language Syntax) and 4 (Semantic Analysis) are tough to get through. They're basically trying to teach enough about Alphabets, Languages, Regular Expressions, Context-Free Grammars, Finite Automata and Push-Down Automata for the reader to understand what the rest of the book is based on. I've read Cohen's Introduction to Computer Theory, which is dedicated solely to this material and I still had some trouble. With an instructor in a class to walk through the things, it should be doable. But, for a person reading the book on his own, ugh.

- All of Section III: Alternative Programming Models, seems to depart from the format of the rest of the book (as noted in the Preface) where the author talks about the concepts and then how the different languages implement them. Instead, he focuses on the languages themselves and almost seems to be trying to cram a primer into his text. Since the section seems to be a special case, it wouldn't be so bad except that the languages covered are a bit out of the mainstream and so that degree of depth gets pretty unreadable at times. Again, with a professor around, things would be better.

- At a more pedagogical level, the author has a tendency to merely explain what his example Figures are doing in general terms. The problem is that a lot of the code/pseudocode involves fairly advanced structures in several languages (many of which most people won't have run across). It would have made things a lot easier if he had walked his way through each of those Figures line-by-line and explained what each line did. Once again, this wouldn't be that much of a problem in a normal teaching environment since a professor could do it.

Other than those three things, this is a very good and readable book. I rate it at four stars out of five.

IMAGINATION AND INSPIRATION COMBINE IN "The Spirit of David" to inspire and motivate the Reader to overcome obstacles which others might consider a severe handicap and give the world their best efforts toward making life rewarding and meaningful for themselves and others. Rewarding and inspirational reading.Even though the going was tough, the people in this book got off their duff and accomplished the seemingly impossible.
Pat Dirkson
Author of "The Ink Patch"
"Don't Let Any Dragons
Get'cha!"

The Spirit of David is a collection of stories that make you literally stand up and cheer! The way these people have faced the Goliaths in their lives makes you realize how majestic the human race can be.

There are many books written to motivate and inspire readers. THE SPIRIT OF DAVID in one such book with a twist. The true stories in THE SPIRIT OF DAVID demonstrate the variety of ways people are challenged in life and how they overcome those obstacles.

The format of twenty-eight short stories makes THE SPIRIT OF DAVID easy to read, succinct and poignant. Each of the various stories is inspiring in its own way. Every short story's author writes his story in a heartfelt, sincere tone. The book's overall style was comforting to read.

The story behind the book is almost as interesting as the stories in the book. THE SPIRIT OF DAVID celebrates the life of David Schumacher, a California entrepreneur, real estate mogul and educator. Nearly blind at birth, Schumacher became totally blind later in life. Schumacher never allowed his disability to deter him from achieving greatness. The first story in the book is written by Schumacher's widow and details his extraordinary life.

Schumacher never stopped giving, even after his death--his widow will donate a portion of the proceeds from the sale of each book to charity.

I recommend this book be on the nightstand of any reader that needs an occasional pick-me-up from the blues. The uplifting stories remind me that others have overcome setbacks and won against the odds.

Thank you so much for "The Story of David". It too has helped me in my everyday life when I think I have obstacles to overcome. I read these inspirational stories and realize life is what we make of it. We all need motivation to never-quit and find that our glass is really "half full". I wish that everyone could read this to understand how to pursue our dreams everyday with love, kindness and heartwarming goals.

The Spirit of David is a compelling book loaded with inspiring stories. They will not only lift your mind but reach your hearts and take you through your future days. Once you have turned the page to the first story you will be wrapped up into each courageous moment throughout every hopeful story. As you read this encouraging book you will find yourself reading the stories over and over again. You may cherish this book and carry it with you on your daily trips. It will constantly remind you of those people who have overcome - winning against all odds. We are all capable of doing that. I see the book as a gem of hope, friendship and care. We are not alone. We are together.

Bought this as a gift for a friend who collects paper money, she loves it says it is one of the bvest gifts she has received this year.

I found this book to be very informative & an important book for any collecter/history buff.

It's been many years since I've had this book. All of my expectations were satisfied. This book has been the "Bible" for US Paper money as long as I can remember. If you want to understand grading, pricing, or just want to learn about an important piece of American history, its worth the money.

This is good book about our money and is very educational.
Well worth the price.

This book has been so helpful in my collecting quests. I spent about an hour in Borders trying to find a book that gives values of modern as well as old currency for ranges up to Unc-63. It provides all the necessary information (such as signatures, series, quantity printed) for almost all bills and has a nice informative section as well. It gives price points that help you place a bid on valuable bills. This helps all collectors, experienced or not. I highly recommend this book.

Many years ago I used this book to build a compiler which generated test cases for a complex real-time system. The result was a syntax-oriented, single-pass, context independent, processor with no restricted variables. It all worked as described in the book. I believe the construction concepts are still valid, mutatis mutandis. Simply disregard the language anachronisms.

Grea

I loved this book and, although very out of date (AED RWord, FORTRAN and so on), I still read bits from time to time. Not a book to buy these days - get one that uses a language that *you* use.

This was one of the best books I read when I was a student 25 years ago. You really understand how to write compilers after reading it. It is invaluable for those who learn programming. I believe it contributed greatly to turning me into a professional programmer. It's a shame that this book is not available any more...

I used this book in my undergraduate studies (Computer Science) at the University of Nigeria, Nsukka. It was very good. The main thing we had against it, back at UNN, was the font used. But once you get used to the fonts the rest becomes easy.

I'm writing reviews of books i read years ago and i fondly remember the late nights listening to music and reading this book. It was my first real programming book and I learned a lot of basic concepts from it that i still use even though now I use C++ and wxWidgets/SDL. It also taught me the that I didn't want to be locked in to just writing for one platform ;-)

I don't know how to program, and I want to know if this book will help me how to program. I have visual basic 5. if anyone can help me, if this book will teach me how to program from the beginning

Look, if you happen to come across this book don't let the version of Visual Basic (5) fool you. This book actually kept me from giving up on programming altogether. I first picked up another Sams Teach Yourself Vb in 21 days and wanted to throw it away, someone recommended this one and I truly am thankful to the Gurewich brothers for writing it. Do yourself a favor and begin your journey in Visual Basic with this book.

This is an excellent starting place. The Teach Yourself series actually does what it claims (the Teach Yourself Visual Basic for Applications book is also a great companion to this one).

Really gets you into the application. If you are like me, though you will get excited and get on tangents within a couple of chapters. I have used this book now for about 1 year (got through everything in about 2 weeks) and still find uses for examples.

I HAVE NEVER HAD ANY PROGRAMMING EXPERIANCE BEFORE THIS BOOK AND WITHIN 2-3 DAYS I COULD WRIGHT MY OWN SMALL PROGRAMMS, THE WAY ITS SET UP YOU CANT GET LOST ITS SO STRAIGHT FORWARD NON OF THIS MUMBO JUMBO THAT YOU NEED A DEGREE JUST TO UNDERSTAND WHAT THERE SAYING NO I RECOMEND THIS BOOK TO ANY ONE WHO WANTS TO LEARN VISUAL BASIC AND BELIEVE ME IT IS POSSIBLE TO LEARN A LOT IN 21 DAYS, I HAVE BEEN LEARNING VISUAL BASIC FOR A YEAR NOW AND I STILL GO BACK TO PICK UP THINGS.

This book is excellent. I wish many more books were like this one. I cannot express how much I enjoyed this book. There are just too many books out there that are just flashy, bulky, in-your-face, and just bloated with fluff. Not this book.

First of all, this book assumes that you know Java. That is rule 1 that many books fail to observe. This book is about wireless Java so it does not waste space teaching you Java. If you want to learn Java, you'll read a book that is written specifically for that - and you'll likely find a great one too. So why redo it in a way that will suffer anyway?

Second, this book gives you useful information, and only useful information. No space is wasted. Every chapter is concise, to the point, and specific. I've never read a book with such a high percentage of useful information. I'll gladly pay about the same price for a 200-page book with 190 useful pages instead of a 1000-page book with 90 useful pages. The presentation is clean, clear, and consistent.

Third, well, the topic is wireless Java, so I'll also tell you that I picked up this book knowing Java but not J2ME, and after reading it I know everything I need to know to writing Java programs using J2ME. I've looked at all the Java wireless books and I truly believe that this is the best one. You'll learn about how J2ME is partitioned, how MIDP fits into CLDC, what parts of J2SE are included and left out, how to write MIDlets and user interfaces, how to work with persistent storage (micro-databases), networking, performance optimization, XML, and security.

The author and his team (because a book does not come to exist by only one person) should be applauded for boldly going against the trend of selling books by weight.

One last note: this is the ONLY book for which I thought even the appendix was useful!

Enjoy it and enjoy trying out J2ME.

Rarely is an early book on an initial release of a still-changing software platform as well-done as this one.

This book delivers exactly what it promises, in a straightforward, down-to-earth, no-nonsense style that's very refreshing in a Java text. It's attractively sized and priced, promises to be useful as a reference long after the first reading, and comprehensively touches on just about all of the major features of the 1.0 MIDP API.

Prospective buyers should be aware, however, that one of the consequences of the aforementioned virtues is that this book is not intended to include or to be a tutorial in Java itself. The presentation presumes that the reader is already comfortable with the Java language and Java technology platforms in general.
In particular, experience with servlets will be required to get some of the network client examples running, and while the author presents a review discussion of the rudiments of HTTP, detailed knowledge of the protocol spec will be rewarded by the ability to make short shrift of the bug that provoked me to a previous negative review of this book (thanks, Jonathan, for sorting out the problem for me).

In addition to thorough coverage of the API and a very good chapter on MIDP code optimization, this book includes what I would characterize as bonus chapters on MIDP-compatible XML parsers and the Legion of the Bouncy Castle's J2ME crypto library. It's not entirely clear to me why these particular topics were chosen (other than because the author has already written a book on Java crypto), but the book would be well worth the investment even without them.

Personally, though, I would have been happier had this space been used to provide some perspective on the relationship between MIDP and other complementary or competing wireless technologies, and how they will integrate to provide a superior experience for users of next-generation wireless devices. Maybe I would be asking for too much, too early in the game.

Anyway, this is a good book that I found very helpful. I hope there will be a second edition when the time comes, and I hope that Apress will post the Jargoneer bugfix so that future readers won't have the frustrating Saturday afternoon that I had trying to deal with it.

This is pretty close to the best book I have ever read on Wireless JAVA. Easy to read. Some of the code is a little tricky to follow. Good code to learn. I would recommend this book to anyone who wants to learn Wireless JAVA. I really enjoyed reading this book. A very good investment.

The latest revolution in Java (the micro revolution) has begun within the release of J2ME. However, the revolution has just started and most of the specification is still being defined within the Java Community Process. The one part of J2ME that is available to developers is the Mobile Information Device Profile (MIDP), the specification for devices such as pagers, mobile phones, and small PDAs. This is the focus of this excellent book by Jonathan Knudsen. After a brief history of J2ME, the author introduces us to MIDlets, which are the applets of Mobile Information Devices. Comparing J2ME with J2SE, the author shows us how to leverage our Java skills to make coding for MIDP devices a breeze. Each step of the way, the author uses working code examples to demonstrate the capabilities of MIDlets. Starting with developing forms, the author explains how to interact with the user and code event handlers. He then demonstrates how to interact with servlets over the Internet using HTTP. Maintaining persistent storage, handling cookies, and programming a game interface are all demonstrated. Performance tuning, which is a critical issue on MIDP devices, is discussed. As long as we are going to be on the cutting edge, a chapter on XML is included. Security and cryptography are critical issues on MIDP devices. Knudsen is the author of "Java Cryptography" and as expected he does an excellent job with these topics. All of this information is well covered in a concise 175 pages. (...)

This is an excellent book. The author does an outstanding job of setting the context by describing the types of devices covered by J2ME and showing the structure of the overall J2ME API. Then he carefully focuses in on the MIDP, the subject of the book, with clear explanations.

This book is not for Java newbies. Knudsen assumes you're already pretty familiar with the core Java classes from J2SE and highlights only the differences that are found in J2ME.

You'll get more out of the book if you take the time to read his sample code and understand how it works. It won't take long (a half hour per sample), and it's well worth the effort.

Not a typical Wrox title, generally these tend deal with specific technology in "no-nonsense" fashion. This book has more theory in it and is not technology specific, you will find it valuable if you program in just any version of Visual Basic .Net and any type of application. Not likely to become obsolete very soon, since basic premises of refactoring will continue to be relevant even in upcoming versions of VB.

Arsenovski has done a great job with this book. It is clearly written, easy to follow and very practical. A great one to keep on the shelf and reference as needed. The free tools that he covers in the book are a bonus! They really help to get you applying what you've learned quickly.

I highly recommend this book for any .NET developer, not just those who use Visual Basic.

I am working with group of developers that came to VB .Net from VB6. Currently we are in process in improving the way things operate using some agile stuff. The overall disposition is pretty good, team has already been formed and things like daily stand-ups, client involvement or short iterations are generally welcomed by all. However, when more technical, code level stuff is discussed, there is more discussion (if not opposition). These folks pack years of experience and will not accept that you can teach them their job just like that. There is no way you can force things like unit testing or refactoring. You have to be able to hold your ground and answer all the questions with some good arguments.
This book gives you in-dept view of refactoring with a lot of practical, code examples. This means that you are well prepared to answer any uncomfortable question. It builds up gradually, so it is easy to follow.
Almost every chapter ends up applying the stuff that was just exposed on a sample application with a lot of code. Surely author spent a decent time on this title. You can download the code and see it progress from chapter to chapter. This gives a great insight since you can read and debug the code at the same time and not just some toy or isolated example.
Here is chapter to chapter break-down of the book.

Chapter 1
Intro chapter, defines refactorings end code smells and explains the kind of baggage VB carries because of its origins. Cool section on misinterpretations, this will prepare you for some tough questions that might come from uninitiated developers or managers.
Explains the importance of writing simple, comprehensible code. For example:
Dim oXMLDom as New DOMDocumet() vs Dim portfolio as new DOMDOcument.
The first statement gives you no idea of what first DOMDocument represents, in second it's the portfolio, and if you know the application context you will know what to expect.

Chapter 2
Teaser chapter but also good single-chapter sample of some typical refactoring work. Captures well typical process of development of VB applications. Starts out with few event-handling methods, ends up with number of domain classes and some inheritance thrown in.

Chapter 3
Chapter on refactoring tools, also gives you some insight of how different tools like refactoring add-ins and unit testing framework fit the big picture of agile development process.

Chapter 4
Intro chapter on application that is used to illustrate refactorings throughout the book. Explains the business case, requirements, lists some use cases. It is important to understand the context of the application to be able to follow-up on refactorings. Also some funny stuff here, like freshman developer that takes pride in copy-paste development.

Chapter 5
In-dept discussion on Static vs. Dynamic and Strong vs. Weak Typing that is rarely dealt with in such depth. This is basically controlled with Option Strict and Option Explicit options. If you program in VB, you must be aware how these work out.

Chapter 6
Chapter on error handling, especially legacy vs. structured error handling. Again, something everyone should know, but rarely explained in such depth. Cool stuff is step by step recipe for converting legacy to structured.

Chapter 7
Deals with some core refactorings like Dead Code Elimination, Scope Reduction etc. It's like cleaning up your code for some serious refactoring stuff.

Chapter 8
First step in structuring your code is getting serious about the problem (or business) domain. Also explains Rename and Safe Rename refactoring, talks about Interface vs. Abstract class, Open-Closed principle etc. some serious OO stuff.

Chapter 9
Some core refactoring stuff. Teaches you how to eliminate duplicated code and why it is the worst thing it can happen to your code. Explains Extract Method and Replace Magic Literal with Symbolic Constant variable. Nice and simple example based on circle geometric shape on how procedural design is transformed to Object Oriented design (Module and Shared method rings a bell?)

Chapter 10
If only method extraction would be as simple in real life... This chapter goes further with method extraction and deals with some common problems like temps.

Chapter 11
Where do objects come from? How you design classes? Some core OO stuff in this chapter, including Extract Class, Move Member (Method or Field) refactorings, smells like Database Driven Design or Data Class, Large Class, OO principles like Single Reasonability Principle etc. Lot of stuff and handful of pages in this chapter.

Chapter 12
Build upon previous chapter. Deals with inheritance, polymorphism, genericity. Explains the difference between class and interface (or implementation vs. interface inheritance), difference between delegation and inheritance and criteria to chose one or another, list some common misuses of inheritance etc. Again, a number of refactorings like Replace Inheritance With Delegation or Extract Interface, Extract Super etc. Some heavyweight OO concepts in this chapter, takes a time to digest.

Chapter 13
Explains what is important when taking a birds-view of software. This chapter is especially important for software architects. Talks a lot about dependencies in software and why you should minimize dependencies in your code.

Chapter 14
Single chapter for huge subject, still a lot of material covered. Design patterns are the most advanced subject in OO, so refactoring your code in order to make use of patterns is in no way child's play. Mostly deals with creational patterns. First mention of Dependency Injection in some VB book I come across. Now taking into account that Unity application block [...] has been released in April, this is really cutting edge stuff!

Chapter 15
Talks about latest VB improvements that come with VB 2008. Starts with XML enhancements like XML literals and then the rest is about LINQ. Explains a LINQ implementation called LINQ-to-SQL. This is first Microsoft Object-Relational Mapper (ORM). Again, cutting edge.

Chapter 16
If you still deal with VB6 code, than you know that migrating to .Net is no easy ride. This chapter explains some techniques that will help you migrate your code and make it .Net in sprit, not leaving it crippled by simple migration that will only make it execute in .Net. VB6 lacks inheritance, generics etc, so you need refactorings to make it VB .Net.

This book has no real competition as far as I know, no book on refactoring or agile for VB .Net developers. The one that come close is Agile Principles, Patterns, and Practices in C# (Robert C. Martin Series) but it is for C# developers and requires a lot higher starting point.
When other books come up, I am sure Professional Refactoring in VB will continue to hold its ground. Highly recommended!

Really great book on refactoring. Although it is based on Visual Basic examples, same advices can be applied to C#, Java or any other OO language.
Martin Fowler finally has a fair partner on my shelf ;).

First of its kind for VB.Net developers. While it does not contain a complete catalogue of all known refactorings, you get a thorough study case used throughout the book, tooling, how to use refactoring for upgrade of legacy VB6 code, a chapter on VB 2008, some important object oriented principles and even short intro on refactoring to patterns.
This book is deep and takes a while to digest. However, it's not about showing off some irrelevant academic knowledge. Author is not afraid to mention "Dependency Injection" or "Single Responsibility Principle" but all of these are demonstrated to be relevant and get illustrated through very practical and real-life examples.

This book is a must have. It uses the dragon book (Compilers: principles, techniques and tools by Aho et.al) as a model but goes a great deal further in its use of examples when explaining the theory. Whenever I had a little trouble understanding the dragon book or wished that more examples were used I turned to Holub's book. The book is extremely well organized. If you want the theory its all there and if you want to just look at code its all there too: thousands of lines of it! After explaining everything you actually get to see how lex and yacc are built (from the ground up) and finally a C compiler. BUY IT NOW!!

This book is more accessible than the Dragon book (Compilers: Principles, Techniques, and Tools) but is less complete. This book presents complete source code for parser generators tools and a C compiler. Even if this book is getting a little bit old and it targets a DOS platform, it should not stop you from acquiring this goldmine of very useful information for anyone interested in compilers for a very reasonable price.

Only a few words. Using this book, I designed a few compilers for testing languages, using Portuguese words and commands. It is yet on the development age, but, without this book it would not be abler at all.

I have had this book for 8 years. It clearly describes compiler theories and examples. It is very useful when I develop very fast parser. (The code generated by lex isn't fast enough.) I am not in the compiler writing business. This book is perfect for me.

Very Long Instruction Word (VLIW) architectures are efficient because they replace costly and power-consuming consuming hardware for detecting and scheduling Instruction-Level Parallelism (ILP); with that functionality supplied by a smart compiler. Furthermore, such smart VLIW compilers and architectures can achieve levels of ILP and power efficiency many times that from hardware schedulers alone. Fisher, Faraboschi and Young's book explains -- skillfully covering software, hardware, theory, application, and business factors -- how such architectures can enable enormous increases in the capabilities of embedded systems.

It's a fabulous read, engagingly styled, with generous research and practical perspective, authoritative with Fisher being responsible for this paradigm of simultaneously engineering the compiler and processor.

Practicing engineers -- both chip architects and embedded system designers -- will find the techniques they will need to use and develop VLIW-based systems. Instructors will value the rare juxtaposition of advanced technology with practical deployment examples, and students will enjoy the unusually engaging and mind-expanding chapter exercises.

That reader has a pretty strong idea, already, of how computers and compilers work, and is ready for a different kind of view. There are a few valuable differences here, compared to most discussions. The first is its emphasis on embedded systems. Loosely speaking, that's any computer that doesn't look like a computer: anti-lock brakes, iPods, microwave ovens, or the processor[s] internal to disk drives. Ignoring the tiny fraction with keyboards and screens, that's pretty much all of computing. The second distinctive feature of this book's viewpoint is it emphasis on the computer as a whole, including cooperating SoC components, operating systems and such, power management, and the instruction set processor itself. Programmers from the Windows/Unix world may be startled by the idea that the instruction set and processor data paths are variables, adjustable to the task at hand. The book's emphasis on close system integration follows the consequences of custom instruction sets out through the simulators, linkers, and compilers that put the processor to work. The authors offer wide-ranging and hard-won insight into optimization techniques, giving glimpses at the scars these project-hardened veterans have picked up along the way.

The book's most distinctive feature, however, is its emphasis on Very Long Instruction Word (VLIW) processors. These come in many flavors. One classic structure comes from TI's DSPs with 8 ALUs controlled in every cycle; standard superscalar and Intel's EPIC are also noted, for contrast and variety. The book is thick (over 600pp) and dense, so no summary can do it justice and still fit here.

The book's personal note is part of its charm. The authors aren't afraid to take on widespread opinoins in their "Flame" sidebars. One in particular struck home for me: the polite diatribe against "smart" assemblers that hide the machine from the people who really need to see it. Amen, brother! My worst experience of that sort was in the 90s-era TI C5x family. It had delayed branches, with two words in the delay slot. You could put either two one-word instructions or one two-word instruction into that slot. After annoyance that you can imagine, I discovered that the compiler was putting a one-word instruction in the branch shadow followed by a two-word instruction. It was executing one and a half instructions in the branch delay, with un-helpful effect. That second instruction was the one the assembler was "helping" with. If the immediate operand had been smaller, it would have been a one-word instruction and would have been fine. The immediate value was too big, though, so the assembler converted that same opcode into a different two-word machine instruction with a larger immediate field - kaboom!

It's a good survey and a good introduction for people who want a wider view of what computing is about. Given the rise of reconfigurable computing, it's also helpful in putting readers in the frame of mind needed for defining their own computers as a matter of course. The breadth of coverage means that, despite the book's mass, its coverage of some topics lacks depth. I can't really fault the authors, though, since there's so much to say and since different readers have such different needs. The depth is there, but it's in the exercises and copious references so readers have to dig into it on their own. This isn't a book for every reader, but it's a helpful compendium for people with many kinds of needs a bit away from what computer science usually offers.

//wiredweird

This is the first technical book that inspired me to read it cover-to-cover in many years. It was well-written, and covered a lot of material. I really liked the breadth of material, and enjoyed reading the lessons from personal experiences. Also, the choice of material validates one of the lessons I learned from my graduate advisor, many years ago, that architecture, software, and applications should all be studied together.

There are two ways to learn more about your country: you can study it directly by travelling around in it, or you can study it indirectly by leaving it. The first method yields facts and insights directly in-context, and the second by contrast.

Our tradition in computer engineering has been to seldom leave our neighborhood. If you want to learn about operating systems, you read an OS book; for multiprocessor systems, you get a book that maps out the MP space.

The book you are holding in your hands can serve admirably in that direct sense. If the technology you are working on is associated with VLIWs or "embedded computing", then clearly it is imperative that you read this book.

But what pleasantly surprised me was how useful this book is, even if one's work is not VLIW-related or has no obvious relationship to embedded computing. I had long felt it was time for Josh Fisher to write his magnum opus on VLIWs, so when I first heard he and his co-authors were working on a book with VLIw in the title, I naturally and enthusiastically assumed this was it. Then I heard the words "embedded computing" were also in the title, and felt considerable uncertainty, having spent most of my professional career in the general-purpose computing arena. I thought embedded computing was interesting, but mostly in the same sense that studying cosmology was interesting: intellectually challenging, but what does it have to do with me?

I should have known better. I don't think Josh Fisher can write boring text. He doesn't know how. (I still consider his "Very Long Instruction Word Architectures and the ELI-512" paper from ISCA-10 to be the finest conference publication I have ever read.) And he seems to have either found like-minded co-authors in Faraboschi and Young, or he taught them well, because Embedded Computing: A VLIW Approach is enthralling in its clarity and exhilarating in its scope. If you are involved in computer system design or programming, you must still read this book, because it will take you to places where the views are spectacular, including those looking over to where you usually live. You don't necessarily have to agree with every point the authors make, but you WILL understand what they are trying to say, and they WILL make you think.

One of the best legacies of the classic Hennessy and Patterson computer architecture textbooks is that the success of their format and style has encouraged more books like theirs. In Embedded Computing: A VLIW Approach, you will find the Pitfalls, Controversies, and occasional Opinion sidebars that made H&P such a joy to read. This kind of technical exposition is like vulcanology done while standing on an active volcano. Look over there, and see molten lava running under a new fissure in the rocks. Feel the heat; it commands your full attention. It's immersive, it's interesting, and it's immediate. If your Vibram soles start melting, it's still worth it. You probably needed new shoes anyway.

I first met Josh when I was a grad student at Carnegie-Mellon in 1982. He spent an hour earnestly describing to me how a sufficiently talented compiler could, in principle, find enough parallelism via a technique he called Trace Scheduling, to keep a really wild looking hardware engine busy. The compiler would speculatively move code all over the place, and then invent more code to fix up what it got wrong. I thought to myself "so THIS is what a lunatic looks like up close. I hope he's not dangerous." Two years later I joined him at Multiflow and learned more in the next five years than I ever have, before or since.

It was an honor to review an early draft of this book, and I was thrilled to be asked to contribute this foreword. As the book makes clear, general-purpose computing has traditionally gotten the glory, while embedded computing quietly keeps our infrastructure running. This is probably just a sign of the immaturity of the general-purpose computing environment (even though we non-embedded types don't like to admit that). With general-purpose computers, people "use the computer" to do something. But with embedded computers, people accomplish some task, blithely and happily unaware that there's a computer involved. Indeed, if they had to be conscious of the computer, their embedded computers would have already failed: antilock brakes and engine controllers, for instance. General-purpose CPUs have a few microarchitecture performance tricks to show their embedded brethren, but the embedded space has much more to teach the general computing folks about the bigger picture: total cost of ownership, who lives in the adjacent neighborhoods, and what they need for all to live harmoniously. This book is a wonderful contribution towards that evolution.

As a researcher in the field, this book was immediately useful to me. Nearly every source code transformation and optimization technique that I'm aware of is present in this book, which often saves sifting through stacks of papers or looking for an elusive reference. If you're looking for a book to teach you the basics of how compilers work, it certainly is not the appropriate place to begin, but if you already have one good book on that then this book will make an excellent companion to it. It was slightly annoying that the book comes with two loose pages, one errata list and another to tape over a page early in the book, but that's what you get with 1st editions. Overall it's very good and the errors are very minor typos as opposed to factual goofs.

Randy Allen and Ken Kennedy are famous for their contributions
to compiler design theory. This book is a clearly written
discussion of the issues involving loop optimization and
dependence analysis. While this book also covers scalar
optimization issues, it is naturally complemented by Steven
S. Muchnick's excellent book "Advanced Compiler Design and
Implementation".

Randy Allen has spent many years implementing a variety of
compilers for supercomputers and hardware design languages.
While Ken Kennedy has published seminal theoretical work on
compiler optimization, he has also been involved in hands on
implementation as well. The experience of these two authors
results in a book which covers the huge body of knowledge in
compiler optimization and provides this knowledge in a
practical form that can be used by software engineers working
on compiler design.

For anyone working on modern compilers that require sophisticated
optimization features, this is an important reference work.
As with Muchnick's book, I have owned this since it was first
published. Rereading it reminds me of what a gem this work is.

Allen and Kennedy (A&K) haven't written your first compiler book. There's nothing about syntax analysis, code generation, instruction scheduling, or intermediate representations. You already know all that part, or you won't get very far in this book. Once you have the basics down, A&K is an irreplaceable reference.

It centers heavily on Fortran - even today, a mainstay of scientific computing and an active area of language development. Today, just as 50 years ago, the language's straightforward structure makes detailed behavioral analysis relatively easy. That's especially true in handling the array computations that soak up so many dozens (as of this writing) of CPU-hours per second on todays largest machines. There's far too much to summarize here, but A&K cover a huge range of processor features, including caches, multiple ALUs, vector units, chaining, and more. C code gets some attention as well, much needed because of the cultural weirdness around array handling in C. In every case, the focus is on the real-world kernels that need the help and on explicit ways of identifying and manipulating those code structures. As a result, the authors disregard the unreal situations that sometimes arise, e.g. in
"while (--n) *a++ = *b++ * *c++;"
Yes, the arrays pointed to by a, b, and c can overlap. But the pointer a can also point to a, b, c, or n, somewhere in its range - and likewise for pointers b and c, or all three. There is essentially no limit to how bad this can get, e.g when n is an alias for a, b, or c. Yes these are rare situations and generally errors - but I've seen on-the-fly code generation in production environments, so even the A&K example isn't as bad as it gets. I admit these to be pathological cases, though, better suited to an 'Obfuscated C' contest than to a compiler textbook.

The real disappointment comes from the section on compilation for Verilog and VHDL, and that disappointment may be a matter of emphasis only. The authors focus heavily on the strangeness of four-valued bits, which exist in Verilog and VHDL simulation, but not in synthesis. I.e., not in what really matters to a deployed application. The real challenge lies in compilation of C or Fortran into gates, a topic that the authors barely skim. That, however, is still a field of research exotica. It should be mentioned in a general book on compilation, as it is here, but awaits a text of its own.

All you processor designers out there should read the title a little differently. You should read this as "Modern Architectures for Optimizing Compilers," but you probably worked that out for yourself. If you have the luxury to define your own memory structure, all that analysis of memory access will give you plenty of ideas for your next ASIP. It will certainly give you lots of ways to quantify the behavior of your target applications, so you'll know just how to get the most MIPS per Mgate, including hard limits on how much hardware paralellism can actually do you any good.

All architects of performance computing systems, hardware or software, need this book. Even application developers can learn better ways to cooperate with the compilers and tools that run their codes. It has my very highest recommendation.

//wiredweird

This book is a very thorough look through all the ways you can extract and use parallelism and data dependencies advantageously in an optimized compiler, depending on your target architecture. As one example, this book contains every imaginable way to deal with arrays and loops and the maddeningly complex data dependancies that can result from their various interminglings. The book is refreshingly easy to read and contains pseudo-code and step-by-step examples everywhere you'd want to see them.