Compilers Books

Ant in Action (Manning)

Steve Loughran, Erik Hatcher

Amazon Price: $31.49 List Price: $49.99 Usually ships in 24 hours By: Manning Publications Amazon Marketplace: 40 new & used starting at $28.46

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Programming -> Java -> General
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> Compilers
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> General

Customer Reviews:
Total reviews: 6 Average rating: 4.5 of 5

More than just Ant 5 out of 5 stars.
8 of 8 people found this review helpful.

A 500+ page book about a build tool. I guess your initial reaction might be the same as mine. Why would we need so much pages to describe a build tool.

Well, after reading "Ant in Action" I concluded, it doesn't need. The book just described much more than just Ant.

The book consists of three parts. The first part is called "Learning Ant". This is basically the build tool part, which describes the basics of Ant and how to use it. Well actually, in part one it already goes a little further to also include unit testing and already some deployment related information.

The second part is called "Applying Ant" and goes well beyond just describing Ant. Chapter 10 describes working in large projects. Chapter 11 talks about managing dependencies and introduces Ivy. Chapter 15 introduces continuous integration and introduces Luntbuild (not sure why the authors not chose to describe CruiseControl, which is absolutely the most used CI tool). Chapter 16 alone would already be a reason to get the book and it talks about automating deployment and introduces a tool called Smartfrog.

The third parts is called "extending ant" and explains how you can extend ant, develop your own tasks and test them using AntUnit. It describes how ant is implemented so that you know how to extend it (and probably how to develop for it further).

When I started my journey through this book, I was a simple Ant user. The authors showed me that there are so much things possible with Ant and also explored the world around Ant. After finishing the book, I felt I have learned so much and it certainly improved my build scripting abilities. An absolute must read.

Editorial Review:

This second edition of a Manning bestseller has been revised and re-titled to fit the 'In Action' Series by Steve Loughran, an Ant project committer. Ant in Action introduces Ant and how to use it for test-driven Java application development. Ant itself is moving to v1.7, a major revision, at the end of 2006 so the timing for the book is right. A single application of increasing complexity, followed throughout the book, shows how an application evolves and how to handle the problems of building and testing. Reviewers have praised the book's coverage of large-projects, Ant's advanced features, and the details and depth of the discussion-all unavailable elsewhere.

This is a major revision with the second half of the book completely new, including:

How to Manage Big projects

Library management

Enterprise Java

Continuous integration

Deployment

Writing new Ant tasks and datatypes

Compilers: Principles, Techniques, and Tools (2nd Edition)

Alfred V. Aho, Monica S. Lam, Ravi Sethi, Jeffrey D. Ullman

Amazon Price: $84.80 List Price: $106.00 Usually ships in 24 hours By: Addison Wesley Amazon Marketplace: 23 new & used starting at $64.99

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Hardware -> Microprocessors & System Design -> Computer Design
Subjects -> Computers & Internet -> Hardware -> Design & Architecture
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> Compiler Design

Customer Reviews:
Total reviews: 67 Average rating: 4.0 of 5

Warmed over ghost of past excellence 3 out of 5 stars.
29 of 31 people found this review helpful.

I spent some serious quality time with the first edition (the "red dragon book"), in three main episodes over the past dozen years: 1) undergraduate compilers class, 2) industry project, and 3) parser generator implementation. During all three episodes, I was disappointed in various ways, though there is no denying that the book contains a wealth of information. As an undergraduate, I found the book somewhat impenetrable. When in industry, I found the book too abstract. When implementing a parser generator, I discovered that the book excludes important research results with regard to LR parser generation. It is the last disappointment that I will focus on.

