Simon Thompson
1 disappointing potpourri of foodle-shnoodle
Perhaps I should forgive Thompson his tender age for the grievous philosophic error he commits as soon as he puts pen to paper, to wit, neither is functional programming new nor is Haskell its foremost exemplar. (Curiously, one Dr. Haskell was my orthodontist when I was a little boy, which rang a soft little bell deep in my cerebrum.) As far as functional programming is concerned, LISP is the way, the truth, and the light. Haskell may do more by way of notational "syntactic sugar" than LISP--with certainty, it can be hard to express yourself graphically when limited to concretely mathematically grounded notations [LISP = L(ots) of I(ncredibly) S(tupid) P(arentheses)]. Notwithstanding, I contend that the more difficult exercises that Thompson introduces--putatively as a vehicle for showcasing the brilliance of Haskell--point in quite the opposite direction. For LISP allows, nay encourages, parallel top-down/bottom-up development whereby you carefully extend the language to create, shall we say, a meta-4GL atop which to code your application, whereas Haskell will have none of this: it is a run-of-the-mill 3GL with some concepts and quirks that may be unfamiliar to the less sophisticated programmer, nor less, nor more. Nay, nay, I speedily toss Haskell into the basket that houses nearly every new language that comes down the pike: a few new tidbits perhaps; a more tersely expressed concept perchance; but nothing new to the sophisticate whose grasp of computer language (not to mention compuer languageS) extends beyond the ALGOL family (and, by extension, its somewhat more capable analogues, e.g., C, Java) and the handier "scripting" languages (e.g., Python, Ruby, Perl) that attempt to marry some OO concepts into what is ultimately a procedural substrate. Kids, first learn what a computer system is; learn assembly language on six or seven processors and how it relates to their bus architecture, I/O interface (e.g., whether DMA or "programmed" [a la the R6502: an admittedly poor term]) and microinstruction decoding; study LISP, APL, FORTRAN 66, SNOBOL, and other vehicles that enable you to explore the range of man's machinewise thinking beyond simple-minded von Neumann and MIX models that calculate the contents of address 1 based upon the contents of address 2; THEN, and only then, read and comment upon a Haskell text.
2 Good Haskell Book
This book, in conjunction with other resources, is a good introduction to Haskell. http://www.haskell.org has a lot of guidance as well.
If you are like me and you are learning Functional Programming after many years of other styles of programming Haskell can be daunting. Books like this explain things from the fundamental levels to more advanced levels. If you read the introduction to the book you will see that it is natural to skip around chapter to chapter when it becomes appropriate to do so. Deciding when it's appropriate is going to depend on your goals. If you want to write full-blown applications in Haskell you may find yourself skipping around much earlier than someone who wants to cover the language completely.
Overall I find this to be a very good book but some of the exercises can be very difficult for someone new to Functional Programming. Almost anything worth doing is not easy though :).
3 $48 down the drain
My excitement to learn Haskell faded with every page turned. The Author presented the subject with such excitement comparable only to that of watching paint dry.
4 Software Engineer
This book is an excellent piece for individuals in the software industry who have programmed and have excellent skills with programming languages however did not encounter the other concept which I call functional programming. It's a good start depending what is the intended goal and use. If you're currently programming some sort of mathematical logic programs or a combination of boolean algebra and proover verification systems, then that's the book for you. It serves the purpose.
5 Mediocre Material, Awful Typography
This book may indeed be suitable for beginners in functional programming. Having had some previous exposure to FP, I found it very slow going, with tediously long discussion of trivial toy examples.
Aggravating these flaws is the typography, which is not just ugly, but dysfunctional: The font used for the unnumbered section headers is not sufficiently distinguished from the text font, so it is impossible to skip over the examples to new material being discussed.
6 Love it!
This was my first text on Haskell, and it certainly got me up to speed on all the essential elements. I prefer Hudaks text for most things, but there is no good reason not to own every Haskell book you can get your hands on. This book is especially strong on learning how to prove things about programs.
It doesnt get to Monads until near the end, but perhaps that is a good thing. It depends on what you want out of a text.
I used this text for self study, and it is well suited to such a task.
7 An interesting introduction
I read this book as my first book towards learning functional programming and Haskell specifically. With many years of (imperative and object oriented) software engineering behind me, the concept of functional programming was interesting.
The good parts of this book are that it is extremely well organized. It includes many helpful exercises (which I highly recommend) and a very good introduction (the first ten or dozen chapters).
Later on in the book, however, I found increasing difficulty. The author picks up the pace of the material without, in my opinion, justification. By the end, he covers what, from reading several other books and many online articles, I consider the most confusing topic in a single chapter or two. Reading it several times, I'm still uncertain how to build an I/O intensive program in Haskell, and/or what a Monad truly is and/or how exception processing is properly handled.
That notwithstanding (because it seems to be a fairly common complaint of new Haskell students) I quite enjoyed the book. Before you buy it, though, you may wish to consider books from Paul Hudak (a Yale professor and nice guy) and Richard Bird, both of whom have written on Haskell; Paul actually taught a class which I avoided back in the early 90s - too bad, too, because then I wouldn't have to start from scratch so many years later.
8 Maybe the best choice for begginers in FP
A very good introductory text for Functional Programming, witch uses the Haskell notation. Maybe made for those who came from some experiense in imperative languages, such as C or Pascal. Good examples, maybe not enough case studies. Another good reference is "Bird"
9 good selection of topics but need more detailed explanation
This is generally a good book. But it has very little explantion of recursion for an introductory cs book. Since Haskell uses recursion exclusively, this is a severe shortcoming. And other concepts like partial application, folding, etc., are covered too briefly as well. However, the programs in the book are very clear and good.
