Compilers: Principles, Techniques, and Tools

Customer Reviews:

The best for getting the theoretical foundation of compilers.......2007-06-13

This is the classical reference book for compiler design. This is not an easy text because of its heavy use of mathematical notation and the algorithms are presented only in pseudo code but you will not find a more complete collection of compiler related algorithms than in this book.

Warmed over ghost of past excellence.......2007-05-19

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.

The new cover is awesome! Long live the Purple Dragon!.......2007-05-04

The CGI cover looks great! I only wish it stretched along the spine of the book like in the previous editions.

Useful book.......2007-02-20

I'm a computer engineering student and I purchased the book for my programming languages and compilers course. At present I still haven't completed the course, but I've already found this book pretty useful so far. The concepts are clearly and well explained, so that I could better understand some points that I found rather obscure during the lessons. It's being of great help, so I'm very satisfied of this purchase.

Great book but...........2007-02-15

This is the numero uno among compiler books. But whoever designed the new cover out to be have their sketch pens stuffed down their throat. Why change the cover! The previous book was called the dragon book and was a red dragon. No one ever changed Feynman's lecture books by painting the cover blue, did they? Addison Wesley should take their new edition cover design and stuff it.

Average customer rating:

Great book!
Great Study resource
Excelente libro para el autoestudio
I CAN'T STAND LIBERAL FEMINISTS
Great Resource

CISSP All-in-One Exam Guide
Shon Harris
Manufacturer: Osborne/McGraw-Hill
ProductGroup: Book
Binding: Hardcover

General | Certification Central | Computers & Internet | Subjects | Books

Network Security | Networking | Computers & Internet | Subjects | Books

General | Computers & Internet | Subjects | Books

Look Inside Business Books | Trip | Specialty Stores | Books

jp-unknown1 | Specialty Stores | Books

All Titles | Qualifying Textbooks - Fall 2007 | Stores | Books

Business & Investing | Qualifying Textbooks - Fall 2007 | Stores | Books

Computers & Internet | Qualifying Textbooks - Fall 2007 | Stores | Books
Similar Items:

Official (ISC)2 Guide to the CISSP Exam
Official (ISC)2 Guide to the CISSP CBK ((Isc)2 Press Series)
CISSP For Dummies (For Dummies (Computer/Tech))
Mike Meyers' CISSP(R) Certification Passport
The CISSP Prep Guide: Gold Edition

ASIN: 0072193530

Book Description

All-in-One is all you need! This authoritative reference offers complete coverage of all material on the Certified Information Systems Security Practitioner (CISSP) exam. You'll find exam objectives at the beginning of each chapter, helpful exam tips, end-of-chapter practice questions, and photographs and illustrations. The bonus CD-ROM contains practice tests and hundreds of questions. This comprehensive guide not only helps you pass this challenging certification exam, but will also serve as an invaluable on-the-job reference.

Customer Reviews:

Great book!.......2007-10-04

This book was excellent in helping me study for the CISSP exam. Good luck.

Great Study resource.......2007-09-25

I just passed the test. I used the Passport, this book, and the Official Guide to the (ISC)2 CBK to study along with practice tests, etc. I thought this was the best study guide out of them. The CBK guide gives more information on the various topics but this gives you a lot of the information you need and I would highly recommend anyone taking the exam to read this book. The Passport was also useful as a brief study guide. It gives a good overview to read first and to read through again to refresh for the test. The practice questions on the CD were also very helpful in preparation. I have never been disappointed with any of the books in the All in One series that i have read.

Excelente libro para el autoestudio.......2007-09-11

Para preparar el examen CISSP es el mejor apoyo con el que puedes contar, este libro explica en un lenguaje simple y directo, a diferencia de otros libros del mercado.
Recomiendo leer este libro a todas las persona que quieren obtener la certificación.

I CAN'T STAND LIBERAL FEMINISTS.......2007-09-08

If you're like me and annoyed by morons that can't keep their mouths shut about politics (ya know, the kind of people that think everyone wants to hear their liberal ranting and complaining "I hate all men", feminist whining) you may NOT want to venture into this book.

If you read quite a few of the following reviews, you'll find MANY others that tried to warn me about this FEMINIST author NOT being able to keep her mouth shut about politics and hatred of men while YOU "attempt" to learn and/or prepare to take the CISSP, this liberal femy is sounding off throughout the book.

This is why I can't stand liberals (especially liberal feminist women). I picture the author with very short hair, wearing all black, sitting at a Mac, typing her feminist book while sipping Starbucks she picked up in her VW.

The world would be such a better place if these types could CONTROL themselves enough to leave their politics at home, especially when the subject at hand is IT Security.

Great Resource .......2007-08-22

I took the CISSP exam on August 12, 2007 and just received word on yesterday that I've passed. I can't express enough how important this book was in helping me prepare for the exam. This book was my primary resource for studying for the exam along with www.cccure.org. I also took a week long class which kind of helped. The reason I say 'kind of' is because I had pretty much read the book and the class was more of a review for me. I think that between this book and www.cccure.org the exam can be passed. Great resource for the exam.

Structure and Interpretation of Computer Programs - 2nd Edition (MIT Electrical Engineering and Computer Science)

Average customer rating:

Mind-changing
from a student who use the book for a course
A Computer Science grand tour
Great Texbook
This should be on your bookshelf

Structure and Interpretation of Computer Programs - 2nd Edition (MIT Electrical Engineering and Computer Science)
Harold Abelson , and Gerald Jay Sussman
Manufacturer: The MIT Press
ProductGroup: Book
Binding: Hardcover

General | Programming | Computers & Internet | Subjects | Books

General | Computers & Internet | Subjects | Books

General | Databases | Computers & Internet | Subjects | Books

Programming Languages | Computer Science & Information Systems | New & Used Textbooks | Stores | Books

All Titles | Qualifying Textbooks - Fall 2007 | Stores | Books

Computers & Internet | Qualifying Textbooks - Fall 2007 | Stores | Books

Professional | Qualifying Textbooks - Fall 2007 | Stores | Books

Look Inside Computer Books | Trip | Specialty Stores | Books
Similar Items:

Instructor's Manual t/a Structure and Interpretation of Computer Programs - 2nd Edition
The Little Schemer - 4th Edition
Simply Scheme - 2nd Edition: Introducing Computer Science
Practical Common Lisp
ANSI Common LISP

ASIN: 0262011530

Amazon.com

Abelson and Sussman's classic Structure and Interpretation of Computer Programs teaches readers how to program by employing the tools of abstraction and modularity. The authors' central philosophy is that programming is the task of breaking large problems into small ones. The book spends a great deal of time considering both this decomposition and the process of knitting the smaller pieces back together.

The authors employ this philosophy in their writing technique. The text asks the broad question "What is programming?" Having come to the conclusion that programming consists of procedures and data, the authors set off to explore the related questions of "What is data?" and "What is a procedure?"

The authors build up the simple notion of a procedure to dizzying complexity. The discussion culminates in the description of the code behind the programming language Scheme. The authors finish with examples of how to implement some of the book's concepts on a register machine. Through this journey, the reader not only learns how to program, but also how to think about programming.