The book presents parser generation in layers of increasing complexity, from SLR to LR to LALR, where LALR is presented as the penultimate algorithm, though LALR parsers can only handle a subset of the grammars that LR can handle. The justification for this is that the original Knuth LR algorithm is intractable for large grammars. However, an efficient, fully correct, approach for LR parser generation was published in 1977, and on top of that it appears easier to implement than efficient LALR parser generation! The red dragon book's original authors simply cannot have been unaware of this research result, but I suspect that they elected to warm over the "green dragon book" (published in 1977) rather than incorporate the state of the art as of 1986 into the "red dragon book". Now here we are another 20 years later, and as near as I can tell from reading through available online information, the "purple dragon book" is perpetuating this omission. The result of the red dragon book is that we have an entire generation of computer scientists who have been mislead to think that LALR is somehow superior to LR, and the purple dragon book is setting things up for yet another generation to be mislead.

Editorial Review:

This book provides the foundation for understanding the theory and pracitce of compilers. Revised and updated, it reflects the current state of compilation. Every chapter has been completely revised to reflect developments in software engineering, programming languages, and computer architecture that have occurred since 1986, when the last edition published. The authors, recognizing that few readers will ever go on to construct a compiler, retain their focus on the broader set of problems faced in software design and software development. Computer scientists, developers, and aspiring students that want to learn how to build, maintain, and execute a compiler for a major programming language.

C++ in a Nutshell

Ray Lischner

Amazon Price: $26.37 List Price: $39.95 Usually ships in 24 hours By: O'Reilly Media, Inc. Amazon Marketplace: 44 new & used starting at $17.18

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Programming -> C -> General
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> Compilers
Subjects -> Computers & Internet -> Programming -> Software Design, Testing & Engineering -> Object-Oriented Design

Customer Reviews:
Total reviews: 18 Average rating: 4.5 of 5

Editorial Review:

To-the-point, authoritative, no-nonsense solutions have always been a trademark of O'Reilly books. The In a Nutshell books have earned a solid reputation in the field as the well-thumbed references that sit beside the knowledgeable developer's keyboard. "C++ in a Nutshell" lives up to the In a Nutshell promise. "C++ in a Nutshell" is a lean, focused reference that offers practical examples for the most important, most often used, aspects of C++.

"C++ in a Nutshell" packs an enormous amount of information on C++ (and the many libraries used with it) in an indispensable quick reference for those who live in a deadline-driven world and need the facts but not the frills.

The book's language reference is organized first by topic, followed by an alphabetical reference to the language's keywords, complete with syntax summaries and pointers to the topic references. The library reference is organized by header file, and each library chapter and class declaration presents the classes and types in alphabetical order, for easy lookup. Cross-references link related methods, classes, and other key features. This is an ideal resource for students as well as professional programmers.

When you're programming, you need answers to questions about language syntax or parameters required by library routines quickly. What, for example, is the C++ syntax to define an alias for a namespace? Just how do you create and use an iterator to work with the contents of a standard library container? "C++ in a Nutshell" is a concise desktop reference that answers these questions, putting the full power of this flexible, adaptable (but somewhat difficult to master) language at every C++ programmer'sfingertips.

Ant: The Definitive Guide, 2nd Edition

Steven Holzner

Amazon Price: $23.07 List Price: $34.95 Usually ships in 24 hours By: O'Reilly Media, Inc. Amazon Marketplace: 54 new & used starting at $12.00

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Programming -> Java -> General
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> Compilers
Subjects -> Computers & Internet -> Programming -> Software Design, Testing & Engineering -> Object-Oriented Design

Customer Reviews:
Total reviews: 16 Average rating: 4.0 of 5

Editorial Review:

Soon after its launch, Ant succeeded in taking the Java world by storm, becoming the most widely used tool for building applications in Java environments. Like most popular technologies, Ant quickly went through a series of early revision cycles. With each new version, more functionality was added, and more complexity was introduced. Ant evolved from a simple-to-learn build tool into a full-fledged testing and deployment environment. Ant: The Definitive Guide has been reworked, revised and expanded upon to reflect this evolution. It documents the new ways that Ant is being applied, as well as the array of optional tasks that Ant supports. In fact, this new second edition covers everything about this extraordinary build management tool from downloading and installing, to using Ant to test code. Here are just of a few of the features you'll find detailed in this comprehensive, must-have guide:

