Design Concepts in Programming Languages [Hardcover]

Franklyn Turbak (Author), David Gifford (Author), Mark A. Sheldon (Contributor)

Book Description

Publication Date: July 18, 2008 | ISBN-10: 0262201755 | ISBN-13: 978-0262201759

Key ideas in programming language design and implementation explained using a simple and concise framework; a comprehensive introduction suitable for use as a textbook or a reference for researchers.

Editorial Reviews

Review

Franklyn A. Turbak is an Associate Professor in the Computer Science Department at Wellesley College.

"There is a paucity of good graduate-level textbooks on the foundations of programming languages, no more than four or five in the last two decades. Nothing to compare with the profusion of excellent texts in the other core areas of computer science, such as algorithms or operating systems. This new textbook by Franklyn Turbak, David Gifford, and Mark Sheldon -- comprehensive, thorough, pedagogically innovative, impeccably written and organized -- greatly enriches the area of programming languages and will be an important reference for years to come."--Assaf Kfoury, Department of Computer Science, Boston University

(Assaf Kfoury )

"This book is an excellent, systematic exploration of ideas and techniques in programming language theory. The book carefully, but without wasting time on extraneous complications, explains operational and denotational semantic techniques, and their application to many aspects of programming language design. It will be of great value for graduate courses and for self study."--Gary T. Leavens, School of Electrical Engineering and Computer Science, University of Central Florida

(Gary Leavens )

"There is a paucity of good graduate-level textbooks on the foundations of programming languages, no more than four or five in the last two decades. Nothing to compare with the profusion of excellent texts in the other core areas of computer science, such as algorithms or operating systems. This new textbook by Franklyn Turbak, David Gifford, and Mark Sheldon comprehensive, thorough, pedagogically innovative, impeccably written and organized greatly enriches the area of programming languages and will be an important reference for years to come." Assaf Kfoury , Department of Computer Science, Boston University

About the Author

Hundreds of programming languages are in use today--scripting languages for Internet commerce, user interface programming tools, spreadsheet macros, page format specification languages, and many others. Designing a programming language is a metaprogramming activity that bears certain similarities to programming in a regular language, with clarity and simplicity even more important than in ordinary programming. This comprehensive text uses a simple and concise framework to teach key ideas in programming language design and implementation. The book's unique approach is based on a family of syntactically simple pedagogical languages that allow students to explore programming language concepts systematically. It takes as premise and starting point the idea that when language behaviors become incredibly complex, the description of the behaviors must be incredibly simple. The book presents a set of tools (a mathematical metalanguage, abstract syntax, operational and denotational semantics) and uses it to explore a comprehensive set of programming language design dimensions, including dynamic semantics (naming, state, control, data), static semantics (types, type reconstruction, polymporphism, effects), and pragmatics (compilation, garbage collection). The many examples and exercises offer students opportunities to apply the foundational ideas explained in the text. Specialized topics and code that implements many of the algorithms and compilation methods in the book can be found on the book's Web site, along with such additional material as a section on concurrency and proofs of the theorems in the text. The book is suitable as a text for an introductory graduate or advanced undergraduate programming languages course; it can also serve as a reference for researchers and practitioners.

"This book is an excellent, systematic exploration of ideas and techniques in programming language theory. The book carefully, but without wasting time on extraneous complications, explains operational and denotational semantic techniques, and their application to many aspects of programming language design. It will be of great value for graduate courses and for self study." Gary T. Leavens , School of Electrical Engineering and Computer Science, University of Central Florida

David K. Gifford is Professor of Computer Science and Engineering at MIT.

Product Details

• Reading level: Ages 18 and up
  
• Hardcover: 1352 pages
• Publisher: The MIT Press (July 18, 2008)
• Language: English
• ISBN-10: 0262201755
• ISBN-13: 978-0262201759
• Product Dimensions: 9.1 x 8.3 x 2.1 inches
• Shipping Weight: 5.2 pounds (View shipping rates and policies)
• Average Customer Review: 5.0 out of 5 stars  See all reviews (4 customer reviews)
• Amazon Best Sellers Rank: #688,585 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

