CDN$ 68.25
  • List Price: CDN$ 74.15
  • You Save: CDN$ 5.90 (8%)
Usually ships within 4 to 6 weeks.
Ships from and sold by
Gift-wrap available.
Have one to sell?
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See this image

Programming Language Pragmatics Paperback – Nov 7 2005

See all 3 formats and editions Hide other formats and editions
Amazon Price New from Used from
Kindle Edition
"Please retry"
"Please retry"
CDN$ 68.25
CDN$ 50.93 CDN$ 21.81

There is a newer edition of this item:

Programming Language Pragmatics
CDN$ 69.32
In Stock.

2014 Books Gift Guide
Thug Kitchen, adapted from the wildly popular web site beloved by Gwyneth Paltrow ("This might be my favorite thing ever"), is featured in our 2014 Books Gift Guide. More gift ideas

Special Offers and Product Promotions

  • Join Amazon Student in Canada

Customers Who Bought This Item Also Bought

Hero Quick Promo
Boxing Day Kindle Deals
Load your library with over 30 popular fiction books and more, today only. Learn more

Product Details

Product Description

Book Description

The most comprehensive and accessible Programming Language text

About the Author

Michael L. Scott is a professor in the University of Rochester’s Department of Computer Science, which he chaired from 1996 to 1999. He is the designer of the Lynx distributed programming language and a co-designer of the Charlotte and Psyche parallel operating systems, the Bridge parallel file system, the Cashmere distributed shared memory system, and the MCS mutual exclusion lock. He received his Ph.D. from the University of Wisconsin-Madison in 1985.

Inside This Book (Learn More)
Browse Sample Pages
Front Cover | Copyright | Table of Contents | Excerpt | Index
Search inside this book:

Customer Reviews

There are no customer reviews yet on
5 star
4 star
3 star
2 star
1 star

Most Helpful Customer Reviews on (beta) 10 reviews
43 of 45 people found the following review helpful
Probably the best book in the "Survey of Programming Languages" genre Feb. 23 2006
By Andrei Formiga - Published on
Format: Paperback
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.
6 of 6 people found the following review helpful
Very Good Book July 20 2007
By David A. Lessnau - Published on
Format: Paperback Verified Purchase
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.
2 of 2 people found the following review helpful
Solid introduction to programming language concepts Jan. 7 2009
By Ada - Published on
Format: Paperback
This book offers a good introduction to basic programming language concepts: scanning/lexical analysis, parsing, semantic analysis, and several other compilation phases. It covers functional languages as well. It's easy to follow too.
8 of 12 people found the following review helpful
Good, not recommended for newbies on their own Jan. 5 2009
By Seth Schroeder - Published on
Format: Paperback
I bought this book hoping for a thorough yet pragmatic guide to teach myself from scratch how to write the front half or so of a compiler. I don't recommend this book for that intent. It's just too high level to be the sole source of instruction.

Chapter two dedicates 9-10 pages for scanning. I'm not looking for endless checklists of minutia, but in that 10 pages why spend time on optimizing a DFA? Is that pragmatic?

About 30 pages of chapter two are spent on parsing, and a decent chunk of that is used for figures. To me that speaks of a text intended to accompany an oral presentation. I have no access to such a lecture -- just the book.

The rest of the book covers many many subjects. I look forward to using Programming Language Pragmatics as a reference in the future. But not for teaching oneself to write the front half of a compiler.
Programming Language Pragmatics 2nd ed review Oct. 9 2014
By Javier - Published on
Format: Paperback Verified Purchase
If you don’t know how programming languages work, I would say this is your book. It contains plenty of examples in different languages. It explains the trade-offs and internals in a very accessible language. The way to explain the different compiler stages and features is very natural. If you are looking for a concrete topic it is in the book.

On the other hand, the book contains complementary stuff in a CD. Along the book some topics are covered in digital content only. One extreme case is the last chapter “Code Improvement”, it is digital entirely. It would be great if all chapters had a minimal ‘core’ of content. By the way, the bibliography would be more useful in digital format only.

Great book on programming languages!