• Developing conditional builds, and handling error conditions
• Automatically retrieving source code from version control systems
• Using Ant with XML files
• Using Ant with JavaServer Pages to build Web applications
• Using Ant with Enterprise JavaBeans to build enterprise applications

Far exceeding its predecessor in terms of information and detail, Ant: The Definitive Guide, 2nd Edition is a must-have for Java developers unfamiliar with the latest advancements in Ant technology. With this book at your side, you'll soon be up to speed on the premiere tool for cross-platform development. Author Steve Holzner is an award-winning author who s been writing about Java topics since the language first appeared; his books have sold more than 1.5 million copies worldwide.

The Definitive ANTLR Reference: Building Domain-Specific Languages (Pragmatic Programmers)

Terence Parr

Amazon Price: $24.39 List Price: $36.95 Usually ships in 24 hours By: Pragmatic Bookshelf Amazon Marketplace: 33 new & used starting at $20.67

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Programming -> Java -> General
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> Compilers
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> General

Customer Reviews:
Total reviews: 10 Average rating: 4.5 of 5

Editorial Review:

ANTLR v3 is the most powerful, easy-to-use parser generator built to date, and represents the culmination of more than 15 years of research by Terence Parr. This book is the essential reference guide to using this completely rebuilt version of ANTLR, with its amazing new LL(*) parsing technology, tree construction facilities, StringTemplate code generation template engine, and sophisticated ANTLRWorks GUI development environment. Learn to use ANTLR directly from the author!

ANTLR is a parser generator-a program that generates code to translate a specified input language into a nice, tidy data structure. You might think that parser generators are only used to build compilers. But in fact, programmers usually use parser generators to build translators and interpreters for domain-specific languages such as proprietary data formats, common network protocols, text processing languages, and domain-specific programming languages.

Domain-specific languages are important to software development because they represent a more natural, high fidelity, robust, and maintainable means of encoding a problem than simply writing software in a general-purpose language. For example, NASA uses domain-specific command languages for space missions to improve reliability, reduce risk, reduce cost, and increase the speed of development. Even the first Apollo guidance control computer from the 1960s used a domain-specific language that supported vector computations.

This book is the definitive guide to using the completely rebuilt ANTLR v3 and describes all features in detail, including the amazing new LL(*) parsing technology, tree construction facilities, StringTemplate code generation template engine, and sophisticated ANTLRWorks GUI development environment. You'll learn all about ANTLR grammar syntax, resolving grammar ambiguities, parser fault tolerance and error reporting, embedding actions to interpret or translate languages, building intermediate-form trees, extracting information from trees, generating source code, and how to use the ANTLR Java API.

An Introduction to R

W. N. Venables, D. M. Smith

Amazon Price: $13.57 List Price: $19.95 Usually ships in 24 hours By: Network Theory. Amazon Marketplace: 26 new & used starting at $11.95

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> Compilers
Subjects -> Computers & Internet -> Programming -> General
Subjects -> Computers & Internet -> General

Customer Reviews:
Total reviews: 1 Average rating: 4.0 of 5

Excellent... but you already have it on PDF 4 out of 5 stars.
170 of 173 people found this review helpful.

This is an excellent and brief introduction to R. I don't mind having a printed copy. I don't mind having paid the 13 bucks, if the money raised will support free software development. But... I want to warn people who are thinking about getting it: If you use R you already have it. Select the help menu, Manuals, An Introduction to R.

Another book worth considering is the one by Peter Dalgaard, Introductory Statistics with R.

Editorial Review:

This tutorial manual provides a comprehensive introduction to R, a software package for statistical computing and graphics.

R supports a wide range of statistical techniques, and is easily extensible via user-defined functions written in its own language, or using dynamically loaded modules written in C, C++ or Fortran. One of R's strengths is the ease with which well-designed publication-quality plots can be produced.

