Essentials of Programming Languages

Essentials of Programming Languages

3.92 (113 ratings by Goodreads)
By (author)  , By (author)  , By (author)  , Foreword by 

List price: US$70.01

Currently unavailable

Add to wishlist

AbeBooks may have this title (opens in new window).

Try AbeBooks


What really happens when a program runs? "Essentials of Programming Languages" teaches the fundamental concepts of programming languages through numerous short programs, or "interpreters" that actually implement the features of a language. Nearly 300 exercises using these programs provide a hands-on undertanding of programming principles that is hard, if not impossible, to achieve by formal study alone. In an approach that is uniquely suited to mastering a new level of programming structure, the authors derive a sequence of interpreters that begins with a high-level operational specification (close to formal semantics) and ends with what is effectively assembly language - a process involving programming transformation techniques that should be in the toolbox of every programmer. The first four chapters provide that foundation for an in-depth study of programming languages, including most of the features of Scheme, needed to run the language-processing programs of the book. The next four chapters form the core of the book, deriving a sequence of interpreters ranging from very high- to very low-level.
The authors then explore variations in programming language semantics, including various parameter-passing techniques for transforming interpreters that ultimately allow the interpreter to be implemented in any low-level language. They conclude by discussing scanners and parsers and the derivation of a compiler and virtual machine from an interpreter.
show more

Product details

  • Hardback | 568 pages
  • 200.7 x 223.5 x 25.4mm | 1,020.59g
  • MIT Press
  • Cambridge, Mass., United States
  • English
  • 160
  • 0262061457
  • 9780262061452

Table of contents

Part 1 Tools for symbolic programming: simple expressions; data types; procedures. Part 2 Induction, recursion and scope: inductively specified data; recursively specified programs; statis properties of variables. Part 3 Syntactic abstraction and data abstraction: local binding; logical connectives; branching; records; data abstraction; from procedural to data structure representations. Part 4 Reduction rules and imperative programming: reasoning about procedures; the Lambda calculus and Beta-conversion; reduction strategies; defining recursive procedures in the Lambda calculus; sequencing and imperative programming; variable assignment and sharing; streams. Part 5 Interpreters: a simple interpreter; conditional evaluation; local binding; procedures; variable assignment; recursion; dynamic scope and dynamic assignment. Part 6 Parameter passing: adding arrays; call-by-reference; call-by-value-result and call-by-result; expressed or denoted values? call-by-name and call-by-need; optional and keyword arguments. Part 7 Object-oriented languages: objects and classes; inheritance; meta-classes. Part 8 Continuation-passing style: iterative control behaviour and proper tail recursion; introduction to continuation-passing style; tail form; converting to continuation-passing style; examples of the CPS transformation; implementing the CPS transformation; call chains. Part 9 Continuation-passing interpreters: data structure representations of continuations; the continuation interpreter; making continuations available to the programmer; upward continuations and coroutines; leaving and entering control contexts; dynamic assignment revisited. Part 11 Imperative form and stack architecture: imperative form; control stacks; interpreter stack architecture; stack allocation of continuations and environments. Part 12 Scanners and parsers: lexical scanning using finite automata; simulating a scanning automation; constructing a predictive parser; recursive descent parsers; table driven parsers. Part 12 Compiler derivation: deriving a compiler and machine from an interpreter; register allocation; obtaining more realistic object code; compiling procedures. Appendices: record implementation; abstract syntax; character string syntax; character string parser; character string scanner; a read-eval-print loop; list structure syntax; list structure parser; scheme procedures used.
show more

Review quote

"Friedman, Wand, and Haynes have done a landmark job.... The sample interpreters in this book are outstanding models. Indeed, since they are runnable models, I'm sure that these interpreters will find themselves at the cores of many programming systems over the years."--from the foreword by Hal Abelson
show more

Rating details

113 ratings
3.92 out of 5 stars
5 36% (41)
4 34% (38)
3 19% (22)
2 8% (9)
1 3% (3)
Book ratings by Goodreads
Goodreads is the world's largest site for readers with over 50 million reviews. We're featuring millions of their reader ratings on our book pages to help you find your new favourite book. Close X