Customer Reviews

Programming in Haskell

5 star:		(10)
4 star:		(6)
3 star:		(2)
2 star:		(2)
1 star:		(1)

 

 

This is a very good introduction to the fundamentals concepts of haskell but it doesn't teach you what you need to know to start writing (or reading) non-trivial programs. Topics that are not covered at all are monad rules, monad trasformers and monad functions like mapM. Syntactic sugars not covered at all are "module", "newtype", "case/of", "let/in".

Hutton's book is an excellent introduction for programmers approaching Haskell for the first time. Hutton keeps the focus on the core concepts of the language and avoids the advanced topics (of which there are many). The book is fairly light at 171 pages, but for an introductory text I consider this appropriate - a weighty tome might intimidate a reader who just wants a introductory overview. That said, if you are already an intermediate level Haskell hacker, you will likely not find anything of use in this text.

Graham Hutton has written a wonderful introduction to functional programming in Haskell. I'm using it as part of an undergraduate level course on programming languages and I'm amazed at how fast my students have understood issues with which previous classes of mine have struggled. In my opinion, this is *the* best introductory text available on functional programming in any language. Thanks Graham!!!

I'm a mathematician who decided Haskell would be a good language in which to perform my latest computing task, so I looked around for learning materials. After going through some web tutorials and starting into _Real World Haskell_, I decided that maybe I should try something more basic and systematic, so I read Hutton's book. I'm glad I did, and I think I understand Haskell much better now than I did before.

The form factor of this book is really odd, essentially that of a thick magazine, like _Wired_. It has huge outer margins, with the text compressed into the middle in tiny-looking 9-point type. Thankfully, the printing is crisp, so the text is fairly readable. Choosing to set the code samples in a proportional font seems like a curious choice, especially for Haskell, where spacing matters. For a computing book, the writing is very elegant, although the organization is somewhat less systematic than I was expecting.

The most questionable aspect of this book is its audience. Ostensibly, it is written for a first university course for students with "[n]o previous programming experience", but I'm not sure how good of a fit it would be, especially for a typical U.S. student. Concepts like pointers, parsers, stacks, and compilers seem to be mentioned with the idea that readers would already know what those are. The examples in the book are largely drawn from Hutton's professional publications in functional programming. To me, these were interesting, but it's not clear how much new students would appreciate them. Contrast that with the fact that mathematical induction is discussed at length as if the reader might be unaware of it, and on page 147 the reader is referred back to a previous derivation for justification of the FOIL formula from basic algebra! The selection of exercises seemed kind of sparse for a textbook.

_Programming in Haskell_ is a quick read, and (if you can afford it) is probably a good stepping stone on the way to being a good Haskell programmer.

I have been a software developer for the past 12 years. However, I had always worked with imperative languages. Learning Haskell is not an easy task. Mostly because it takes time to assimilate the functional paradigm, and secondly because the learning material is not very well organized. It has been practically impossible to learn Haskell using a single book, and I have bought many. However, if I had to recomend a place to start, I would certainly say it is "Programmming in Haskell".

The book covers the very basics that everyone new to Haskell and new to functional programming needs to understand. However, the book does not cover material enough to become a Haskell developer. It just covers enough to get you started with the language, and most importantly, to enable you to understand other Haskell books out ther, which on the contrary, seem to assume that one has a broader understanding on functional programming.

The reason I gave it 4 starts instead of 5 is because it uses a strange symbology in the examples which forces the reader to interpret the symbols when writing Haskell code. You have to read an appendix to interpret symbols as actual Haskell operators.

Hutton is a well-known and respected authority on Haskell. This book is a very clear introduction to the essentials of Haskell: if I had to pick one book to recommend, for newcomers or old hands, this would be the one.

While it does not go into the details of libraries, it goes over the basic structures quite well. To really master the book's material would put one well on the road to "thinking in Haskell". Some of the examples are deceptively simple: they are easy to read, but they sketch out the structure of very sophisticated concepts. My favorite example is the chapter on "Functional Parsers". It alone would earn the book 5 stars, because it provides the only comprehensible introduction to Monads I've ever found (I've programmed LISP for 15 years, and C++ for another 15, so it isn't for lack of grounding). I disagree with an earlier reviewer that lack of details on monads (e.g. mapM) is a problem, because my learning style is to really understand the underlying concept before moving on to detailed usage.

