Customer Reviews

Essentials of Programming Languages

5 star:		(8)
4 star:		(3)
3 star:		(1)
2 star:		(3)
1 star:		(2)

 

 

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.

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.

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.

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.

I enjoyed this book's implementation-oriented approach to teaching language constructs, in the tune of such classics as SICP. The book title is misleading in that this book focuses almost exclusively on functional languages. But within that realm, it admittedly does cover a broad range of features. The book has just the right amount of formal notation to insure relative completeness, but not so much as to scare away unfamiliar readers. I think it's a nice gentle introduction to the whole field.

As I alluded to, the only reason I didn't give this a 5-star is the slightly misleading general-purposeness appeal, even though it really is entirely functional-oriented. Other than that, the book was a great read.

This is a great book used in "The Theory of Programming Language" in Iowa State University. Although this book use Scheme to illustrate fundamental concepts of programming languages, I found out later that these concepts are especially useful in helping me to understand other language like Java. e.g. you can pass argument(s) to C++ fn either by value or by reference, in Java you're passing argument by copy-reference only(except primitive data tyeps). However, beware that there're lots of errors in this book, be sure to check out the publisher's web site and checkout a list of erranta.

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 of programming-language paradigms. It covers what many computer scientists consider the most important ones: functional programming, object-oriented programming, type systems/inference, and logic programming (though it gives short shrift to the latter).

Teachers love the book because it takes a unified, minimalist approach, using the simple, elegant language Scheme. Students seem to hate the book for the same reason, complaining that the details of Scheme divert attention from the concepts themselves.

This situation makes it essential to supplement the book with programming assignments in actual languages (Java, ML, Prolog), so students can see what all the trouble is for, and what's really exciting about the ideas in the book. Otherwise, reading this book is like learning how to build a car without ever having seen one!

I honestly don't understand why professors choose this book to teach programming language concepts/semantics. The best books to learn from are written in simple, easy to read language, and with a well-designed index. EOPL lacks both of these attributes.

As a part of the class we had to take reading quizzes on each section, meaning we had to read this book cover to cover. Friedman used complex, difficult to understand language to teach concepts that themselves were difficult to grasp. To make matters worse, the professor simply read from the book during lecture, failing to clarify the mysteries created by Friedman.

An optional book for the class was Programming Language Pragmatics. It explained the implementations of Object Oriented languages, type checking, assembly, etc. using multiple languages people have used before, unlike scheme. I would suggest looking at that book before choosing EOPL.

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 .... doesnt explain lambda calculus and combinators in much detail though

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 for the class.

I "read" the first few chapters, then gave up. I was tired of having to re-read every, and I mean every, sentence of the book multiple times in order to understand the topics covered.

This book relies too heavily on the syntax of Scheme in the early stages. I find myself learning another language, and not new concepts. The title should be "Essentials of Scheme."