Rating: 
Summary: Surprisingly thorough
Review: As the subject suggests, I was surprised to discover how thorough this book really is; many others might claim they cover many languages, but this one really does. On top of that, it uses language easily understood outside of the academia.On the flipside, however, I doubt you will get much out of this book if you have not explored several different programming languages already. Without a bit of experience in the covered topics you will probably not find the book to be very useful, however. It does not contain any tutorials on the languages it covers, nor does it really go into any depth on many of the features it describes. Its descriptions are very concise, making for a hard read if you dont have an inkling of what he is talking about already.
Rating:
Summary: Surprisingly thorough
Review: As the subject suggests, I was surprised to discover how thorough this book really is; many others might claim they cover many languages, but this one really does. On top of that, it uses language easily understood outside of the academia. On the flipside, however, I doubt you will get much out of this book if you have not explored several different programming languages already. Without a bit of experience in the covered topics you will probably not find the book to be very useful, however. It does not contain any tutorials on the languages it covers, nor does it really go into any depth on many of the features it describes. Its descriptions are very concise, making for a hard read if you dont have an inkling of what he is talking about already.
Rating:
Summary: A classic
Review: For everyone that ever has worked on or plans to implement a compiler/interpreter. It gave me many new insights on different implementation issues. This book is written in such a pedagogical, clear and exciting way that it can be read like a novel or a thriller (pick Your choice).
Rating:
Summary: A classic
Review: For everyone that ever has worked on or plans to implement a compiler/interpreter. It gave me many new insights on different implementation issues. This book is written in such a pedagogical, clear and exciting way that it can be read like a novel or a thriller (pick Your choice).
Rating: 
Summary: Not just for compiler developers. A little too much RISC
Review: I agree that every compiler writer (not engineer: programming is a cruelly difficult writing *sui generis*, not engineering) needs this book but its market is or should be much wider.
There is NO way to learn programming except at the intersection between compiler writing and applications programming, and it is a MISTAKE to teach programming as either a context-free application programmer's worship of machines and authority, or as the acquaintance with one programming language, its mistakes of design and implementation included, as Eleusinian mysteries demanding reverence.
Dijkstra, famously, described programming as applied mathematics. The concept of "applied" introduces an ineradicable tension between one discipline and another where the key ability is the ability to shuttle between layers of representation.
Crude language speaks airily of the needs of the user, where the user is hypostatized, singular, male, and imaged as wealthy and lacking taste. The actuality is that the relationship goes in computing all the way down, one user is also a worker for another, and only a programmer who has mastered his trade understands the need to transcend, in the course of understanding, the relationship.
Thus this book is useful not only to the compiler writer but also to the application programmer, because (for example), the application programmer has to understand at least in general terms how the For or Do construct of his language is evaluated.
He's importuned instead to meditate upon business needs with the result that something like 80% of large systems fail.
A programmer who, in Visual Basic, does not understand that For intIndex1 = 1 To intLimit - 1 is not "inefficient" because the expression is evaluated by value, doesn't know his trade. A programmer who, in C, doesn't know that while ( intIndex1 = 0; intIndex <= intLimit - 1; intIndex++ ) IS inefficient insofar as the expression is repeatedly evaluated doesn't know his trade, and the book is full of useful information about these important semantic issues.
Many programmers use the totally inappropriate automobile metaphor to describe the computer and in so doing they declare that no more than they would look under the hood of their car, they should be freed of important issues of semantics and if possible coherent and readable syntax in their mindless coding.
The metaphor confuses a force and energy determined system with an information engine. It also encapsulates a narrow understanding, restricted to America and other energy-wasteful societies, of what it means to relate, even to cars, for the atypical but thrifty American, who buys manual transmission used cars, or the Havana teen, who starts his car by rolling it down the hill, both are familiar, of necessity, with what goes on "under the hood"...or else.
A person with claims to professional writing skills would of course be familiar with semantics as well as syntax. But in programming, semantics is confused with "being a compiler developer or something".
Unlike natural language semantics, which bleeds out in history and sociology, programming language semantics is coeval with the "way the compiler works" in the sense of its specification, captured NOT in Programming Languages for Dummies BUT INSTEAD in the specifications document for the language.
[In France titles in the For Dummies series are "pour les nuls", which is *tres amusant*. I don't mean to slam this series which is well written and useful, but its title needs rethinking, for it at once asserts class pride and solidarity while disempowering in the very act of doing so.]
Good program design is based on knowing how the compiler "works" in the sense of understanding the language contract, which in C forces while evaluation by reference but in Visual Basic forces it by value.
The advanced material in this book on the implementation of Prolog and logic languages is important because it shows how far these languages are from being complete in the sense of first-order logic with quantification, which explains the survival of procedural languages.
My First Computer Book, special-ordered from the Roosevelt University Bookstore in 1971, was Peter Wegner's Information Structures, Information Structures and Machine Organization, a book in the Algol tradition which taught how to think at the Edge City, where the user's problem meets the circuits. This book, like Wegner, teaches the same lessons. About its only flaw is that like many titles from Morgan Kaufmann, which seems to have an incestuous relationship with MIPS and the RISC kiddies, it overemphasizes clever optimization and completely downplays the importance of the stack model of computation, a RISCy tradition.
Rating:
Summary: A magnificent achievement--a bedrock of knowledge, for life
Review: I am in the process of reading this book for a review and already I am compelled (at the conclusion of chp. 7 of 13) to write a glowing review. This book truly is an achievement and it lives up to my predecessor's comments. I hasten to emphasize that this textbook combines form and content to a very high degree: it is written superbly with great clarity, the topics are organized extremely well and meaningfully, and finally it provides a comprehensive overview of all aspects of programming. In the course of my reading, I have never felt the need to skip sections; there are no sections that are abstruse or cursorily covered. All sections are integrated with the others and each section offers very useful knowledge. The author clearly displays a profound understanding of all aspects of his endeavor. I must emphasize that in the vast majority of cases with textbooks, in any academic area, the impression is that the author has intimate knowledge of 60% of the material he covers, and as for the latter 40% of the material he has at best good knowledge or passing familiarity but is able to speak on these topics because of his qualifications. The greatest merit of this book is that one can very profitably go through a self-study programme through all 13 chapters and come away much superior to one's peers in college or graduate school or industry (I qualify this statement at present: I have read only 7 chapters yet, but intend to read all 13). Finally, if you are familiar with the excellent book on Computer Architecture by Patterson and Hennesy, then I say that this book is on level par with that venerable textbook.
Rating:
Summary: A magnificent achievement--a bedrock of knowledge, for life
Review: I have always enjoyed reading programming-language and compiler books and most of them are quite tough on a first-read. Programming Language Pragmatics is one huge exception. None of the books I have read come close to the clarity that this book exhibits. On many occassions, the choice of words and presentation in this book has made me go 'Wow, I thought I already knew this stuff...' Besides core topics, it has interesting discussion like concurrency, data-abstraction (object-oriented) and non-imperative programming models (functional and logic). TOC (with my comments) Ch. 1 Introduction Ch. 2 Programming Language Syntax (theory of Regular Expression, Context-Free Grammars, Automata etc) Ch. 3 Names, Scopes, and Bindings (binding, scope rules, closures etc) Ch. 4 Semantic Analysis (attribute grammars, attribute flow, syntax tree etc) Ch. 5 Assembly-Level Computer Architecture (keeping the pipeline full, register allocation etc) Ch. 6 Control Flow (expression evaluation, iteration, recursion, nondeterminacy etc) Ch. 7 Data Types (type checking, pointers and recursive types etc) Ch. 8 Subroutines and Control Abstraction (stack layout, calling sequences, parameter passing etc) Ch. 9 Building a Runnable Program (back-end compiler structure, intermediate forms etc) Ch. 10 Data Abstraction and Object Orientation (encapsulation, inheritance, dynamic method binding, multiple inheritance, the object model of smalltalk) Ch. 11 Nonimperative Programming Models: Functional and Logic Languages Ch. 12 Concurrency (shared memory, message passing etc) Ch. 13 Code Improvement (peephole, redundancy elimination, data flow analysis, loop improvement, instruction scheduling, register allocation etc) App. A Programming Languages Mentioned App. B Language Design and Language Implementation This is a very impressive book; truly one of my best investments in books so far.
Rating:
Summary: Tough Topic - Crystal Clear Explanation
Review: I have always enjoyed reading programming-language and compiler books and most of them are quite tough on a first-read. Programming Language Pragmatics is one huge exception. None of the books I have read come close to the clarity that this book exhibits. On many occassions, the choice of words and presentation in this book has made me go 'Wow, I thought I already knew this stuff...' Besides core topics, it has interesting discussion like concurrency, data-abstraction (object-oriented) and non-imperative programming models (functional and logic). TOC (with my comments) Ch. 1 Introduction Ch. 2 Programming Language Syntax (theory of Regular Expression, Context-Free Grammars, Automata etc) Ch. 3 Names, Scopes, and Bindings (binding, scope rules, closures etc) Ch. 4 Semantic Analysis (attribute grammars, attribute flow, syntax tree etc) Ch. 5 Assembly-Level Computer Architecture (keeping the pipeline full, register allocation etc) Ch. 6 Control Flow (expression evaluation, iteration, recursion, nondeterminacy etc) Ch. 7 Data Types (type checking, pointers and recursive types etc) Ch. 8 Subroutines and Control Abstraction (stack layout, calling sequences, parameter passing etc) Ch. 9 Building a Runnable Program (back-end compiler structure, intermediate forms etc) Ch. 10 Data Abstraction and Object Orientation (encapsulation, inheritance, dynamic method binding, multiple inheritance, the object model of smalltalk) Ch. 11 Nonimperative Programming Models: Functional and Logic Languages Ch. 12 Concurrency (shared memory, message passing etc) Ch. 13 Code Improvement (peephole, redundancy elimination, data flow analysis, loop improvement, instruction scheduling, register allocation etc) App. A Programming Languages Mentioned App. B Language Design and Language Implementation This is a very impressive book; truly one of my best investments in books so far.
Rating:
Summary: If You want to make Your own general-purpose prog. language
Review: If You want to make Your own general-purpose programming language, firstly You make a conception of this language, You search lot of programming languages for usefull statements, think about new more usefull construction. etc. This book is summary of constructions existed in lot of languages, so it good jumpkit to make conceptions (not implementation) of your Faivourite Toy Language. But conceptions is the most part of language.
Rating:
Summary: Great book: well written, covers a lot, and up-to-date
Review: Not much to add ot the title line: it's a great book. The writing is clear, an awful lot of material is covered, and it is very up-to-date. For example, I liked a few sections on object-oriented languages. It's got pretty good explanations of the implementation internals of those. Which is rare, I'd say. Appel has something like that, but his books are barely readable, so again, this one is very helpful
| 