Book Description

Structure and Interpretation of Computer Programs has had a dramatic impact on computer science curricula over the past decade. This long-awaited revision contains changes throughout the text.

There are new implementations of most of the major programming systems in the book, including the interpreters and compilers, and the authors have incorporated many small changes that reflect their experience teaching the course at MIT since the first edition was published.

A new theme has been introduced that emphasizes the central role played by different approaches to dealing with time in computational models: objects with state, concurrent programming, functional programming and lazy evaluation, and nondeterministic programming. There are new example sections on higher-order procedures in graphics and on applications of stream processing in numerical programming, and many new exercises.

In addition, all the programs have been reworked to run in any Scheme implementation that adheres to the IEEE standard.

Customer Reviews:

Mind-changing.......2007-07-16

This is the best book on programming I have ever met in my life and, most probably, will ever meet.
It not only surprised me and made me think "Oh my god, how come I didn't think this way/about these so incredibly important things before?" dozens of times in every single chapter during every of my 3(in a row) readings of it but it actually changed the way I think about programs and the way I write them.
The authors have a perfect sense of balance between complexity and importance: they never skip important things silently and they never dig too deep into dull subtleties, instead they point out the really meaningful points and either invent a solution before the reader's eyes or give clues that inspire the reader to work out the solution himself.

The book does not teach most of the basic algorithms and data structures, like quicksort of graph path finding (except for several examples that fit well for the purpose of a particular chapter), it is not a programming reference: it is a manual on methods of computation: exactly what the title says. So, in case you have a pragmatic problem you can't just take the book and find a solution: I guess this is the reason for low ratings. But if you read the book thoroughly, you will definitely become an order of magnitude better programmer and that is much more important than knowing concrete algorithms.

I also extremely highly recommend the same-named video course by the same authors at http://swiss.csail.mit.edu/classes/6.001/abelson-sussman-lectures/ : I first was intrigued and shocked with it and only afterwards saw and immediately bought the book. It is a pity I have not yet had time to watch all the lectures (I watched about a half).

from a student who use the book for a course .......2007-05-04

I'm an undergrad who is currently taking an introductory class in C.S using the book as the primary textbook (actually, the only textbook). Sadly, I'm taking it with another class in computer architecture with heavy emphasis on system programming (a la C, MIPS). Like one of the reviewers having pointed out, the excessive zeal of pedantic and theoretical C.S has left the students clueless about the connection between reality and fundamental ideas presented in the book. The authors enforces a grand vision of solving problems independent of programming language. Sadly, this is not the case in practice (I have been trying to port some algorithms in the book into C, oh boy, what a frustrating experience). This vision has left me a very bad impression on Scheme (a good-for-nothing language invented by geeks to impress other geeks).