R is free software, distributed under the terms of the GNU General Public License (GPL). It can be used with GNU/Linux, Unix and Microsoft Windows.

This is a printed copy of the tutorial manual from the R distribution, with additional new examples, notes and corrections added by the publisher (second printing, September 2004). All the money raised from the sale of this book supports the development of free software and documentation.

Advanced Compiler Design and Implementation

Steven Muchnick

Amazon Price: $95.20 List Price: $119.00 Usually ships in 24 hours By: Morgan Kaufmann Amazon Marketplace: 22 new & used starting at $53.99

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> Compiler Design
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> Compilers
Subjects -> Computers & Internet -> Programming -> Software Design, Testing & Engineering -> Software Development

Customer Reviews:
Total reviews: 17 Average rating: 4.5 of 5

Good for seasoned compiler writers, bad for CS students 1 out of 5 stars.
20 of 41 people found this review helpful.

Ok, let's be fair. This book provides a broad coverage of useful optimizations and it will be useful in case you work writing compilers AND have some experience.

However, for learning the concepts, it is a very bad material. At the end you end up confused under a pile of thousands of lines of pseudocode in a weird notation (invented by the author) called "I CAN" (yes you can write a very bad book Mr. Muchnick) instead of reading useful explanations of the topics. The author also assumes that you already know some concepts and that's why he does not explain them as he should. If you want to really understand this book, first review Chapter 10 of the Dragon Book. I thought that the Dragon book was not so good because you have to re read some things in order to fully understand, but with Muchnick's book that is not always possible.

You can also take a look at Morgan's book (unfortunately, out of print) or just read the papers (as the first reviewer suggested). This book is not enough, and sadly, a lot of "teachers" think of it as a kind of "bible" and as a very bad excuse to teach very poorly. Some of them even don't master all the concepts presented there and have to use other books (their "dirty little secret") but they don't tell you which ones and continue praising this bad piece of work. If you are a CS student who really wants to learn, be warned that this book is not for you (it has at least three erratas and still has errors!)

Editorial Review:

Optimizing compilers, which turn human-readable programming languages into the smallest, most efficient machine code possible, are among the most complex pieces of software ever written. Building a compiler is both science and black art and demands an intimate knowledge of data structures, algorithms, high-level programming languages, and processor architectures and their instruction sets. Advanced Compiler Design and Implementation presents a comprehensive and technically up-to-date look at design of real-world compilers for CISC- and RISC-based uni-processor architectures. The author led the advanced compiler design and implementation teams for both Hewlett-Packard's PA-RISC and Sun Microsystems's SPARC processors.

Compilers: Principles, Techniques, & Tools with Gradiance (pkg) (2nd Edition)

Alfred V. Aho, Monica S. Lam, Ravi Sethi, Jeffrey D. Ullman

Amazon Price: $88.32 List Price: $110.40 Usually ships in 24 hours By: Addison Wesley Amazon Marketplace: 19 new & used starting at $88.30

Buy at Amazon.com

Browse similar items by category:
Subjects -> Biographies & Memoirs -> General
Subjects -> Computers & Internet -> Hardware -> Microprocessors & System Design -> Computer Design
Subjects -> Computers & Internet -> Hardware -> Design & Architecture

The Definitive Guide to GCC, Second Edition (Definitive Guide)

William von Hagen

Amazon Price: $44.99 List Price: $49.99 Usually ships in 24 hours By: Apress Amazon Marketplace: 27 new & used starting at $31.00

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> Compilers
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> General
Subjects -> Computers & Internet -> Programming -> Software Design, Testing & Engineering -> Software Development

Customer Reviews:
Total reviews: 8 Average rating: 4.0 of 5

Excellent Reference 5 out of 5 stars.
14 of 15 people found this review helpful.

