Home - Functional

Haskell: The Craft of Functional Programming (2nd Edition)

Price: $40.33 ~~$62.00~~

& 2-Day * Free Nationwide Shipping! (* details)

Availability: Usually ship in 24 hours if sold by Amazon.com

Tags: haskell craft functional programming 2nd edition

Product Details

Binding:	Paperback
EAN:	9780201342758
Label:	Addison Wesley
Feature:
Publisher:	Addison Wesley
Studio:	Addison Wesley

Editorial Reviews

The second edition of Haskell: The Craft of Functional Programming is essential reading for beginners to functional programming and newcomers to the Haskell programming language. The emphasis is on the process of crafting programs and the text contains many examples and running case studies, as well as advice on program design, testing, problem solving and how to avoid common pitfalls.

Customer Reviews

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.

Most of the reviewers for this text so far seem to be more experienced programmers or computer scientists. So I am writing this review to give a different perspective.

My uni has this year chosen Haskell as the INTRODUCTORY language, apparently because it:
1) Is a clear implementation of some fundamental programming concepts
2) Puts everyone on an equal footing, since no-one is likely to have studied it (or even another functional language) before.

I have little formal background but have been messing around with scripting languages like TCL for a couple of years.

The initial transition to thinking from a functional perspective seemed very difficult. The idea of recursion as opposed "just sticking it in a loop" took a while to stick.

But I have found simply by working through the book I have progressed quickly and in only a few weeks it has become quite natural to think in a Haskell way.

I attribute this to the excellent layout of the book, but more importantly the frequent exercises provided throughout each chapter. As my lecturer is fond of saying, practice is the only way to learn programming, and it is by exploring the introduced concepts in this way that I feel my learning of Haskell has been most effective.

The book is paced, if anything, a little slowly. But since I am someone who likes to gain a thorough understanding of topics I don't mind this. The exercises themselves are well thought out and tend to offer an increasing amount of challenge. Something that conceptually seems trivial can be given an interesting twist when it comes to writing a function.

I suppose experienced programmers may have covered similar kinds of exercises in other languages so it may not be quite so interesting, and they will be more wrestling with the mechanics of Haskell than gaining theorertical insights. However this highlights it's usefulness to a beginning programmer.

It has been said that learning a functional language increases your abilities in other languages. Whether this is true for me I haven't discovered yet, but certainly it has given me far more insight than I could have got from a scripting langauge about what is actually happening in a program.

This really is a well-written and surprisingly accessible book considering the typical Haskell programmer. I can highly recommend it.

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.

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 :).

This book makes an excellent gradually-paced introduction to Haskell, with plenty of examples and exercises, for those who are a little overwhelmed by the online "Gentle Introduction to Haskell". My only complaint is that it proceeds a bit too slowly for my taste, taking 150 pages to get around to discussing higher-order functions and other advanced topics that make Haskell worth learning. This is understandable, since it's intended to be usable as a textbook for a first programming course, but it's also frustrating for someone who already has programming experience. The other feature of the book that stands out is its price, which is quite reasonable for a textbook. All told, this is an good-quality Haskell textbook suitable for either new programmers or (by skimming the first several chapters) more experienced programmers looking to learn functional programming.

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.

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.

This book takes an interesting topic like functional programming and makes it hideously boring. In retrospect, I wish I'd bought Hudak's book instead. I read a review claiming that Mr. Thompson's book was better for newcomers to Haskell than Mr. Hudak's. I don't know where this idea came from; I later borrowed Hudak's "Haskell School of Expression" and found it to be more informative and faster-paced than this book. I give it two stars only because it is useful as a reference. If you're looking to learn Haskell and do cool things with it, get School of Expression instead.

This is a dull university textbook meant to instruct tender young minds in the philosophy of functional programming, and several of the chapters are on topics that are not likely to be of interest to anyone who isn't using the book as the required text for a course. There is insufficient reference material on the built-in functions and the functions in the language's standard prologue for this book to stand on its own.

The author has an annoying habit of using haskell-like pseudocode to explain ideas, without making it clear what is pseudocode and what is real, working code. In addition, the lines of code are interspersed with the text, making it unclear what would constitute a complete, compilable source code file. For example, the discussion of memoization leads off with the standard example of memoizing the naive recursive implementation of the Fibonacci function. First he gives an example of how to memoize it that he clearly marks as not real code that would compile. Then he gives another example that seems to be the one that he is saying would actually compile, but it doesn't compile either. There is no working version of the code on the book's web site, either. After this, he passes on to another example.

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"

Good book for beginners, not so exciting if you're an intermediate-to-advanced level programmer. Then again, it doesn't claim to cater to that level, so your mileage might vary.

Very good introduction to Haskell and functional programming in general. Covers Haskell's type inference system and unconventional syntax in a comfortable, clear way. Lazy evaluation and its effects on the language are likewise explained in an clear approachable way.
There's lots of SICP-like exercises to practice with if you want, though their placement makes the book a bit confusing at times if you don't as it's hard to tell the exercises and the material apart sometimes.
I haven't looked at competing Haskell books, but after reading this one, I don't see the need to. This book doesn't explain monads particularly well (though most other explanations, besides one explanation in a reddit comment I saw, are equally not understandable, so that's no great fault).
Overall, a great book for programmers who want to get into functional programming or quickly learn Haskell.

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.

Simply one of the best books on Haskell you can purchase. Very well written with a tone of good examples. Perfectly structured, avoids the trap of being too introductory or too advanced. If you want to learn funcational programming you can start with this book and learn enough quick enough to be productive with it in a short time.

I got this book for a CS class in college but never used it (professors just love you to waste your money that way). I recently came back to this book after getting really into Python, especially the functional features.
The approach the book takes is more or less instructing someone who knows absolutely nothing about programming in the ways of functional thinking. This makes it perfectly easy for an absolute beginner with no imperative or OOP prejudices to learn Haskell--just as if they were taught hex before decimal they'd catch onto hex real quick.
This is also a great text for someone who's had some functional programming experience (map, filter, reduce, monads) and for whom recursion is a friend. I've become a much better Python programmer (and a better programmer in general) from just scanning the book every time in the bathroom.
However, for a student who's been doing Java or C/C++ for a year or two, this will be extremely confusing. They will already have adopted a certain way of thinking and will have trouble going through this text. This is why this book was useless to me for several years.
But for the advanced guys or the absolute n00bs I'd definitely recommend this book. As far as functional programming books go it's downright lively. My only complaint is that it doesn't really show me any practical things I can do with Haskell (these examples seem hard to find anywhere), such as database or GUI stuff. I mean sure it's cool to do a graph walk incredibly succinctly, but that's not something I'm going to use for work . . .

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.

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.

Share your thoughts with other customers
Create your own review

Home - Functional

Haskell: The Craft of Functional Programming (2nd Edition)

Product Details

Editorial Reviews

Customer Reviews

Search

Categories