Some people have said they liked the book. At the beginning of semester. I liked the book too, since programming in functional style is completely new to me (who major in C.S wouldn't delight at learning new thing). HOWEVER, the more I delved into the book while taking a computer architecture course at the same time (in which I have to design a complete 8-bit CPU from ground up, as well as doing a lot of low-level programming), the more I feel there are some fundamental issues with using Scheme (or any other functional languages for that matter) as a tool to interpret and design machines and programs. It just struck me as very odd to design a computer "recursively". How ironic that the book is called "STRUCTURE and INTERPRETATION of computer programs".

I agree with some reviewers in here who bashed C in favor of Scheme. C is not a very good language, but C deserves praises. There are reasons why it has been around forever (both in academic and in industry), and at this rate, I don't see how any functional languages would emerge out of academics as replacement for C. The authors in book braggs that only Fortran has been surviving longer than Scheme, but besides surviving in the this textbook (which has been pushed down my throat by my school), I haven't seen Scheme anywhere else.

This textbook reminds me of the Feynman series in Physics. A series which everyone talks about, but when it comes to reality, it's just best used as a supplementary to look up for reference and self-congratulate as being "smart" rather than the one used to teach and learn from.

A Computer Science grand tour.......2007-03-17

I discovered this text, I believe, while browsing The Aerospace Corp Library in '90. I was immediately taken with it, wishing my own undergraduate program in CS had incorporated its use. The first two chapters on procedural and data abstraction are much better CS preparation than learning Java or C++ or Ada or Pascal. Abstraction and specificiation in software development are absolutely necessary if software "art" is ever to become a "science."

I used this text last year to teach a one year introduction to computer science to some rather advanced homeschooled high school students. Scheme is a much better choice for a teaching language than C++ or Java. There is no need to deal with memory management issues as with C++ and the development model is simpler than with Java. And scheme makes many things easier to achieve than with other languages: higher-order procedures (chapter 1) and hierarchical data (chapter 2).

For my own enjoyment and personal enrichment I have used chapters 4 and 5 as a basis for my own explicit control evaluator for scheme in C++.

A classic. Every CS graduate should do remedial work now and read this text, if they have not done so already.

Great Texbook.......2007-03-15

I purchased this texbook for my first computer class since it was required. It's a great book, but I'm glad we did not cover it entirely. Too much material, and Scheme is not that popular of a language. Price was right though!

This should be on your bookshelf.......2007-03-02

This is a 'must have' book for anyone wishing to practice the craft of programming. It is enigmatic in that it requires little background in programming, but leads swiftly and easily into non-trivial concepts. Of course one must do the exercises, which are varied and practical, the most they ask of the reader is that they understand basic mathematics of Leibniz and Newton. This book will not teach you a collection of tricks, it will give you a way to think about programming. There are a set of lectures by Abelson and Sussman based on the book available at no cost on the Web. Even though they were produced over a decade ago they are well worth watching, and add an interesting flavour to the text. All the software you need to use this text is available for free for a number of platforms. If you are an experienced programmer this is a fun read, if your intention is to learn the art of computer programming, start with SICP, and add Knuth to your bookshelf for reference.

Average customer rating:

Depends on what you want
If you are a beginner...Do not buy it
A great starter guide to writing a compiler
Terrible for Starters
Super compiler text!

Engineering a Compiler
Keith Cooper , and Linda Torczon
Manufacturer: Morgan Kaufmann
ProductGroup: Book
Binding: Hardcover

General | Architecture | Professional & Technical | Subjects | Books

General | Hardware | Computers & Internet | Subjects | Books

Design & Architecture | Hardware | Computers & Internet | Subjects | Books

Systems Analysis & Design | Computer Science | Computers & Internet | Subjects | Books

General | Computers & Internet | Subjects | Books

General & Reference | Technology | Science | Subjects | Books

General | Arts & Photography | Subjects | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

Look Inside Science Books | Trip | Specialty Stores | Books

All Amazon Upgrade | Amazon Upgrade | Stores | Books

Arts & Photography | Amazon Upgrade | Stores | Books

Computers & Internet | Amazon Upgrade | Stores | Books

Professional & Technical | Amazon Upgrade | Stores | Books

Science | Amazon Upgrade | Stores | Books

All Titles | Qualifying Textbooks - Fall 2007 | Stores | Books

Arts & Photography | Qualifying Textbooks - Fall 2007 | Stores | Books

Computers & Internet | Qualifying Textbooks - Fall 2007 | Stores | Books

Professional | Qualifying Textbooks - Fall 2007 | Stores | Books

Science | Qualifying Textbooks - Fall 2007 | Stores | Books
Similar Items:

Programming Language Pragmatics, Second Edition
Compilers: Principles, Techniques, and Tools (2nd Edition)
Advanced Compiler Design and Implementation
lex & yacc
Optimizing Compilers for Modern Architectures: A Dependence-based Approach

ASIN: 155860698X

Book Description

The proliferation of processors, environments, and constraints on systems has cast compiler technology into a wider variety of settings, changing the compiler and compiler writer's role. No longer is execution speed the sole criterion for judging compiled code. Today, code might be judged on how small it is, how much power it consumes, how well it compresses, or how many page faults it generates. In this evolving environment, the task of building a successful compiler relies upon the compiler writer's ability to balance and blend algorithms, engineering insights, and careful planning. Today's compiler writer must choose a path through a design space that is filled with diverse alternatives, each with distinct costs, advantages, and complexities.

Engineering a Compiler explores this design space by presenting some of the ways these problems have been solved, and the constraints that made each of those solutions attractive. By understanding the parameters of the problem and their impact on compiler design, the authors hope to convey both the depth of the problems and the breadth of possible solutions. Their goal is to cover a broad enough selection of material to show readers that real tradeoffs exist, and that the impact of those choices can be both subtle and far-reaching.

Authors Keith Cooper and Linda Torczon convey both the art and the science of compiler construction and show best practice algorithms for the major passes of a compiler. Their text re-balances the curriculum for an introductory course in compiler construction to reflect the issues that arise in current practice.

·Focuses on the back end of the compilerreflecting the focus of research and development over the last decade.
·Uses the well-developed theory from scanning and parsing to introduce concepts that play a critical role in optimization and code generation.
·Introduces the student to optimization through data-flow analysis, SSA form, and a selection of scalar optimizations.
·Builds on this background to teach modern methods in code generation: instruction selection, instruction scheduling, and register allocation.
·Presents examples in several different programming languages in order to best illustrate the concept.
·Provides end-of-chapter exercises, with on-line solutions available to instructors.

Customer Reviews:

Depends on what you want.......2007-06-12

What it is: A great introduction to basic concepts in contemporary compilers.
What it's not: A handbook for someone thrown in at the deep end of commercial compiler development.

I can imagine a very good one-term course in compiler construction built around this text. After a brief introduction, it gets immediately into the classic topics of lexical scanning, parsing, and syntax analysis. These three chapters help any beginner understand the multiple levels of processing, from the character level, up through reorganizing grammars for practical parsing and table-driven techniques, to the lower levels of sematic analysis. This includes a very brief discussion of type systems and type inference - less than 20 pages, on a topic that whole books devote themselves to. These 200 pages typify what you'll see in the rest of the book: a lot of attention paid to lexical analysis, a problem largely eliminated by automated tools (lex and yacc being the best known), and thin mention of the harder problems that differ significantly across languages and applications of languages.

Chapter 5 addresses the critical issue of intermediate representation, the data structures that represent the program during analysis, optimization, and code generation. Chapter 6 is titled "The Procedure Abstraction." It deals with much more than its name suggests, including procedure activation records (generalizations of stack frames), parameter passing, stack management, symbol visibility and scoping, and scraps of symbol table organization - important stuff, but hard to understand as "procedure abstaction." The next chapter deals with "Code Shape," a grab-bag including value representations, arrays and strings, control constructs, and procedures (again). It also presents a very few pages, at the end, on object oriented language - hardly enough to scratch the surface, let alone build competence. And, for lack of a better place to stick them, I would have expected support for parallelism and exceptions to appear here, but this book seems to omit the topics altogether.

Code analysis and optimization appear in chapters 8-10. That includes a competent introduction to static single assignment notation, a staple of current compiler technology mentioned earlier, in the section on intermediate representation. This covers a range of basics, but omits all significant mention of arrays, the workhorses of performance computing. Chapters 11-13 introduce the basics of instruction selection, scheduling, and register allocation. Although it mentions some hardware effects, like out-of-order execution in superscalar architecture, discussion stays close the instruction sets of popular processors. As a result, it omits mention of SIMD, VLIW, DSP, and more exotic architectures, the ones most in need of good code generation. Compiler-specific support libraries, e.g. the kind that make up for lack of hardware divide instructions, should have appeared somewhere around here, but are oddly absent.

The authors present an adequate introduction for the beginner, someone who's still not sure what a hash table is (see appendix B). It introduces many basic topics, but doesn't go into a lot of depth in any of them. The student who finishes this book will understand most major issues of classical compiler construction. I just can't see a serious, working competence coming out of this text, though. I give it four stars as an academic introduction, but a lot less for anyone with immediate problems to solve.

-- wiredweird

If you are a beginner...Do not buy it .......2007-01-01

I read this book and really did not like it. It is a nightmare for any one new to compilers. It is difficult to read with more emphesis on the backend of the compiler.

The following texts are much better for a beginner:

1. Louden's Compiler construction --> the best text for a beginner.

2. the Dragon book

A great starter guide to writing a compiler.......2005-06-10

I recently used this book to supplement the Dragon book in a Compilers course. I found this book so much easier to read and understand. They do a great job of laying out the basics and introducing you to compiler design.

I also liked how they seemed to keep an open mind about which intermediate representation is best to use. They discuss the pros and cons of graphical IRs vs Linear IRs, and let you decide which best fits your needs.

Their open mindedness ended when it came to optimization though. I got the impression that the authors consider SSA (static single assignment) form to be the silver bullet of optimization. Almost all of the optimizations they discuss in this book rely on your IR being in SSA form! I agree that SSA form does indeed make many optimizations much easier, but there is a very high initial cost involved in converting to and from SSA form. In there defense they spend almost an entire chapter on how to do these conversions.

So to sum up, this book does a great job of introducing you to compiler design. It is well written and very easy to understand. It also does a good job of discussing different compiler design choices and their pros and cons. The only short coming of this book is that the entire optimization discussion is revolves around SSA form.

Terrible for Starters.......2005-03-22

This book was the textbook for an undergraduate course on compilers. Let me make it short: I never read it after reading the first chapter. The authors may be top experts on compilers but they shouldn't be writing books. Another book written in 1982 (compilers, principles, techniques and tools) saved my life for this class. If you are a beginner "do not buy this book".

Super compiler text!.......2005-02-22

This is really a super compiler text. It is also one of the most recent compiler books you can buy.

First of all this is a theoretical book. If you read the title 'Engineering a compiler' as 'Coding/Building a compiler' you would be disappointed! So, if you're looking for a learing-by-coding book, this is not for you (but I have some recommendations at the end of this review in the latest paragraph). The difference with most of the other theoretical books is that this book is not a dry text. It has also a nice layout. It gives plenty of examples, and all topics are well connected to each other. It's a pleasure to read for not native English people, so native English people can read it pretty fast.

This book read like a novel.. It does contain enough diagrams, tables, etc. but not too much (crowded), and everything is well explained.

You can read this book as a compiler introduction book. But I can only recommend this to B.Sc/M.Sc Computer Science students (like me). You don't need to have a M.Sc in Mathematics to understand this text, (all the math, eg. liveness graphs are well explained), but you will understand everything better if you have some background in algorithms (design), pseudocode, etc. like you gained during your B.Sc program. People without formal computer science education I would recommend to read a practical book first (see at the end of this review), because you may find else this text too theoretical.

This book focus on code optimizations. According to the authors (and me) compiler front ends (scanning/parsing/etc) are commodities today, and the backend (codegeneration) is where the difference is made nowadays. So if you're looking for a introduction text into compiler optimization this book is for you!

If you're looking for a more practical book I advice you to read 'Programming Language Processors in Java' from Watt & Brown. In that book you learn to build a nice stack virtual machine in Java with 'advanced features' like records (structs), procedures/functions, arrays and so on. That book is a good companion for 'Engineering a Compiler' to give you some practical insight. If you're looking for a Language Design book I advice you to look at 'Programming Language Pragmatics'. Both books are worth the money...

Average customer rating:

Overcomplicated
Best reference for the core language with plenty of examples
Great reference book
Excellent reference
excellent

C++ in a Nutshell
Ray Lischner
Manufacturer: O'Reilly Media, Inc.
ProductGroup: Book
Binding: Paperback

General | Programming | Computers & Internet | Subjects | Books

General | Operating Systems | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

Nutshell | Series | O'Reilly | By Publisher | Books

C & C++ | Programming | O'Reilly | By Publisher | Books

General | Programming | O'Reilly | By Publisher | Books

Look Inside Computer Books | Trip | Specialty Stores | Books
Similar Items:

C++ Cookbook (Cookbooks (O'Reilly))
C in a Nutshell (In a Nutshell (O'Reilly))
C++ Pocket Reference
Practical C++ Programming, Second Edition
STL Pocket Reference

ASIN: 059600298X

Book Description

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's fingertips.

Customer Reviews:

Overcomplicated .......2007-07-11

Hi,
I'm a recent graduate B.Sc CS and used this book extensively for a month+ as to prepare for a c++ job interviews.

Unfortunately I can't say I loved this book. I found the examples to be overcomplicated by irrelevant information and language to be ambiguous at the times.

As an example, from page 160 (classes/ covariant return types):
"In a derived class, a covariant return type is a pointer or reference to a class type that derives from the return type used in the base class" ?!

Code examples are contaminated by the irrelevant programming techniques and irrelevant code. Page 158, "declaring and using virtual functions", the code example extends over two pages. In it, author uses concepts of templates, complicated operators overloading, constructor and destructor, pure virtual functions (its different topic in the book, much later) as well as a very complicated programming code. And all of this extra information used to explain a rather simple virtual functions.

If the reader is not very familiar with some concepts of programming language, reader might face a difficulty to understand the topic illustrated, as it would be polluted with much unrelated code technique.

I wouldn't recommend this book for the beginners, and would proceed with caution if you are an intermediate programmer. This is a great start but author need to maintain focus on the particular topic and not to make it more complicated then it's already is. After all it's a reference book and not the collection of the brain teasers.

Best reference for the core language with plenty of examples.......2007-06-23

Many implementations of C++ extend the language and standard library. Except for brief mentions of language and library extensions in the appendixes, this book covers only the standard. The standard library is large, but it omits much that is common in computing today such as concurrency, network protocols, database access, graphics, and windowing. However, Appendix B contains some information about nonstandard libraries that provide additional functionality.

This book is a reference, not a tutorial, thus those unfamiliar with C++ might find portions of this book difficult to understand. Although each portion of the book contains some advice on idioms and the proper use of certain language constructs, the main focus is on the reference material. This book is divided into two interleaved sections that cover the language and the library, and a couple of appendixes. Roughly speaking, the language is the part of C++ that does not require any additional #include headers or files. The library is the part of C++ that is declared in the standard headers.

Chapter 1 through Chapter 7, Chapter 11, and Chapter 12 cover the language itself. The first seven chapters form the main language reference, organized by topic. It is customary for a programming reference to contain a formal grammar, and this book does so in Chapter 12, which is organized alphabetically by keyword with some additional entries for major syntactic categories, such as expressions. Chapter 11 is a reference for the preprocessor. Chapter 13 is the library reference, organized alphabetically by header. Chapters 8 through 10 present an overview of the library and introduce the topics that span individual headers. A detailed accounting of each chapter follows:

Chapter 1. Language Basics - describes the basic rules for the C++ language.
1.1. Compilation Steps
1.2. Tokens
1.3. Comments
1.4. Character Sets
1.5. Alternative Tokens
1.6. Trigraphs

Chapter 2. Declarations - describes how objects, types, and namespaces are declared and how names are looked up.
2.1. Declarations and Definitions
2.2. Scope
2.3. Name Lookup
2.4. Linkage
2.5. Type Declarations
2.6. Object Declarations
2.7. Namespaces

Chapter 3. Expressions - describes operators, precedence, and type casts.
3.1. Lvalues and Rvalues
3.2. Type Conversions
3.3. Constant Expressions
3.4. Expression Evaluation
3.5. Expression Rules

Chapter 4. Statements - describes all the C++ statements.
4.1. Expression Statements
4.2. Declarations
4.3. Compound Statements
4.4. Selections
4.5. Loops
4.6. Control Statements
4.7. Handling Exceptions

Chapter 5. Functions - describes function declarations and definitions, overload resolution, argument passing, and related topics.
5.1. Function Declarations
5.2. Function Definitions
5.3. Function Overloading
5.4. Operator Overloading
5.5. The main Function

Chapter 6. Classes - describes classes, unions, structures, members, virtual functions, inheritance, accessibility, and multiple inheritance.
6.1. Class Definitions
6.2. Data Members
6.3. Member Functions
6.4. Inheritance
6.5. Access Specifiers
6.6. Friends
6.7. Nested Types

Chapter 7. Templates - describes class and function template declarations, definitions, instantiations, specializations, and how templates are used.
7.1. Overview of Templates
7.2. Template Declarations
7.3. Function Templates
7.4. Class Templates
7.5. Specialization
7.6. Partial Specialization
7.7. Instantiation
7.8. Name Lookup
7.9. Tricks with Templates
7.10. Compiling Templates

Chapter 8. Standard Library - introduces the standard library and discusses some overarching topics, such as traits and allocators.
8.1. Overview of the Standard Library
8.2. C Library Wrappers
8.3. Wide and Multibyte Characters
8.4. Traits and Policies
8.5. Allocators
8.6. Numerics

Chapter 9. Input and Output - introduces the I/O portion of the standard library. Topics include formatted and unformatted I/O, stream buffers, and manipulators.
9.1. Introduction to I/O Streams
9.2. Text I/O
9.3. Binary I/O
9.4. Stream Buffers
9.5. Manipulators
9.6. Errors and Exceptions

Chapter 10. Containers, Iterators, and Algorithms - introduces the suite of container class templates, their iterators, and generic algorithms. This is the portion of the library that has traditionally been called the Standard Template Library (STL).
10.1. Containers
10.2. Iterators
10.3. Algorithms

Chapter 11. Preprocessor Reference - an alphabetical reference for the preprocessor, which is part of the language, but with a distinct set of syntactic and semantic rules.

Chapter 12. Language Reference - an alphabetical reference for the language and grammar. Backus-Naur Form (BNF) syntax descriptions are given for each keyword and other language elements, with pointers to the first seven chapters for the main reference material.

Chapter 13. Library Reference - a reference for the entire standard library, organized alphabetically by header, and alphabetically by name within each header section.

Appendix A. Compiler Extension - describes ways that some compilers extend the language: to satisfy customer need, to meet platform-specific requirements, and so on.

Appendix B. Projects - describes a few interesting, open source C++ projects. You can find information about additional projects on the book's web site.

The book illustrates the descriptions and definitions it covers with plenty of examples - some quite short, and then some longer ones as you get further into the book. If you need a good desk reference on C++, this is definitely the one to buy and keep by your side.

Great reference book.......2007-01-10

This is a great reference book. You definitely need to know something about c++ to get the full benefit of it. I would recommend it.

Excellent reference.......2006-03-19

I always like O'Reilly books and are usually what I purchase. The "In A Nutshell" may be misleading to some. Just think of it as "C++ A Language & Library Reference." If you are a beginner looking for a how to, this isn't the one for you. "Thinking in C++" by Bruce Eckel (great book), or "Practical C++ Programming" would be the one a beginner would want. However, when you are ready to explore the inter-details about what C++ classes provides, this would be a good one to add to your collection. The first half describes C++ in general, while the last half details the language reference. I like how the reference is structured, grouped by the easy to find header declaration at the bottom of the page. Quickly finding what you need is a great feature here. You can only do so much "std::cout < < "hi" < < std::endl; without a reference and this one covers the missing details. Not for beginners, but an excellent reference.

excellent.......2006-01-14

I found this book is excellent. It concisely covers many finer
points of c++ language, which are not fully explained
in many other similar books. Of course, your understanding of
this book will be greater if you have already studied c++ for
a while.

Advanced ASIC Chip Synthesis Using Synopsys® Design Compiler® Physical Compiler® and PrimeTime®

Average customer rating:

hands on guide
ok for an introduction to the tools

Advanced ASIC Chip Synthesis Using Synopsys® Design Compiler® Physical Compiler® and PrimeTime®
Himanshu Bhatnagar
Manufacturer: Springer
ProductGroup: Book
Binding: Hardcover

CAD | Graphic Design | Computers & Internet | Subjects | Books

General | Science | Subjects | Books

General | Arts & Photography | Subjects | Books

Look Inside Art Books | Trip | Specialty Stores | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

Look Inside Science Books | Trip | Specialty Stores | Books

All Amazon Upgrade | Amazon Upgrade | Stores | Books

Arts & Photography | Amazon Upgrade | Stores | Books

Computers & Internet | Amazon Upgrade | Stores | Books

Engineering | Amazon Upgrade | Stores | Books

Professional & Technical | Amazon Upgrade | Stores | Books

Science | Amazon Upgrade | Stores | Books

All Titles | Qualifying Textbooks - Fall 2007 | Stores | Books

Arts & Photography | Qualifying Textbooks - Fall 2007 | Stores | Books

Computers & Internet | Qualifying Textbooks - Fall 2007 | Stores | Books

Professional | Qualifying Textbooks - Fall 2007 | Stores | Books

Science | Qualifying Textbooks - Fall 2007 | Stores | Books
Similar Items:

Timing Verification of Application-Specific Integrated Circuits (ASICs) (Prentice Hall Modern Semiconductor Design Series: PH Signal Integrity Library)
Logic Synthesis Using Synopsis
Timing (Information Technology: Transmission, Processing & Storage)
Synthesis of Arithmetic Circuits: FPGA, ASIC and Embedded Systems
Verilog HDL Synthesis, A Practical Primer

Accessories:

Algorithms for VLSI Physical Design Automation, Third Edition
Rapid Prototyping of Digital Systems: Quartus® II Edition

ASIN: 0792376447

Book Description

Advanced ASIC Chip Synthesis: Using Synopsys® Design Compiler® Physical Compiler® and PrimeTime®, Second Edition describes the advanced concepts and techniques used towards ASIC chip synthesis, physical synthesis, formal verification and static timing analysis, using the Synopsys suite of tools. In addition, the entire ASIC design flow methodology targeted for VDSM (Very-Deep-Sub-Micron) technologies is covered in detail.
The emphasis of this book is on real-time application of Synopsys tools, used to combat various problems seen at VDSM geometries. Readers will be exposed to an effective design methodology for handling complex, sub-micron ASIC designs. Significance is placed on HDL coding styles, synthesis and optimization, dynamic simulation, formal verification, DFT scan insertion, links to layout, physical synthesis, and static timing analysis. At each step, problems related to each phase of the design flow are identified, with solutions and work-around described in detail. In addition, crucial issues related to layout, which includes clock tree synthesis and back-end integration (links to layout) are also discussed at length. Furthermore, the book contains in-depth discussions on the basis of Synopsys technology libraries and HDL coding styles, targeted towards optimal synthesis solution.
Target audiences for this book are practicing ASIC design engineers and masters level students undertaking advanced VLSI courses on ASIC chip design and DFT techniques.

Customer Reviews:

hands on guide.......2005-11-12

This book is geared towards the synopsys synthesis tools (as evident in the title). It gives brief explanations about vhdl and verilog coding style (which can be found in many other books).
The actual useful part was that the book explored the commonly used synthesis commands in synopsys, and also had explanations on the steps to follow to succesfully synthesize rtl. These ideas can also be used on synthesis tools from other vendors.

This book is good for people already familiar with front end rtl design and are looking into moving to backend.

ok for an introduction to the tools.......2003-03-21

This book is interesting as an introduction to these tools but needs more depth

Advanced Compiler Design and Implementation

Average customer rating:

Bible of compiler data-flow analysis
Great starting point for compiler development
Confusing at best
Good for seasoned compiler writers, bad for CS students
Excellent

Advanced Compiler Design and Implementation
Steven Muchnick
Manufacturer: Morgan Kaufmann
ProductGroup: Book
Binding: Hardcover

General | Programming | Computers & Internet | Subjects | Books

General | Computers & Internet | Subjects | Books

General | Operating Systems | Computers & Internet | Subjects | Books

Design & Architecture | Hardware | Computers & Internet | Subjects | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

All Amazon Upgrade | Amazon Upgrade | Stores | Books

Computers & Internet | Amazon Upgrade | Stores | Books

Professional & Technical | Amazon Upgrade | Stores | Books

All Titles | Qualifying Textbooks - Fall 2007 | Stores | Books

Computers & Internet | Qualifying Textbooks - Fall 2007 | Stores | Books

Professional | Qualifying Textbooks - Fall 2007 | Stores | Books
Similar Items:

Optimizing Compilers for Modern Architectures: A Dependence-based Approach
Compilers: Principles, Techniques, and Tools (2nd Edition)
Engineering a Compiler
Programming Language Pragmatics, Second Edition
Garbage Collection: Algorithms for Automatic Dynamic Memory Management

ASIN: 1558603204

Amazon.com

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.

Book Description

From the Foreword by Susan L. Graham:

This book takes on the challenges of contemporary languages and
architectures, and prepares the reader for the new compiling problems that
will inevitably arise in the future.

The definitive book on advanced compiler design

This comprehensive, up-to-date work examines advanced issues in the design
and implementation of compilers for modern processors. Written for
professionals and graduate students, the book guides readers in designing
and implementing efficient structures for highly optimizing compilers for
real-world languages. Covering advanced issues in fundamental areas of
compiler design, this book discusses a wide array of possible code
optimizations, determining the relative importance of optimizations, and
selecting the most effective methods of implementation.

* Lays the foundation for understanding the major issues of advanced
compiler design

* Treats optimization in-depth

* Uses four case studies of commercial compiling suites to illustrate
different approaches to compiler structure, intermediate-code design, and
optimizationthese include Sun Microsystems's compiler for SPARC, IBM's for
POWER and PowerPC, DEC's for Alpha, and Intel's for Pentium an related
processors

* Presents numerous clearly defined algorithms based on actual cases

* Introduces Informal Compiler Algorithm Notation (ICAN), a language devised
by the author to communicate algorithms effectively to people

Customer Reviews:

Bible of compiler data-flow analysis.......2007-09-12

It's the bible of compiler data-flow analysis. The author had the experience of building an industrial strength compiler. One tip: skip books authored by those who haven't implemented an industrial strength compiler by themself.

Great starting point for compiler development.......2007-03-04

Compiler development is more of a craft than a science, although there's plenty of science involved. It involves huge numbers of tradeoffs in features, optimizations, and use of the underlying processor. But, as long as people keep coming up with new computing platforms (and not just instruction set processors), new languages, and new performance demands there will always be need for new compiler developers. If you can't apprentice yourself to masters of the craft, or even if you can, this book is a great introduction 2000-era compiler development.

Muchnik does a clear, thorough job of laying out the basics, starting with the intermediate representation used. (If you get that wrong, nothing else is going to work.) He then moves on to the basics of symbol table structure - an issue that can get immensely complicated in systems like Microsoft's CLR. He also discusses run time support briefly. Although that discussion is good as far as it goes, it skips past a lot of the complexities of dynamic loading, debug symbol tables, simulation support, and related issues. They aren't strictly part of the compiled, executable code, but responsibilities of the compiler developer nonetheless. Next comes a brief description of code generation, crucial in normal environments but tangential to my own needs.

That's just the first quarter of the book, though. The rest is the real meat of the topic: code analysis and optimization techniques, over 600 pages of discussion. It's way too much to summarize here, but even that just an introduction to a huge technology. Still, you have to start somewhere.

By this point, you may be asking "But what about tokens, lexemes, and grammars? Isn't that what compilers do?" Well, yes, but it's done. Tool developers have made lexical analysis a commodity. The easily automated tasks are not where modern compiler distinguishes itself. This book addresses the semantic levels, getting the reader into the shallow end of the industry's huge pool of specialized compilation knowledge.

If you have to self-teach compiler development - good luck. Start here, though, and luck will have a lot less to do with the outcome.

//wiredweird

Confusing at best.......2006-08-17

I've seen chapter 14 of this book referenced (by a university professor giving suggestion to his students, not by a random guy) as:

"Another conventional approach to strength reduction. 35 pages of the same kind of confusing crap we've all come to expect from this book."

This could not sum it up better. A confusing book at best, presenting basic material so as to make it look "advanced", and without any covering of even relatively new techniques. A good source of references to papers that you should read, but not at all a valid reference on its own.

Good for seasoned compiler writers, bad for CS students.......2004-12-14

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!)

Excellent.......2003-10-14

Advances in compiler design do not get much press these days. The reasons for this are unclear, but no doubt the perception that compilers need no further improvement has something to do with this. This book, written by one of the leading experts on compilers, certainly dispels this belief. Once readers get used to the idiosyncratic ICAN (Informal Compiler Algorithm Notation) invented by the author and used throughout the book, they get a comprehensive overview of compilers, especially that of optimization. Compilers for the SPARC, PowerPC, DEC, and Pentium architectures are treated in the book. The predominant emphasis of the book is in optimization, and so a few more recent and important topics in compiler construction, such as partial evaluation, are not discussed. Readers are expected to have a prior background in elementary compiler theory. My primary interest in reading the book was to gain insight into the compilation issues that arise in symbolic programming languages such as LISP and Prolog.

A detailed review of this book cannot be done for lack of space, but some of the helpful aspects and interesting discussions in the book include: 1. The "wrap-up" section at the end of each chapter, giving a compact summary of what was done in the chapter. 2. Generating loads and stores: The author shows how to move values to and from registers using routines more sophisticated than simply loading values into registers before using them or storing values as soon as they have been computed. 3. The main issues in the use of registers, such as variable allocation, efficiency of procedural calls, and scoping. The author lists the different categories that will result in contention for registers, such as stack, frame, and global offset table pointers and dynamic and static links. 4. The local stack frame and its uses, such as holding indexed variables (arrays, etc.) and debugging. 5. The five different parameter-passing mechanisms: call by value, call by result, call by value-result, call by reference, and call by name. A thorough discussion is given of their properties and what languages make use of them. In particular, the author notes that in the languages C and C++, call by value is the only parameter-passing mechanism, but that the address of an object may be passed, thus emulating essentially call by reference. This can be a source of confusion to those who program in C and C++. The most exotic of these mechanisms is call by name, which is a form of "lazy evaluation" in functional programming languages. The author gives a code example of the call by name parameter passing in ALGOL 60. I don't know of any modern practical programming languages that make use of call by name. 6. Shared libraries and the role of semantic linking and position independent code. 7. The compilation issues that arise in symbolic languages, such as LISP and Prolog. These languages typically have run-time type checking and function polymorphism, which gives them their power and ease of use. The author discusses how to produce efficient code for these languages. Since heap storage is utilized heavily by these languages, the allocation and recovering of it is very important. "Generation scavenging" is mentioned as the most efficient method for doing garbage collection in these languages. This method has been advertised in the literature as one that minimizes the time needed for storage reclamation in comparison with other approaches. In addition, the use of "on-the-fly" recompilation for polymorphic-language implementations is discussed. 8. Dynamic programming and its role in automatic production of code generators, as contrasted with the "greedy approach". The author explains the need for "uniform register machines" in the dynamic programming algorithm. 9. Interval analysis and its use in the analysis of control flow. This technique has been used in the field called "abstract interpretation" in recent years, the aim of which is too automatically and intelligently test program code. 10. Dependencies between dynamically allocated objects, such as links between graph structures in LISP and Prolog. The author describes the Hummel-Hendren-Nicolau technique for doing this, which involves naming schemes for locations in heap memory, a collection of axioms for characterizing aliasing locations among locations, and lastly, and most interestingly, utilizes a theorem prover to establish the properties of the data structures. The author emphasizes though that this technique, and others developed for doing dependence analysis of dynamically allocated objects, are very computationally intensive. 11. Individual optimizations, which the author divides into four groups in order of importance. 12. Induction-variable optimizations and their role in loop optimizations. The author shows how to identify induction variables, and how to transform them using various techniques, going by the name strength reduction, induction-variable removal, and linear-function test replacement. 13. Procedure integration and its role in "inlining" procedures in languages such as C++. The author emphasizes the drawbacks in using inlining, such as its impact on cache misses. 14. The trade-off between object abstraction and optimization, which occurs in object-oriented languages such as C++. The author discusses in detail the role of interprodecural optimizations in dealing with abstraction in the object-oriented modular approach to programming, particularly the identification of "side effects" in making procedure calls. 15. Code optimization that takes advantage of the memory hierarchy, such as data and instruction caches, and how to improve register allocation for arrays. The author gives a detailed and highly interesting discussion of scalar replacement for array elements. 16. Future trends and research in compiler design. The author mentions a few which he believes will dominate in the upcoming decade, such as scalar-oriented and data-cache optimizations. Scalar compilation will be he most active research area in his opinion. At the present time, there has been discussion of "intelligent compilers" that will interact with the user to develop optimal code, or even produce correct programs. These compilers will understand the intentions of the program and warn the user if these are violated, as well as reduce the time and cost needed for testing programs.

Programming Language Pragmatics
Average customer rating:

Very Good Book

Excellent coverage of language concepts

Great book.

Probably the best book in the "Survey of Programming Languages" genre

Outstanding introduction to programming languages and their compilers

Programming Language Pragmatics
Michael L. Scott
Manufacturer: Morgan Kaufmann
ProductGroup: Book
Binding: Hardcover

Compilers | Languages & Tools | Programming | Computers & Internet | Subjects | Books
General | Languages & Tools | Programming | Computers & Internet | Subjects | Books
Software Development | Software Design, Testing & Engineering | Programming | Computers & Internet | Subjects | Books
General | Programming | Computers & Internet | Subjects | Books
General | Computers & Internet | Subjects | Books
Design & Architecture | Hardware | Computers & Internet | Subjects | Books
All Titles | Qualifying Textbooks - Fall 2007 | Stores | Books
Computers & Internet | Qualifying Textbooks - Fall 2007 | Stores | Books
Similar Items:

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

Engineering a Compiler

Introduction to the Theory of Computation, Second Edition

Beautiful Code: Leading Programmers Explain How They Think (Theory in Practice (O'Reilly))

Programming Language Processors in Java: Compilers and Interpreters

ASIN: 1558604421

Amazon.com

As a textbook suitable for the classroom or self-study, Michael Scott's Programming Language Pragmatics provides a worthy tour of the theory and practice of how programming languages are run on today's computers. Clearly organized and filled with a wide-ranging perspective on over 40 different languages, this book will be appreciated for its depth and breadth of coverage on an essential topic in computer science.

With references to dozens of programming languages, from Ada to Turing and everything in between (including C, C++, Java, and Perl), this book is a truly in-depth guide to how code is compiled (or interpreted) and executed on computer hardware. Early chapters tend to be slightly more theoretical (with coverage of regular expressions and context-free grammars) and will be most valuable to the computer science student, but much of this book is accessible to anyone seeking to widen their knowledge (especially since recent standards surrounding XML make use of some of the same vocabulary presented here).

The book has a comprehensive discussion of compilation and linking, as well as how data types are implemented in memory. Sections on functional and logical programming (illustrated with Scheme and Prolog, which are often used in AI research) can expand your understanding of how programming languages work. Final sections on the advantages--and complexities--of concurrent processing, plus a nice treatment of code optimization techniques, round out the text here. Each chapter provides numerous exercises, so you can try out the ideas on your own.

Students will benefit from the practical examples here, drawn from a wide range of languages. If you are a self-taught developer, the very approachable tutorial can give you perspective on the formal definitions of many computer languages, which can help you master new ones more effectively. --Richard Dragan

Topics covered: A survey of today's programming languages, compilation vs. interpretation, the compilation process, regular expression and context-free grammars, scanners and parsers, names, scopes and bindings, scope rules, overloading, semantic analysis, introduction to computer architecture, representing data, instruction sets, 680x0 and MIPs architectures, control flow and expression evaluation, iteration and recursion, data types, type checking, records, arrays, strings, sets, pointers, lists, file I/O, subroutines, calling sequences and parameter passing, exception handling, coroutines, compile back-end processing, code generation, linking, object-oriented programming basics, encapsulation and inheritance, late binding, multiple inheritance, functional and logical languages, Scheme and Prolog, programming with concurrency, shared memory and message passing, and code optimization techniques.

Book Description

Programming Language Pragmatics addresses the fundamental principles at work in the most important contemporary languages, highlights the critical relationship between language design and language implementation, and devotes special attention to issues of importance to the expert programmer. Thanks to its rigorous but accessible teaching style, you'll emerge better prepared to choose the best language for particular projects, to make more effective use of languages you already know, and to learn new languages quickly and completely.

* Addresses the most recent developments in programming language design, spanning more than forty different languages, including Ada 95, C, C++, Fortran 95, Java, Lisp, Scheme, ML, Modula-3, Pascal, and Prolog.
* Places a special emphasis on implementation issueshow the techniques used by compilers and related tools influence language design, and vice versa.
* Covers advanced topics in language design and implemenation, such as iterators, coroutines, templates (generics), separate compilation, I/O, type inference, and exception handling.
* Reviews language-related topics in assembly-level architecture critical for understanding what a compiler does to a program.
* Offers in-depth coverage of object-oriented programming, including multiple inheritance and dynamic method binding.
* Devotes a special section to static and dynamic linking.
* Includes a comprehensive chapter on concurrency, with detailed coverage of both shared-memory and message-passing languages and libraries.
* Provides an accessible introduction to the formal foundations of compilation (automata theory), functional programming (lambda calculus), and logic programming (predicate calculus).

Customer Reviews:

Very Good Book.......2007-07-20

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.

Excellent coverage of language concepts.......2007-05-04

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.

Great book........2006-11-10

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.

Probably the best book in the "Survey of Programming Languages" genre.......2006-02-24

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.

Outstanding introduction to programming languages and their compilers.......2006-02-07

Over the years the Dragon Book has become the de facto standard for introducing compilers and related topics at universities. This is very unfortunate because "Programming Language Pragmatics" is in a completely different league and should be the one used instead. It gives the student (or the self taught) a complete and through overview of parsing, grammar, automata theory and other key language constructs. What really differentiates this book from others (and most notably the (in)famous "Dragon Book") is that it does so in a easy to understand manner and with lots of well written examples.

Many people find compiler and language theory to be dark magic, and it would be wrong not to acknowledge that these subjects are considerably harder than say creating a web page in PHP or writing a small Java/C# program. But much of the confusion also stems from the long history of porly written books which all have lacked explaining key areas or assumed that the readers just know some obscure CS topics beforehand. This book does not travel down that road, it is well written, contains both simple and advanced examples and is simply a delightful read.

Average customer rating:

best!
Truly amazing book but not about Expert C programming
Great book for the intermediate C programmer
OK, but terribly overrated. Definitely nothing expert
Fun basic C book

Expert C Programming
Peter van der Linden
Manufacturer: Prentice Hall PTR
ProductGroup: Book
Binding: Paperback

General | Programming | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

All Titles | Qualifying Textbooks - Fall 2007 | Stores | Books

Computers & Internet | Qualifying Textbooks - Fall 2007 | Stores | Books

Professional | Qualifying Textbooks - Fall 2007 | Stores | Books
Similar Items:

C Traps and Pitfalls
C: A Reference Manual (5th Edition)
Memory as a Programming Concept in C and C++
The C Programming Language (2nd Edition)
Mastering Algorithms with C (Mastering)

ASIN: 0131774298

Amazon.com

Defying the stereotypical notion that technical books tend to be boring, Expert C Programming offers a lively and often humorous look at many aspects of C--from how memory is laid out to the details of pointers and arrays. The author reveals his points through invaluable anecdotes, such as stories of costly bugs, and through folklore, such as the contents of Donald Knuth's first publication. Each chapter ends with a section entitled "Some Light Relief," which discusses topics (topics that some may consider to be "recreational"), such as programming contests. A fabulous appendix on job interview questions finishes the book.

Customer Reviews:

best!.......2007-08-21

The best C book of all in my opinion - maybe K&R is still essential to have, then this should be the second. For all there who have come to the point to understand that C is a relatively simple language, this is the book that will show you what next to learn about C.

As well as the technical valuables, the writing style is really enjoyable to read. Plus, very interesting anecdotes.

The chapter about C++ may not be a very important chapter in this book, but it is so well written that it does better teaching C++ than many of the C++ books out there on the market. Gets the essentials and is very balanced instead of "religious".

Truly amazing book but not about Expert C programming.......2007-05-10

This is a truly amazing book. This book alone will not make you an Expert C programmer, but if you ever programmed anything in C or C++ you will find it amazing. It will help you to uncover dark corners of language in most entertaining way possible. I can guarantee you will not go to sleep until you finish it.

Great book for the intermediate C programmer.......2007-02-26

I am forced to agree with those reviewers who thought the title misleading. A better title might have been "On the Road to Expert C Programming." It won't help the experienced C programmer, but for intermediate C programmers the book is priceless.

Perhaps more importantly, the book is simply a joy to read. Very rarely do you get to read a book that exudes the pleasure of computer programming. More technical writers should read van der Linden; they might learn something.

OK, but terribly overrated. Definitely nothing expert.......2007-01-18

Too much hype about this book. I bought it online a few years back -- because of this hype; it's very basic; I regret I bought it. Not that it's bad: for a beginner in may be OK. In any case, make sure to check it out in store; don't buy sight unseen.

Fun basic C book.......2006-12-21

I enjoyed reading this book, the writing style keeps you reading. The titbits were fun to read. I liked the brief chapter on the comparison of C to C++.

However, i didn't really learn anything from it, but this maybe because I learnt my basic C from K&R. There is no coverage of sockets, shared memory, semaphores, ipc, threads, TCP/IP, etc..., so i would not condsider myself an expert knowing the contents of this book. Any professional C programmer in todays environment needs knowledge of these areas IMHO. Nobody only writes vanilla C these days. If you want to move on your knowledge get Stevens, if you want something fun to read before you go to bed get this.

Average customer rating:

Great book for learning ADA, but long....
Not a book for those new to Ada
The ultimate Ada95 book, if you are experienced programmer.
The ultimate Ada95 book, if you are experienced programmer.
The best book on Ada 95.

Ada As A Second Language
Norman Cohen
Manufacturer: McGraw-Hill Science/Engineering/Math
ProductGroup: Book
Binding: Paperback

General | Programming | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

All Titles | Qualifying Textbooks - Fall 2007 | Stores | Books

Computers & Internet | Qualifying Textbooks - Fall 2007 | Stores | Books

Professional | Qualifying Textbooks - Fall 2007 | Stores | Books
Similar Items:

Programming in Ada 95 (2nd Edition) (International Computer Science Series)
Ada 95: Problem Solving and Program Design (3rd Edition)
Rendezvous with Ada 95, 2nd Edition
Programming in Ada 2005 with CD (International Computer Science Series)
Concurrent and Real-Time Programming in Ada

ASIN: 0070116075

Book Description

Known as the authority on Ada 83, this text reflects the latest version of the language, Ada 95. Designed for a junior/senior programming course, this text serves as both a tutorial introduction and a complete reference to the Ada language. It offers specific, practical advice on how and why to use each language feature, stressing good programming style supported by hundreds of complete examples.

Customer Reviews:

Great book for learning ADA, but long...........2005-05-28

This book is great for people just starting with ADA because it initially goes through the basics of a program and then going through every component in detail. Since I was already proficient in C and C++ it was nice how the book points out how the commands are similar to not only C but also Pascal and COBOL (even though I don't know those two). I really like the format of the book. You get the format definition, then the syntax, and finally a short example of the instruction being used.

If you already know C or some other similar language, you'll probably get annoyed with how much detail it goes into at explaining the simple programs and code it presents, but you can always skip it.

My only complaints are how long the book is and the price. Not only is this the longest programming book I've seen, but it's also the most expensive. However, if you really need to learn ADA it's pretty much worth the price.

Not a book for those new to Ada.......2003-04-23

This is a poor book to learn Ada from. I'll agree that the book is a good reference tool, once you have a firm grasp on the language. I took a course four years ago with 14 other experienced programmers (Ada, C, ...), all of them thought this book was difficult to use as a learning tool. It lacks good examples and is poorly orginized. Go elsewhere if your new to Ada 95.

The ultimate Ada95 book, if you are experienced programmer........1999-12-01

Over two years back, I had to write and test huge amount of code (about 200-330K LOC) in Ada 95 (I had over 8 yrs. Ada 83 experience) in very short time. A colleague suggested to use this book. It has helped me in every way. The book contains very clear explanations about all the new concepts in Ada and it also covers the real-time issues, OOP, low-level multilingual programming, distributed programming etc.

Although, it was written for the "C" programmers who are new to Ada, I have since then worked on two more major programs and this is the only Ada95 book I am continuously using together with the Ada 95 LRM.

The ultimate Ada95 book, if you are experienced programmer........1999-12-01

The best book on Ada 95........1999-04-13

This book is the best Ada 95 book in the market. It covers everything about Ada 95 (core language plus all six specialized annexes). Chapters are presented in a tutorial format. Examples in the book are practical and realistic. Best of all you learn features of Ada 95 with a tremendous clarity. What is unbelievable is the ability of the author to teach you some complex topics in a step by step manner leaving no room for confusion. This book is complete in every way and entertaining. If you are a serious Ada developer this is a MUST BOOK. I use this book to teach adavnced Ada 95 classes.

Books:

Books Index

Books Home

Recommended Books