This textbook offers a deep understanding of the essential concepts of programming languages. The approach is analytic and hands-on. The text uses interpreters, written in Scheme, to express the semantics of many essential language elements in a way that is both clear and directly executable. It also examines some important program analyses. Extensive exercises explore many design and implementation alternatives.
 |
| ||||||||||||||||||
New! Introducing the tech.book(store), a hub for Software Developers and Architects, Networking Administrators, TPMs, and other technology professionals to find highly-rated and highly-relevant career resources. Shop books on programming and big data, or read this week's blog posts by authors and thought-leaders in the tech industry. > Shop now |
|
There is a newer edition of this item:
|
Book Description
Editorial Reviews
Review
"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 --This text refers to an out of print or unavailable edition of this title.
About the Author
Daniel P. Friedman is Professor of Computer Science at Indiana University and is the author of many books published by the MIT Press, including The Little Schemer (fourth edition, 1995), The Seasoned Schemer (1995), A Little Java, A Few Patterns (1997), each of these coauthored with Matthias Felleisen, and The Reasoned Schemer (2005), coauthored with William E. Byrd and Oleg Kiselyov.
Mitchell Wand is Professor of Computer Science at Northeastern University.
Christopher T. Haynes is Associate Professor of Computer Science at Indiana University.
Mitchell Wand is Professor of Computer Science at Northeastern University.
Christopher T. Haynes is Associate Professor of Computer Science at Indiana University.
Product Details
Would you like to update product info or give feedback on images? |
More About the Author
Discover books, learn about writers, read author blogs, and more.
Customer Reviews
Share your thoughts with other customers
Most Helpful Customer Reviews
31 of 32 people found the following review helpful
By Ravi Mohan
Format:Hardcover
This book is invaluable to someone who is trying to understand how computer languages really work.
The Good
1. Very comprehensive .Covers a whole gamut of programming language features.By the time you finish the book you will have built interpreters which demonstrate recursion, call-by-value/reference/need and name semantics, class based and prototype based OO, type inference ,Continuations etc .
2. Very "Hands on" . You are taught how programming languages work by actually building intrepreters (in other words an Operational Semantics is used) .This is the best way to learn .
3.Environments and Continuations are explained extremely well.
4.Lots of exercises which explore design alternatives . For example the main flow deals with lexical binding of variables, with dynamic binding left as an exercise.
The Bad
1. A certain knowledge of scheme (let letrec, cond) etc is assumed (The First edition was better in this respect and was more self contained)
2.The writing is sometimes unnecessarily dense with long sentences and slighly disjonted paragraphs.
3.some essential features of a language design (eg: memory management ) are skipped entirely.While this is understandable from the pov of reducing the length of the book, it also means that one needs to read supplementary material before one can write real life interpreters.
4.Some parts of the interpretation/compilation process are skipped entirely or treated through "magic". For example the book provides practically no explanation of lexing or parsing and some "magic " code (SLLGEN) is used .The examples for using this framework are thoroughly inadequate.It is better to skip using this framework and just use list syntax and the read functionality of scheme .
Summary
With all its faults (which will probably get fixed in the next edition ) this is an incredible book and should be part of the library of every programmer interested in learning how languages work. As far as i know there isn't a single other book that can do better in conveying how various features of languages really work and interact .
While this book may not be suitable for an undergraduate course of study(withoout an excellent teacher to help students get ove r the difficult bits) it is ideal for the self taught programmer .
If you don't mind reading extra material/browsing the web to supplement this book, just buy it.
The Good
1. Very comprehensive .Covers a whole gamut of programming language features.By the time you finish the book you will have built interpreters which demonstrate recursion, call-by-value/reference/need and name semantics, class based and prototype based OO, type inference ,Continuations etc .
2. Very "Hands on" . You are taught how programming languages work by actually building intrepreters (in other words an Operational Semantics is used) .This is the best way to learn .
3.Environments and Continuations are explained extremely well.
4.Lots of exercises which explore design alternatives . For example the main flow deals with lexical binding of variables, with dynamic binding left as an exercise.
The Bad
1. A certain knowledge of scheme (let letrec, cond) etc is assumed (The First edition was better in this respect and was more self contained)
2.The writing is sometimes unnecessarily dense with long sentences and slighly disjonted paragraphs.
3.some essential features of a language design (eg: memory management ) are skipped entirely.While this is understandable from the pov of reducing the length of the book, it also means that one needs to read supplementary material before one can write real life interpreters.
4.Some parts of the interpretation/compilation process are skipped entirely or treated through "magic". For example the book provides practically no explanation of lexing or parsing and some "magic " code (SLLGEN) is used .The examples for using this framework are thoroughly inadequate.It is better to skip using this framework and just use list syntax and the read functionality of scheme .
Summary
With all its faults (which will probably get fixed in the next edition ) this is an incredible book and should be part of the library of every programmer interested in learning how languages work. As far as i know there isn't a single other book that can do better in conveying how various features of languages really work and interact .
While this book may not be suitable for an undergraduate course of study(withoout an excellent teacher to help students get ove r the difficult bits) it is ideal for the self taught programmer .
If you don't mind reading extra material/browsing the web to supplement this book, just buy it.
42 of 45 people found the following review helpful
Format:Hardcover
I took Friedman's undergraduate Programming Languages course at Indiana University and though this book was the required text
Friedman used it sparingly, as did I. It's full of formal programming language theory and enough EBNF grammars to satisfy the purist while confusing the practioner. To Friedman's credit, he is realistic about the book's audience (graduate,doctoral, and post-doctoral) and about the prevalence of Scheme outside of academia.
Friedman used it sparingly, as did I. It's full of formal programming language theory and enough EBNF grammars to satisfy the purist while confusing the practioner. To Friedman's credit, he is realistic about the book's audience (graduate,doctoral, and post-doctoral) and about the prevalence of Scheme outside of academia.
The chapters on continuations and object oriented programming, however, are quite accessible and interesting reading. Though he doesn't do it much in the book, Friedman decoupled the course from Scheme several times and we examined everything from C's setjmp, longjmp mechanisms to C++'s virtual method lookup implementation.
Word of advice to those taking a course taught by Friedman: Don't miss a single lecture or you will be hopelessly lost.
Buy this book if you are interested in formal programming language theory. Don't buy this book if you are interested in learning a specific language or are put off by a dense, rigorous approach to learning programming languages. In any event, best
of luck with your studies.
21 of 24 people found the following review helpful
By A Customer
Format:Hardcover
I've used this book to teach an undergraduate programming language for 4 years now. I believe it to be the finest text in the area because of its approach to the subject. Many books in this area are what I call smorgasborg books--leading the reader through one language syntax after another without ever getting to what really matters: programming language operation. In EoPL, Freidman, Wand, and Haynes solve this problem by using a standard technique of computer science: using the right langauge for the job. In this case the job is progrmaming language operation and the language is Scheme. Don't be fooled into thinking you're learning Scheme--you're actually learning a great deal about programming languages along the way.
The book covers the operational semantics of the most important features in programming languages and give users a clear understanding of the infrastructure of programming langauges along the way. Highly recommended.
See http://lal.cs.byu.edu/cs330 for a course based on this book.
Most Recent Customer Reviews
5.0 out of 5 stars
very methodical and simple
its really a nice book to start with functional programming and thinkin in terms of recursion. you can easily write a cool interpreter by following this book cover to .... Read more
Published on March 2, 2006 by Rajesh Kumar
4.0 out of 5 stars
Good balance of formal and layman language
I enjoyed this book's implementation-oriented approach to teaching language constructs, in the tune of such classics as SICP. Read more
Published on January 15, 2006 by Joe Duffy
2.0 out of 5 stars
Be sure to have your dictionary on hand while reading...
I honestly don't understand why professors choose this book to teach programming language concepts/semantics. Read more
Published on May 20, 2004
5.0 out of 5 stars
excellent
I had a lot of fun going through the book and following the steps to build an increasingly sophisticated language interpreter. Read more
Published on August 6, 2002
3.0 out of 5 stars
Essential but insufficient
For better or for worse, this book is probably the best general "hands-on" introduction to programming language concepts, showing students how to write interpreters for a variety... Read more
Published on May 5, 2002
2.0 out of 5 stars
Horridly Hard To Read
The author of this book seems to have purposefully obfuscated every paragraph in this book. I had a course in Program Organization a couple semesters ago and this was the textbook... Read more
Published on March 12, 2002 by J. Van Dyk
1.0 out of 5 stars
Painful for most students
We had to read this text for Prof. Friedman's Programming Languages course. It was entirely unintuitive and slow reading. I grasped very few of the concepts in the book. Read more
Published on February 9, 2002
5.0 out of 5 stars
Essentials of Programming Languages
This book was truly a masterpiece. This is all the concepts of programming you need. After reading this book, all you have to know to learn other languages is style and functions.. Read more
Published on September 30, 2001 by Eric Newton
5.0 out of 5 stars
Great book
I used this book in university and studied under Professor Friedman. This book perfect encapsulates the content of our course. Read more
Published on April 15, 2000 by D. Kern
5.0 out of 5 stars
Essentials of programming languages
about book catalogue and conten
Published on January 21, 2000 by gang,li
What Other Items Do Customers Buy After Viewing This Item?
Sell a Digital Version of This Book in the Kindle Store
If you are a publisher or author and hold the digital rights to a book, you can sell a digital version of it in our Kindle Store.
Learn more
Listmania!
|
|
So You'd Like to...
|
|