The Definitive Guide to GCC covers the ways to use the GCC Compiler to compile programs written in C, C++, Fortran, and Java. For each of these languages the author discusses how it is implemented within the GCC compiler. While all the sections of the book are good the parts I found the best were the ones on optimizing and analyzing code as well as troubleshooting GCC. These are very well done sections and cover stuff that is often left out of other texts or not explained nearly as well.

This can be a dauntingly technical book for those unfamiliar with programming and compiling but that is also what makes it so perfect for the experienced user. It is an extensive reference that includes not only the common options but also some of the more obscure options and switches that can be highly useful in the right circumstances.

The Definitive Guide to GCC is typical of the "Definitive Guide" series by Apress and does not disappoint in terms of expertise, detail, and easy to follow explanations. If you want to know the GCC compiler, the details of how to use it, and troubleshoot compilation problems you will find this book to be one of the best resources you can find. The Definitive Guide to GCC is highly recommended.

Editorial Review:

The GNU Compiler Collection (GCC) offers a variety of compilers for different programming languages including C, C++, Java, Fortran, and Ada. The Definitive Guide to GCC, Second Edition has been revised to reflect the changes made in the most recent major GCC release, version 4. Providing in-depth information on GCC's enormous array of features and options, and introducing crucial tools such as autoconf, gprof, and libtool, this book functions as both a guide and reference.

This book goes well beyond a general introduction to GCC and covers key programming techniques such as profiling and optimization that, when used in conjunction with GCCs advanced features, can greatly improve application performance. This second edition will prove to be an invaluable resource, whether youre a student seeking familiarity with this crucial tool or an expert who uses GCC on a daily basis.

Compiler Construction: Principles and Practice

Kenneth C. Louden

Amazon Price: $110.36 List Price: $137.95 Usually ships in 24 hours By: Course Technology Amazon Marketplace: 38 new & used starting at $39.00

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> Compilers
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> General
Subjects -> Computers & Internet -> Programming -> General

Customer Reviews:
Total reviews: 15 Average rating: 4.5 of 5

Great book on a tough subject 5 out of 5 stars.
8 of 8 people found this review helpful.

I am studying for an M.S in software construction/engineering and this book was used for a compiler course. This review is written from my perspective as a student required to understand the information.

The language: The book is written in a clear and frindly "student"-friendly tone. It is actually like the author understands that I am a student and seeing this subject for the first time. The language is straightforward and not over-complex as I have seen it in other books used by instructors.

The structure: As a student i liked the content of the exercises a great deal. They kept focus on things which had been discussed earlier and this is always a good thing. I was able to keep pace with the reading and to follow the course at the same time - this is quite a feat (though maybe i just pulled myself together this time).

Content: It should be no problem for any instructor to plan the teaching using this book. The first chapters introduces compilers and the idea of simple text-recognition using regular expressions and finite automatas and moves on from there by introducing the BNF notation to write context-free grammers. Three chapters explains the essence of CF grammers and top-down and bottom-up parsers in a clear and friendly way.

The book uses the C language to show programming examples. Personally i had not problems but some might feel that the use of pseudo-code would be more appropiate. The book describes the construction of a simple compiler (written in C) for a simple programming language. C or pseudo-code - i like this way of doing a real example which is followed all the way through the book. The entire C source-code for this compiler is presented in the back of the book and used as reference through the chapters.

But - have you never seen the C programming language before, perhaps another book was better. It tries to keep focus on the clean understanding on the theory of parsers, semantic analysis and also later on code optimization. How to program compilers in an object oriented manner is not described, which i believe is okay since it would move the focus away from what is important here. There are books with focus on implementation of compilers in Java for instance, which could be a better choice if you are not a C programmer.

All in all - a good compiler book for students if the instructor teaches by the structure of the book and uses the exercises in class. But it can also be used for self-study.

Editorial Review:

Compiler Construction: Principles and Practice features a comprehensive, hands-on case study project for constructing an actual, working compiler.