A type system is a syntactic method for automatically checking the absence of certain erroneous behaviors by classifying program phrases according to the kinds of values they compute. The study of type systems--and of programming languages from a type-theoretic perspective -- -has important applications in software engineering, language design, high-performance compilers, and security.This text provides a comprehensive introduction both to type systems in computer science and to the basic theory of programming languages. The approach is pragmatic and operational; each new concept is motivated by programming examples and the more theoretical sections are driven by the needs of implementations. Each chapter is accompanied by numerous exercises and solutions, as well as a running implementation, available via the Web. Dependencies between chapters are explicitly identified, allowing readers to choose a variety of paths through the material.The core topics include the untyped lambda-calculus, simple type systems, type reconstruction, universal and existential polymorphism, subtyping, bounded quantification, recursive types, kinds, and type operators. Extended case studies develop a variety of approaches to modeling the features of object-oriented languages.

Average Customer Review: ( 7 customer reviews )
Write an online review and share your thoughts with other customers.

On the one hand, it offers excellent grounding: practical motivation is provided, numerous examples illustrate the concepts, and implementations are provided which can be used to typecheck and evaluate these examples. At various points, extended demonstrations of the type systems under consideration are given (e.g. showing how objects may be encoded). The exercises are well constructed and in many cases, accompanied with answers and detailed explanations in the appendix.

On the other hand, it offers an excellent exposition of the material: Pierce provides a lucid account of the static and dynamic semantics (primarily small-step operational) for various lambda calculi. He proceeds in a stepwise fashion via the gradual accretion of features: from first order (simply typed) systems to higher order systems incorporating bounded subtyping and recursion. He also gives attention to the metatheory of these systems (focusing on proofs of progress and preservation, and for systems with subtyping, of decideability). Internally, the text is well organized, with clear dependencies among the chapters, and the bibliography is extensive.

It should be noted that, while reasonably comprehensive, the text is necessarily limited in scope. For example, aside from the discussion on Featherweight Java, systems other than typed lambda calculus variants are not considered. In my opinion, the focus on these (in some sense "low-level") calculi makes foundational issues more apparent, and the linear progression from simple to complex variants lends a pleasant cohesiveness that would have been lost in a more general survey. However, as object/class encodings were discussed at various points, it would have been nice to see a more integrated presentation, in the spirit of the paper Comparing Object Encodings [BCP97].

20 of 20 found the following review helpful:

Just rightJun 03, 2007
By Jason Orendorff
This is a textbook about programming language theory, somewhat mathematical-- but it's must-read material for anyone who wants to gripe about programming languages cluefully, much less design them.

For me, this book strikes exactly the right balance between theory and practicality. Chapters on the mathematical properties of various tiny programming languages are interleaved with chapters that provide annotated implementations of those languages.

The book will also give you the background (notation and terminology) you'll need to read cutting-edge research papers on programming language theory.

This book contains all the information I was missing. Excellent presentation of the material, well written, great exercises, doesn't go off into lala-land. Highly recommended. Some math background very helpful (you need to know what a mathematical proof is).

8 of 8 found the following review helpful:

Excellent bookApr 06, 2008
By agentzh
Writing baby interpreters using OCaml for the funny languages (include lambda calculus!) used in the theoretic chapters is a pretty cool idea and I really like it.

Elementary discrete mathematics and first-order logic are required for grokking the maths materials through out the book though. If you don't have enough patience to deal with math symbols, theorems, and formal proving, then this is not the right book for you ;)

IHMO, this is a highly comprehensible book for introducing lambda-calculus and type theory to readers without much background knowledge in either abstract algebra or theoretic computer science (like me ;)). I've been looking for such a book for long, in fact :)

Besides, this was the very book which directly inspired the birth of Pugs (a Perl 6 interpreter/compiler in Haskell) according to Audrey, the Pugs project's leader.

Highly recommended!

17 of 20 found the following review helpful:

Well put, practical and theoretic book on types.Dec 21, 2004
By S. van den Berg "Functional programmer"
Extremely well written book on type systems in programming languages. Uses lambda calculus to explain type systems. Practical aspects show up in the ML implementations downloadable on the books site.

Contains a lot of programming language theory besides just type-systems. Can be used as an introductionary book to programming language design. Concluding: Great book!

44 of 64 found the following review helpful:

Not quite what I was looking forJun 12, 2005
By wiredweird "wiredweird"
I need basic information on type safety, theory of object oriented typing, and how to axiomatize nonstandard kind of typing systems. I need it now, in a form that I can put to use without too many side trips

This book is almost what I was looking for. It builds up a semantic logic based on lambda calculus, then creates typed versions. Pierce really does work very methodically up through the levels, ending at about the place where C++ templates and recursive type definitions start. Along the way, he's careful to match the typing axioms to semantics, covering unusual topics like exceptions and type inference while he's at it.

Almost what I was looking for, but not quite. As I said, I have immediate needs, and I'm not into theory for its own sweet sake. That means I had little appreciation for all the chapters that created arithmetic all over again, starting from Peano axioms (or something like), via the lambda calculus. I know that low-level axiomatizations and lambda calculus are much beloved of the theoreticians, but I encounter them only rarely, and when I was trying to get something else done, like now. For me, they created a diversion blocked by an impediment. Also, however convenient it may be for theory, functional programming is mostly a journal-page peculiarity in industrial practice. I admit, analysis of functional programs pushed me into insight I might have missed, but I would probably have been quite happy dealing with assignment formalisms instead.

I almost gave this three stars, because its unnecessary notational baggage and off-main-stream topics weren't doing my job. Bruce's book (ISBN 026202523X) was a much more profitable use of my time. Still, Pierce's goals weren't mine, and the mansion of type analysis has many rooms. Not all of those rooms are furnished to my taste, and don't need to be. I rounded up to four stars for what it meant to do.

//wiredweird

See all 7 customer reviews on Amazon.com