Greg Michaelson

Probably, imperative programming is the inevitable professional path of the budding programmer that picks up this book. However, the career programmer can benefit from seeing how “the other half lives”. As one who has trained and hired software engineers over the years, I have seen that a mindset of iteration and conditional statements can often lead to inefficient designs. Someone with only an introductory knowledge of LISP or Haskell or general declarative principles as outlined here show more often can come up with more compact and efficient designs in object-oriented programming (OOP). The excellent chapter here on recursion highlights a key concept I find taught better through functional programming. I recommend that those serious about OOP read this as a “mind hack” to spark innovation and a fresh assessment of the tools at hand.

(Look for my full review to appear in MAA Reviews: http://mathdl.maa.org/mathDL/19/) show less

I have been working in a functional programming language for the last four years. Over the years, there have been many frustrations with this language in trying to understand why it is the way it is. Part of these frustrations are rooted in certain proprietary aspects of the language, which sometimes make it difficult to know what is going on when something goes wrong. But a large part was also from not understanding why it is doing things the way it is doing them.

The approach taken by this show more book, to root functional programming in the lambda calculus was immensely helpful for understanding the general case for these kinds of languages. Probably the most helpful was to see how simple data structures can be "simulated" with functions. This helped to recast my thinking away from the standard languages (python etc.). I stopped thinking about iteration, and started thinking about recursion as well.

While the material was helpful, it was the presentation that kept me from giving this 4/5. It was a little opaque at times, and the examples were not always helpful. show less

Excellent coverage of practical lambda calculus. However the model gets hand-wavier over time without looking at a concrete implementation. And the type checking is only ever introduced at runtime.

The last two chapters cover Standard ML and Common Lisp and don't really add much. There's little more to be wished for, perhaps in a book dedicated to Hindley-Milner unification.