Hutton also implements a simple language (using LISP's classic eval/apply duo under slightly different names), then an abstract computing machine, a compiler for it, and finally proving correctness of the implementation. All this is kept down to a manageable size by restricting the language to support a simple calculator. Nevertheless, it is worth noting that MIT's introductory computer science course, which uses "Structure and Interpretation of Computer Programs", follows the same progression in much more detail (and in Scheme). It, too, avoids introducing a large number of library modules or "advanced language features". The reason for this lies in the old adage that "You can write FORTRAN in any language": the way to write excellent Haskell in the long run is to learn to think in the Haskell from the start. By following the sequence, using only elementary language features, Hutton introduces fundamental and important ideas -- while showing how Haskell represents them in an easy and natural way.

Finally, there is a useful listing of basic functions in the back. Hutton does not provide a massive listing of the many classes, methods, modules, etc. available, but again I think this is an advantage in disguise: learning how to use the fundamentals to accomplish a wide range of useful tasks is an excellent way to learn and appreciate the language. After getting a really good grip on this book, I'd move on to "Real World Haskell", a generally excellent text with impoverished graphics, and "Pearls of Functional Programming", another text with beautiful and insightful examples.

Again, this is the best introduction I've found to Haskell, and its general approach would make it an excellent introduction to programming in general.

If you're trying to learn Haskell (like me), then you'll probably want to reference many sources. I find this is the best way to learn. Reading the same topic from different viewpoints is one of the best ways to embed the knowledge in your head. That said, this book meets all my criteria:

1) Anti-Bible Pattern = not 1000+ pages and if you dropped it on your foot, it probably would only make you wince (not have a broken foot).
2) Well written, clear, concise, and easy to follow
3) Good coverage of all the things that matter in Haskell-land -- as far as I can tell..not really a Haskell expert (yet).

If you are a total newbie to programming, you'll have a hard time with this book -- but that could be said of many programming books. I have many years of C (procedural) and OO design (Java) under my belt, but this is my first foray into functional programming. This book served its purpose for me very well. I read it in bed, and would grab the laptop and hammer out small programs and do the exercises in the back using the Glasgow Haskell Compiler. I like programming books that give you programming exercises at the end of the chapter -- best way to learn. It would be nice if they also supplied solutions. Granted, you can determine if you solved the problem by running the program, but it is nice to see code written by an expert so you can compare implementations and learn different ways to solve the problem.

There are some fantastic web tutorials on Haskell out there. If you plow through this book (less than 200 pages), and go through many of the web tutorials, I think you'll have a decent grasp of programming in Haskell.

The author has obviously explained Haskell to many people before, and drawing from this experience, he creates a book on programming in Haskell that is a quick read -- dare I say, even, a "page turner". Few instructional books clearly explain their subject matter, and fewer still make that subject matter a tasty treat to be savored.

Not everything is covered, to be sure, and a few topics receive hasty treatment. But if Graham comes out with a more advanced book in the series, you can bet I'll preorder it on the reputation of this book alone.

I purchased this book roughly a year ago now, when I approached it then I did find some difficulty but as the months went on, attempting the exercises and writing some of my own small programs, the value of the book has increased and I think I have understood its intentions better.

I recommend this book both as a starting point and as desk reference for the standard prelude for those times when thinking is required, one can lazily flip through the pages while thinking about possible approaches to solving problems.

For those that have had some trouble with this book, it's just a matter of persistence, practice and patience.

The writing style is clear and to the point, thank you Graham Hutton for this excellent starting point and your other contributions to the functional programming arena.

This book was written for first-year students, meaning that the author took care to make it consise, gentle, easy to understand, and has provided good introductory examples. After getting your head around Haskell, you can then pick up a more full and complex book on the subject.

As a professional developer, lacking prior experience in functional languages, I really enjoyed this introduction. As I was reading it concurrently with books on ML, Scheme, and Erlang, this text always made me feel comfortable with a new topic which the others then explored in more detail.