Programming Books C Java PHP Python Learn more Browse Programming Books
Buy Used
$5.68
FREE Shipping on orders over $35.
Used: Very Good | Details
Sold by Go_Deals
Condition: Used: Very Good
Comment: No sign of writing, notes, or highlights in text. May have minor shelf wear on corners.
Add to Cart
Have one to sell? Sell on Amazon
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 Hardcover – October 25, 1999


See all 5 formats and editions Hide other formats and editions
Amazon Price New from Used from
Hardcover
"Please retry"
$30.99 $0.01

NO_CONTENT_IN_FEATURE

Shop the New Digital Design Bookstore
Check out the Digital Design Bookstore, a new hub for photographers, art directors, illustrators, web developers, and other creative individuals to find highly rated and highly relevant career resources. Shop books on web development and graphic design, or check out blog posts by authors and thought-leaders in the design industry. Shop now

Product Details

  • Hardcover: 858 pages
  • Publisher: Morgan Kaufmann; 1st edition (October 25, 1999)
  • Language: English
  • ISBN-10: 1558604421
  • ISBN-13: 978-1558604421
  • Product Dimensions: 9.6 x 7.7 x 1.7 inches
  • Shipping Weight: 3.2 pounds
  • Average Customer Review: 4.9 out of 5 stars  See all reviews (15 customer reviews)
  • Amazon Best Sellers Rank: #1,474,228 in Books (See Top 100 in Books)

Editorial Reviews

Amazon.com Review

As a textbook suitable for the classroom or self-study, Michael Scott's Programming Language Pragmatics provides a worthy tour of the theory and practice of how programming languages are run on today's computers. Clearly organized and filled with a wide-ranging perspective on over 40 different languages, this book will be appreciated for its depth and breadth of coverage on an essential topic in computer science.

With references to dozens of programming languages, from Ada to Turing and everything in between (including C, C++, Java, and Perl), this book is a truly in-depth guide to how code is compiled (or interpreted) and executed on computer hardware. Early chapters tend to be slightly more theoretical (with coverage of regular expressions and context-free grammars) and will be most valuable to the computer science student, but much of this book is accessible to anyone seeking to widen their knowledge (especially since recent standards surrounding XML make use of some of the same vocabulary presented here).

The book has a comprehensive discussion of compilation and linking, as well as how data types are implemented in memory. Sections on functional and logical programming (illustrated with Scheme and Prolog, which are often used in AI research) can expand your understanding of how programming languages work. Final sections on the advantages--and complexities--of concurrent processing, plus a nice treatment of code optimization techniques, round out the text here. Each chapter provides numerous exercises, so you can try out the ideas on your own.

Students will benefit from the practical examples here, drawn from a wide range of languages. If you are a self-taught developer, the very approachable tutorial can give you perspective on the formal definitions of many computer languages, which can help you master new ones more effectively. --Richard Dragan

Topics covered: A survey of today's programming languages, compilation vs. interpretation, the compilation process, regular expression and context-free grammars, scanners and parsers, names, scopes and bindings, scope rules, overloading, semantic analysis, introduction to computer architecture, representing data, instruction sets, 680x0 and MIPs architectures, control flow and expression evaluation, iteration and recursion, data types, type checking, records, arrays, strings, sets, pointers, lists, file I/O, subroutines, calling sequences and parameter passing, exception handling, coroutines, compile back-end processing, code generation, linking, object-oriented programming basics, encapsulation and inheritance, late binding, multiple inheritance, functional and logical languages, Scheme and Prolog, programming with concurrency, shared memory and message passing, and code optimization techniques.

Review

"Michael Scott's book could have been entitled: Why Programming Languages Work. It takes a fresh look at programming languages by bringing together ideas and techniques usually covered in disparate language design, compiler, computer architecture, and operating system courses. Its comprehensive and integrated presentation of language design and implementation illustrates and explains admirably the many deep and profitable connections among these fields."
-Jim Larus, Microsoft Research

"This book is the best and most complete
on this topic that I've seen until now."


-Klaus Ostermann, Darmstadt University of Technology

Customer Reviews

4.9 out of 5 stars
5 star
14
4 star
1
3 star
0
2 star
0
1 star
0
See all 15 customer reviews
The study of programming languages though skipped by most programmers is an essential element if you want to be a better programmer.
sameer borate
Beside in depth analysis of language design (e.g. OO-, functional-, imperative- and logical-languages) it gives some practical implementation advice/tips.
Jos van Roosmalen
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).
SVENSSON KURT

Most Helpful Customer Reviews

57 of 58 people found the following review helpful By Lars Tackmann on February 7, 2006
Format: Hardcover Verified Purchase
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.
1 Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
52 of 56 people found the following review helpful By Jos van Roosmalen on February 20, 2005
Format: Paperback
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.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
38 of 41 people found the following review helpful By Cher-Wah Tan on June 3, 2001
Format: Hardcover
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.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
23 of 24 people found the following review helpful By Dobes Vandermeer on July 12, 2000
Format: Hardcover
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.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again

Customer Images

Most Recent Customer Reviews


What Other Items Do Customers Buy After Viewing This Item?