To use our price comparison to get the cheapest price, please click on the "Find the Cheapest Price" button located above for Programming Language Pragmatics, Second Edition by Michael L. Scott (ISBN-10: 0126339511, ISBN-13: 9780126339512).
At this time we have not yet written a review for Programming Language Pragmatics, Second Edition by Michael L. Scott (ISBN-10: 0126339511, ISBN-13: 9780126339512). Please continue to keep checking back to this page as we are constantly adding reviews.
Summaries and Customer Reviews are supplied by Amazon.com
Thoroughly updated to reflect the most current developments in language design and implementation, the second edition
*Addresses key developments in programming language design:
+ Finalized C99 standard
+ Java 5
+ C# 2.0
+ Java concurrency package (JSR 166) and comparable mechanisms in C#
+ Java and C# generics
*Introduces and discusses scripting languages throughout the book and in an entire new chapter that covers:
+ Application domains: shell languages, text processing and report generation, mathematics and statistics, "glue" languages and general purpose scripting, extension languages, scripting the World Wide Web
+ Design concepts: names and scopes, string and pattern manipulation, high level data types, object orientation
+ Major languages: Perl, PHP, Tcl/Tk, Python, Ruby, JavaScript, XLST
*Updates many sections and topics:
+ iterators
+ exceptions
+ polymorphism
+ templates/generics
+ scope rules and declaration ordering
+ separate compilation
+ garbage collection
+ threads and synchronization
New pedagogical features
Design & Implementation boxes
+ Highlight the interplay between language design and language implementation
Test Your Understanding review questions
+ Help students assess their understanding of key points of a section
In More Depth CD supplements
+ Present more advanced or peripheral material for students who would like to extend their knowledge
Explorations
+ Provide students with additional exercises that are open-ended, research-type activities
New reference features
+ Over 900 numbered and titled examples help the student to quickly cross-reference and access content for initial study and later review.
+ Indices (in the printed text) for both the Design and Implementation boxes and the numbered examples.
+ CD search engine for both the printed text and the supplemental sections.
+ Live links on the CD to Web-based language tutorials, reference manuals, and compilers and interpreters.
On the CD
+ In More Depth sections and sub-sections that are introduced in the book and presented on the CD
+ In More Depth Exercises and Explorations for students wanting additional challenges
+ Links to Web-based language reference manuals and tutorials
+ Links to Web-based compilers and interpreters
+ Text files containing the code fragments featured as examples in the book
+ Search engine to search both the main text and the CD-only content
CD System Requirements
PDF Viewer
The CD material includes PDF documents that you can read with a PDF viewer such as Adobe, Acrobat or Adobe Reader. Recent versions of Adobe Reader for some platforms are included on the CD.
HTML Browser
The navigation framework on this CD is delivered in HTML and JavaScript. It is recommended that you install the latest version of your favorite HTML browser to view this CD. The content has been verified under Windows XP with the following browsers: Internet Explorer 6.0, Firefox 1.5; under Mac OS X (Panther) with the following browsers: Internet Explorer 5.2, Firefox 1.0.6, Safari 1.3; and under Mandriva Linux 2006 with the following browsers: Firefox 1.0.6, Konqueror 3.4.2, Mozilla 1.7.11.
The content is designed to be viewed in a browser window that is at least 720 pixels wide. You may find the content does not display well if your display is not set to at least 1024x768 pixel resolution.
Operating System
This CD can be used under any operating system that includes an HTML browser and a PDF viewer. This includes Windows, Mac OS, and most Linux and Unix systems.
Instructor support
+ Password-protected site for adopters who request the password from a sales representative
+ Solutions to most exercises
+ Figures from the book in several formats
+ Lecture slides prepared by other instructors
New Coverage:
* Addresses the most recent developments in programming language design, including C99, C#, and Java 5.
* Introduces and discusses scripting languages throughout the book as well as in an entire new chapter.
* Includes a comprehensive chapter on concurrency, with coverage of the new Java concurrency package (JSR 166) and the comparable mechanisms in C#.
* Updates many sections and topics, including iterators, exceptions, polymorphism, templates/generics, scope rules and declaration ordering, separate compilation, garbage collection, and threads and synchronization.
New Pedagogical Features:
* Highlights the interaction and tradeoffs inherent in language design and language implementation decisions with over 100 "Design and Implementation" call-out boxes.
* Adds end-of-chapter "Exploration" exercises-open-ended, research-type activities.
* Provides review questions after sections for quick self-assessment.
* Includes over 800 numbered examples to help the reader quickly cross-reference and access content.
Incredible knowledge in a fairly small book.
| Customer Rating:  | Programming Language Pragmatics 2nd Edition (PLP2e) is a fantastic book that covers a great deal of information. It starts with explaining lexing and parsing, and then goes into scope, target machine instructions, control flow, data structures, a number of paradigms, and building a runnable program. It touches on pretty much every aspect of computer programming, and with deep and insightful knowledge.
While it's not as specific as some other books (language specific references, compiler construction texts, etc), it is a great beginning and reference for a wide range of topics. The bibliography of this book is incredible. I have marked a large number of papers/books from the bib that I now want to read in full.
The bonus information on the CD is also very good, including all the source code from the book, extra sections, and links to other resources. |
Very Good Book
| Customer Rating:  | 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
| Customer Rating: | | 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.
| Customer Rating: | | 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
| Customer Rating: | 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. |
|
