Over the years the Compilers: Principles, Techniques, and Tools (2nd Edition) (also knwon as 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.

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, Programming Languages, 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.

This is must read for every compiler engineer.

This book is 800+ pages of theory behind language design and processing of languages.

Altought it is very theoretical, it's very easy to read and well written and a pleasure to read. There are a lot of examples/figures/tables etc to explain things. I recommend people which are totally new to language design/compiler design to first read an introduction text. I can really recommend 'programming language processors in java' from Watt and Brown. This is a really good book.

The title of the book suggest that this book will only cover Language Design. In reality chapter 2, 3,4 and 5 covers in depth resp. Syntax checking (parsing), Names/Scope/Binding, Semantic Analysis and processor architecture.

Beside in depth analysis of language design (e.g. OO-, functional-, imperative- and logical-languages) it gives some practical implementation advice/tips. E.g. there are only a few compilerbooks which seriously talks about the different parsing error recovery techniques. This book explain some different recovery methods. Probably error recovery is not scientific enough for the other books, but for a compiler user error recovery is really important.

A last tip: this book comes in 2 editions: a paperback and hardcover edition. If you want to save some money buy the paperback.

Scott is a marvelous teacher. The book covers everything from language syntax to functional programming with ease and depth. The study of programming languages though skipped by most programmers is an essential element if you want to be a better programmer.
The exercises given at the end of chapters are excellent and will reinforce your understanding. At a time when programming languages are proliferating at an amazing rate, it is essential you know how to compare the various aspects of different languages and choose the one most suitable for your work. Studying this will help you in that endeavour.
Get this book, but better read it.

This is a very high quality text/reference book. I feel that I have my money and time well spent. The author's writing style is precise yet accessible. And his model and mindset about explaining programming languge design has been consitent all through -- always about the intricate relations and interactions among those three facets in a language design (syntactic, semantic and pragmatic). This treatment of the subject, in my view, reflects real dynamics of language design, and also makes the text more pratically useful for readers while laying out solid conceptual fundation at the same time. I am looking forward for the next edition, which I am sure that author will include discussion of more recent language examples like C# and XML.

The best (only?) book on the subject of PLs that ties abstract concepts directly to practice. Clear, concise and incredibly thorough in both breadth and depth. A rare pleasure...

This book covers how common imperative languages
implement various programming features. Very extensive.

If you want to know how Algol, pascal,
C/C++, Java are implemented, then
this book is for you.

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

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.

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.

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.

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

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.