- Paperback: 912 pages
- Publisher: Morgan Kaufmann Publishers In; 2nd Revised edition edition (21 Nov 2005)
- Language English
- ISBN-10: 0126339511
- ISBN-13: 978-0126339512
- Product Dimensions: 22.9 x 18.8 x 3.6 cm
- Amazon Bestsellers Rank: 912,340 in Books (See Top 100 in Books)
- See Complete Table of Contents
| |||||||||||||||
Did you know you can trade in your old books for an Amazon.co.uk Gift Card to spend on the things you want? Plus, get an extra £5 Gift Certificate when you trade in books worth £10 or more before June 30, 2012. Visit the Books Trade-In Store for more details. |
|
There is a newer edition of this item:
|
Product details |
Product Description
Product Description
Thoroughly updated to reflect the most current developments in language design and implementation, this 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. It 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; and, major languages: Perl, PHP, Tcl/Tk, Python, Ruby, JavaScript and XLST. It updates many sections and topics: iterators, exceptions, polymorphism, templates/generics, scope rules and declaration ordering, separate compilation, garbage collection, and 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; and, 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; and, 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; and, 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; and, lecture slides prepared by other instructors. This work addresses the most recent developments in programming language design, including C99, C#, and Java 5. It Introduces and discusses scripting languages throughout the book as well as in an entire new chapter. It includes a comprehensive chapter on concurrency, with coverage of the new Java concurrency package (JSR 166) and the comparable mechanisms in C#. This work 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 include: 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; and, includes over 800 numbered examples to help the reader quickly cross-reference and access content.
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)
Tag this product(What's this?)Think of a tag as a keyword or label you consider is strongly related to this product.
Tags will help all customers organise and find favourite items. |
Customer Reviews
There are no customer reviews yet on Amazon.co.uk.
5 star
4 star
3 star
2 star
1 star
Most Helpful Customer Reviews on Amazon.com (beta)
Amazon.com:
7 reviews
42 of 44 people found the following review helpful
Probably the best book in the "Survey of Programming Languages" genre
23 Feb 2006
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.
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
20 July 2007
Format:Paperback|Amazon 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.
"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
7 Jan 2009
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.
Were these reviews helpful?
Let us know
Listmania!
Look for similar items by category
Look for similar items by subject
Feedback
- Would you like to update product info or give feedback on images?
- I am the Author, and I want to comment on my book.
- I am the Publisher, and I want to comment on this book.