Most Helpful Customer Reviews

26 of 26 people found the following review helpful:

5.0 out of 5 stars An outstanding treatment of programming language theory, March 22, 2009

By 

Evgeny Kirpichov - See all my reviews
(REAL NAME)   

Amazon Verified Purchase

This review is from: Design Concepts in Programming Languages (Hardcover)

The book is about various concepts encountered in various kinds of programming languages: denotational and operational (BOS/SOS) semantics, issues of state and control, type systems, modules, modeling effects and compilation.
Every concept is introduced by defining the semantics of a language that has this concept and exploring the design dimensions and issues of this concept and language.
Concepts are gradually accumulated, and by the time you reach the chapter on modules you've got a CBV language with records, mutable state, polymorphic algebraic data types, a System F type system with type inference and a hint of dependent types, abstract data types and first-class dynamically loadable modules.

The tools used for description are of course the good old denotational and operational semantics and typing judgements and derivation trees; but each element of those is clearly and succintly described in text; it happens to me all the time that I am reading a type reconstruction algorithm and wondering, "why does this rule have that restriction?" and it immediately turns out that in the next paragraph, the authors focus attention on why this rule has that restriction; just like if they were reading my thoughts.
That's why this book feels very comfortable to me: I am absolutely sure that I won't encounter a point where I am lost and buried under the notation; but there is also not a single boring moment.

I've been interested in functional programming and PL theory for 2-3 years already, and here's a brief list of the *new* things that I have learned, at least:
- What do SOS and BOS mean, and why one should care, and what properties a SOS might posess (confluence and normalization, for instance)
- How many features of languages can be defined in terms of simply desugaring, and how in some cases they can't
- How one might use monadic style in the semantics metalanguage to greatly simplify the semantic rules for monadic concepts like state, control and error handling (the authors mention the word "monad" only once, but they use return- and bind-like operators in their semantics)
- How powerful records are, and of what use are operators like "conceal"
- What use is subtyping outside of OOP
- How does one define CPS-style semantics and how such a style allows to add state, control and errors with minimal changes
- How small yet powerful an OOP language core can be
- How algebraic datatypes can be very useful even in a language without static typing
- How pattern matching can be desugared into CPS-style deconstructors
- How many caveats are there in defining typing rules, and how a small change in them can lead to very big changes in language expressiveness
- How HM type inference actually works
- Why purity is important for certain polymorphism issues
- What let-polymorphism means
- What effect systems are
- How effect reconstruction works and how it is different from type reconstruction in nature
- How effect inference can prove the external purity of certain internally impure programs
That's where I finished my reading for now. The remaining looks even more intriguing; for example, I don't (yet) know how functional languages are compiled and how register allocation is done.

I'm afraid to sound like a salesman, but this is absolutely the best-written technical book I have ever seen in my life, and probably the most influential one for me, excluding maybe SICP.

11 of 13 people found the following review helpful:

5.0 out of 5 stars well worth the price, January 19, 2009

By 

S. Saha (Manhattan, NY United States) - See all my reviews
(REAL NAME)   

This review is from: Design Concepts in Programming Languages (Hardcover)

If you want to pursue PL in any detail, you might as well buy this book now because very soon most schools are going to start using it/recommending it as a text in grad-level intro PL courses. I used Winskell in grad school and had forgotten most of it. This book is definitely more accessible and covers a lot more material and is much more up-to-date with current research. It's a lot of fun to read and I predict its going to become *the* book in its field very shortly.

10 of 13 people found the following review helpful:

5.0 out of 5 stars Fantastic book!, February 18, 2009

By 

Josip Gracin (Croatia) - See all my reviews
(REAL NAME)   

This review is from: Design Concepts in Programming Languages (Hardcover)

Really wonderful book, well-written, easy to read, covers many topics. Very formal and yet so readable. All code within the book is written in s-exps syntax, and the book covers topics such as type inference, monads etc. Need I say more? :-)