Customer Reviews


40 Reviews
5 star:
 (25)
4 star:
 (7)
3 star:
 (3)
2 star:
 (4)
1 star:
 (1)
 
 
 
 
 
Average Customer Review
Share your thoughts with other customers
Create your own review
 
 

The most helpful favorable review
The most helpful critical review


27 of 31 people found the following review helpful
4.0 out of 5 stars Best Haskell book, but not perfect
This is probably the best book on Haskell available.

That said, there were some things I didn't like about it.

The biggest annoyance is that the example in Chapter 12 doesn't actually work. The point is to teach Haskell, not how to read barcodes, but example code that doesn't work just seems sloppy.

I'm also not a big fan of how the code...
Published on March 7, 2009 by Jeremiah LaRocco

versus
80 of 85 people found the following review helpful
3.0 out of 5 stars Rich with info, but VERY uneven
The good news is, this is probably the best Haskell book yet. The bad news is, it's still a frustratingly confusing jumble. It starts out well, introducing expressions, type inference, recursion, pattern matching, algebraic types, and higher order functions, with an emphasis on maps and folds (the way real world Haskell code is actually written), and it contains...
Published on October 17, 2009 by C. Adams


‹ Previous | 1 2 3 4 | Next ›
Most Helpful First | Newest First

80 of 85 people found the following review helpful
3.0 out of 5 stars Rich with info, but VERY uneven, October 17, 2009
This review is from: Real World Haskell (Paperback)
The good news is, this is probably the best Haskell book yet. The bad news is, it's still a frustratingly confusing jumble. It starts out well, introducing expressions, type inference, recursion, pattern matching, algebraic types, and higher order functions, with an emphasis on maps and folds (the way real world Haskell code is actually written), and it contains exercises that range from simple to challenging. The first four chapters alone are worth the price.

Unfortunately, the problems start in chapter 5, and rarely let up. It starts by introducing a datatype for JSON data for the purpose of pretty-printing it. The way the pretty-printer is rolled out is confusing -- it constantly jumps between code snippets that won't even compile, because a type they depend on is not defined til nearly the end of the chapter. And while it stays away from excessive cleverness, function names are confusingly named. In fact the entire nature of the pretty-printer revolves around a "Doc" abstraction that is never clearly explained or rationalized.

Later chapters are also rich with useful information, such as explanations of various GHC language extensions to the type system (which are really de facto standard Haskell nowadays). Unfortunately (there are many "unfortunatelys" to use in this review) I would never have been able to follow these explanations had I not already known a little about them -- unlike the rest of the examples in the book, the examples stop being "real-world" and instead devolve into meaningless metasyntax like "Foo" and "Bar".

By the time monads are finally introduced (late, but rightly so -- I consider this delay in introducing them to be a plus), the reader has had to suffer through some very tedious projects, such as parsing an obscure binary format. The book really begins to redeem itself again here, and makes monads clear as a datatype that captures common concepts of encapsulating and sequencing, and completely avoids cutesy visual analogies (no spacesuits or toxic waste here!).

I've not finished the book (I'm still in Chapter 14) but I am eagerly looking forward to its later chapters introducing monad transformers, parallel programming, and software transactional memory. You get a lot of book for the price, but you'll need the support of the always-friendly haskell community on IRC or email to make the most of this tome, or even make any sense of several parts of it.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


27 of 31 people found the following review helpful
4.0 out of 5 stars Best Haskell book, but not perfect, March 7, 2009
By 
This review is from: Real World Haskell (Paperback)
This is probably the best book on Haskell available.

That said, there were some things I didn't like about it.

The biggest annoyance is that the example in Chapter 12 doesn't actually work. The point is to teach Haskell, not how to read barcodes, but example code that doesn't work just seems sloppy.

I'm also not a big fan of how the code samples are spread out over several pages, with a comment stating which file they belong to. Mostly just a pet peeve, but it does cause some problems because there are a few places where the code references variables or types that haven't been declared yet, so the code won't actually compile until you get further along. Not the end of the world, but the book suggests compiling often to avoid errors and the end of each code snippet would be a natural place to do that.

There are also a few language features that are used but not really explained or used before they're explained. The $ operator, for example, is used on page 165 (among other places), but is only briefly explained on page 248. In that case, even when $ is explained it's incidental to explaining something else (fmap and <$>).
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


41 of 49 people found the following review helpful
1.0 out of 5 stars Poorly organized, and not needed., June 27, 2010
Verified Purchase(What's this?)
This review is from: Real World Haskell (Paperback)
The book is very poorly organized, and for the life of me I can't think of an ideal audience. Some of the material targets beginners, and then the other seventy percent is completely out of reach to all but seasoned pros. The stuff targeting beginners is rather poorly worded -- the book claims no intro to functional programming is required, but the definitions of fold[lr] will send any beginner scrambling to find a decent explanation. The book has a good share of technical rants that serve to do little more than side-track: "Ok, so you've learned foldr, now for good example and test of knowledge I'll tell you it can be written in terms of foldl" -- no further explanation provided. The definitions are all around bothersome. Ultimately, I don't think I learned much at all from this book, and I'd put in the top two worst O'reilly books I've ever read (following CGI Programming with Perl). This book seems to be a really poor mix of these non-existent books: Beginning Haskell, Advanced Haskell, and the Haskell Cookbook -- and with all this said, Haskell comes off as the most difficult language I've attempted to grasp thus far.

I should add I read through this book twice, and didn't learn much the second time around either.

A ton of the book is devoted to a JSON parser, which is rather tiresome. The other "real world examples" are equally poor like a bit-shifting checksum algorithm.

Go read Learn You a Haskell if you're looking to learn the language. If not, you can try this book -- but I'm going to predict your attempt will be fruitless.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


31 of 41 people found the following review helpful
5.0 out of 5 stars The best book on Haskell to come along in a long time, January 7, 2009
This review is from: Real World Haskell (Paperback)
Until this book came along you really needed two books to learn Haskell Programming. Haskell: The Craft of Functional Programming (2nd Edition) (International Computer Science Series) teaches the mechanics of Haskell programming, but it can be dry reading. The Haskell School of Expression: Learning Functional Programming through Multimedia shows you the possibilities of Haskell via multimedia programming, but it does miss some basic details about the language that are in the first book. This second book is lots of fun, but I think that the new O'Reilly book replaces the first book entirely and some of the functionality of the second.

Haskell has its roots in academia, and functional programming requires lots of up-front thinking about your total approach. It is not a language where you can usually just sit down and start coding. This book shows you how to use functional programming and Haskell to solve real-world problems. Each chapter contains many code samples, and many contain complete applications. The book contains an application that downloads podcast episodes from the web and stores the history in an SQL database. There is also an application that takes a grainy phone camera photo of the barcode on a book and transforms it into an identifier that you can then ue to query a library website. This is the "fun stuff" that seems to work out so well and so elegantly in the Haskell language.

It is not necessary that you have any prior knowledge of Haskell or functional programming concepts, however general programming concepts are a requirement. This is certainly the first Haskell book to come along in a few years that I would recommend for the novice. As usual with the best of O'Reilly's programming books, this one is well illustrated with lots of well-commented code. The following is the table of contents:

Chapter 1. Getting Started
Chapter 2. Types and Functions
Chapter 3. Defining Types, Streamlining Functions
Chapter 4. Functional Programming
Chapter 5. Writing a Library: Working with JSON Data
Chapter 6. Using Typeclasses
Chapter 7. I/O
Chapter 8. Efficient File Processing, Regular Expressions, and Filename Matching
Chapter 9. I/O Case Study: A Library for Searching the Filesystem
Chapter 10. Code Case Study: Parsing a Binary Data Format
Chapter 11. Testing and Quality Assurance
Chapter 12. Barcode Recognition
Chapter 13. Data Structures
Chapter 14. Monads
Chapter 15. Programming with Monads
Chapter 16. Using Parsec
Chapter 17. Interfacing with C: The FFI
Chapter 18. Monad Transformers
Chapter 19. Error Handling
Chapter 20. Systems Programming in Haskell
Chapter 21. Using Databases
Chapter 22. Extended Example: Web Client Programming
Chapter 23. GUI Programming with gtk2hs
Chapter 24. Concurrent and Multicore Programming
Chapter 25. Profiling and Optimization
Chapter 26. Advanced Library Design: Building a Bloom Filter
Chapter 27. Sockets and Syslog
Chapter 28. Software Transactional Memory
Appendix A. Installing GHC and Haskell Libraries
Section A.1. Installing GHC
Section A.2. Installing Haskell Software
Appendix B. Characters, Strings, and Escaping Rules
Section B.1. Writing Character and String Literals
Section B.2. International Language Support
Section B.3. Escaping Text
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


7 of 8 people found the following review helpful
2.0 out of 5 stars Not a very good book, February 20, 2012
Verified Purchase(What's this?)
This review is from: Real World Haskell (Paperback)
I have bought the book to improve my understanding of Haskell and its real world usage. Haskell is well known for a very steep learning curve and a lack of good books on it so I hoped the book will improve the situation. Unfortunately, it did so only partially.

The book gives you a deep overview of different language features and libraries. Unfortunately, after reading the book I felt that using Haskell for real world problem is a very bad idea, because of verbose and incomprehensible (and often uncompilable) examples presented in the book which isn't true. This book can only be used as a supplementary material for another haskell book.

For those who are willing to learn haskell I recommend the following sequence of reading: 1. Read Learn You a Haskell for Great Good!: A Beginner's Guide, the book is very short and very easy to comprehend and covers features of Haskell very well. 2. Read Haskell langauge spec. It isn't very long but you will be aware of all the languages' features. 3. Read Monad.Reader for more advanced haskell stuff.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


8 of 10 people found the following review helpful
5.0 out of 5 stars One of the best programming books in recent years, December 18, 2008
This review is from: Real World Haskell (Paperback)
This is one of the best programming books that came out in recent years regardless of language. It covers all the main concepts of the Haskell language and functional programming while at the same time showing how they can be used in real world code. Once past the first few chapters, the examples become non trivial and start to combine multiple concepts to produce short powerful programs, yet remaining totally accessible.

Maybe this is testimony to the conciseness of Haskell language, but to cover the same amount of material the examples cover in another more mainstream language would have taken several more pages if not multiple volumes. How many books cover file processing, regex, parsing, network programming, web programming, system programing, GUI programming and 2 different concurrency mechanisms while teaching a new language all that in around 600 pages. Not many. Above all this book really teaches how to design practical programs in a functional way. An area that was somewhat lacking. So this books might help a broader adoption of FP for real world stuff even if not in Haskell.

The only negatives I could find besides a few typos (It is still a first edition after all) was the usage of the $ operator in examples before it was actually explained. These are minor and don't really take anything away from this book.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


5 of 6 people found the following review helpful
3.0 out of 5 stars Inpenetrable and Boring, December 1, 2010
This review is from: Real World Haskell (Paperback)
I bought the book "Real World Haskell", but subsequently found far better routes to learning Haskell on-line.

Real World Haskell started off very well but quickly became inpenetrable. What's that unexplained '$' operator? And those ambiguous "explanations" of left and right folds are downright mysterious.

Anyone who manages to pursue the chapter on bar codes in "Real World Haskell" to completion has too much time on their hands.

This blogger: "Mike's World-O-Programming", [...], deeply understands Haskell and explains it clearly and literately. I wish that the authors of "Real World Haskell" were so lucid. That blog concentrates on Monads, but it is still a good starting place for Haskell learners that have already gleaned the basics of the language.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


7 of 9 people found the following review helpful
4.0 out of 5 stars Good for a first draft and especially for a Functional Programming book, May 1, 2009
Verified Purchase(What's this?)
This review is from: Real World Haskell (Paperback)
RWH is a solid book that gives the read a good idea of how Haskell works and why its unique. The book has its fault, largely because its a first draft that tries to cover a LOT of material. Don Stewart however has actively tried to aid in any deficiencies found by fixing errors on the web-version of this book so I'm not bothered by errors or things left out in the book.

The biggest complaint people have is that it tends to introduce concepts without really ever mentioning why something is being done. On one hand I agree with that assessment, however I also think that the book was marketed somewhat improperly. I would not call this book a good book for a beginner or your average intermediate programmer. At the very least I would say this book is better suited for experienced programmers or intermediate programmers with a passion for learning about languages.

That said, of the Functional Programming books I own, this is one of the best and most practical. It does not require a doctorate in Denotational Semantics to understand and it does not burn the first half of the book on typed/untyped lambda calculi (not that these things aren't important).

In short, if you want to get down to business working with a functional language, you have some experience with programming and are comfortable with a few errors then this book is for you.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


27 of 38 people found the following review helpful
2.0 out of 5 stars Better than others, but still not good enough, August 13, 2009
By 
Federico Zenith (Magdeburg, Germany) - See all my reviews
(REAL NAME)   
This review is from: Real World Haskell (Paperback)
Haskell books are in general among the worst I have seen for any programming language, which is really a pity for such an interesting language. I was really excited when I got this book because of all the good reviews, so I thought I would finally understand what a monad is and learn how to make practical programs.

I would like to mention that I have been a C++ programmer, currently work at a research institution, and my main tool at work is now Modelica: I think I am not completely dense and have experience with different programming paradigms, so I suppose my problems may not be limited to me.

Having read The Craft of Functional Programming, I had some background on the first chapters, which sail along nicely on their own; map, filter, fold, partial application and type classes are really nice and well explained.

There are entire chapters dedicated to case studies, in which the authors clearly favoured quantity versus quality: these example chapters are long-winded, nebulous and downright boring. JSON data? Parsers for some godforsaken image format? The authors clearly ignored the basic fact that examples need to be simple to be pedagogical, and lost themselves in details instead. Which would be tolerable if the case-study chapters could be skipped, but new stuff is introduced in these, so one has to follow through.

The coding style is mediocre: as unfortunately common in Haskell textbooks and resources, variables are often identified with single letters, originating cryptic code. It appears that the authors of those code snippets never wrote production code (i.e. code that has to be maintained down the road, possibly by others), given the total lack of semantics; if they did, someone now maintaining their code must be hating their guts. An argument should be named "state", "name", "address", "previous", not "x", "y", "z". In other cases, the choice of function or argument names is plainly misleading, such as in the case of the parser examples.
A terrible quote (approximately): "A SimpleState is actually a state extractor ..." so what about naming it "StateExtractor", instead of ending up with a bunch of misleading function signatures? Were their fingertips hurting, or did they want to save ink?

However, as customary for Haskell documentation, the worst comes with monads. Introduced early because of the IO monad, which is necessary for basic I/O operations, they are however left unexplained until chapter 14, during which time the reader is left to wonder what they are.
The usual foggy buzzwords are then thrown unsystematically around: "side effects" (what side effects could the Maybe data type or lists have? Yet they are monads), "actions", messy function specifications, confusing "examples" that raise more questions than they address.

I tried hard to wrap my brain around these concepts, I read and re-read the relevant chapters at various time over a month, but in the end I threw the book into the recycle bin - at some point I had to cut my losses. I stress this is the first time ever I throw a book away. Well, actually the second, because the first time I threw it away I recovered it because I got a bad conscience about it.

Sorry if I sound bitter, but I am really angry at myself for wasting so much time and effort for a language that will however never be of any practical use. Now, I'll rather learn Python, thankyouverymuch.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


13 of 18 people found the following review helpful
2.0 out of 5 stars Not written for real-world use, July 20, 2010
By 
Omari Norman (Washington DC USA) - See all my reviews
(REAL NAME)   
Verified Purchase(What's this?)
This review is from: Real World Haskell (Paperback)
Despite what the title suggests, the book was not written with real-world use in mind.

The biggest flaw in this book is the examples. I think the authors were so focused on "real-world" use that they come up with tortured examples that are both too simple to be "real-world" and too complicated to be instructive. In Chapter 3: "For motivation, we'll consider a few kinds of data that a small online bookstore might need to manage. We won't make any attempt at complete or realistic data definitions, but at least we're tying them to the real world." The book states this as though "tying them to the real world" is some sort of virtue.

At least the bookstore example is easily digested. The next chapter has a JSON parser. That's great if my "real world" application uses JSON. For everyone else, it means a lot of time trying to understand how JSON works rather than learning about how Haskell works. Subsequent chapters tell you how to replicate the globbing you'll find in a UNIX shell, how to replicate the UNIX find command, or how to parse some picture format. None of these are things I actually want to do, and seeing how someone else implements these things is not instructive--especially when you have to fight through all the details of globbing, or regular expressions, or some bizarre binary file format.

The problem with all these examples is that they take too long to understand. The book actually needs shorter examples--ones that illustrate a programming technique without losing the reader in irrelevant details. The bad examples would be okay if you could just skip them. Unfortunately, important details are buried in these examples--how to use the Haskell module system, for example.

All the examples make the book a tedious tutorial, but they make it an even worse reference. You can't jump into the middle of any chapter--or even the beginning of later chapters--because they rely on examples from earlier chapters. The first chapter on monads says hey, remember that thing we did when we were writing the parser for that picture format? Well, really, that was a monad.

The material is also not presented in a good, straightforward order. The most glaring example of this is in chapter 1: "Let's take a small leap ahead, and write a small program that counts the number of lines in its input. Don't expect to understand this yet..." So how is it instructive for me to read and paste code that I shouldn't even expect to understand? They say it is "fun" to make the computer do things, but if I want to make my PC show me things on the screen, I'll type "echo" commands into my shell.

Haskell has some concepts that take awhile to understand, and this book does not explain them well. The chapter on monads just left me scratching my head, while some Web tutorials (listed below) cleared things up quickly.

In short, every time I have turned to this book I have been disappointed. I originally thought Haskell was very difficult to learn, but it turned out that this book was holding me back. I'm not sure there are better dead tree books out there. Before you buy this one, check out the book's website and see if you like it. The full text is there; it could save you a lot of money.

There are several places I can recommend, and all of them explain things much better than this book:

"Learn You a Haskell for Great Good" is a web tutorial. It is very basic, but the material is presented in a logical order. He shows right away in a succinct manner how useful many of the functions in the Haskell Prelude are. The examples illustrate, rather than obfuscating as they do in this book. I recommend this as a first stop if you know no Haskell; it might even get you started if you know no programming at all.

"Yet Another Haskell Tutorial" is also available on the web. It covers much material that "Learn You a Haskell" omits, such as monads.

For more specific topics that this book covers quite poorly:

"IO Inside" is an article on the Haskell Wiki. I did not truly understand the rationale behind Haskell IO until I read this. "Yet Another Haskell Tutorial" also does a good job explaining IO.

"You Could Have Invented Monads" is someone's blog entry, but it is the best explanation of monads I have seen. It cleared things right up for monads. This book only confused me.

Overall "Real World Haskell" is a real disappointment. This and other subpar O'Reilly titles have soured me on the value of the O'Reilly brand. I will still look at their books but I cannot assume they are excellent or even as good as other, free stuff that is available on the Web.

*** Edit - on April 12, 2014

Now "Learn You a Haskell for Great Good" is available in printed form, as well as the full treatment being available for free on the internet. It has been expanded since I wrote this original review and it now covers monads. The treatment of monads is brilliant--rather than jumping into monads it starts with functors, then covers applicative functors, and then monads. Since every monad is an applicative functor, this gives you a great footing. He uses simple throwaway examples, so you spend more time understanding the principles and less time fighting through irrelevant detail like you do in "Real World Haskell".

I think the only reason "Real World Haskell" gets so many good reviews is just because there are so few decent Haskell books out there. RWH actually stands out to me as one of the worst programming books I have ever read.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


‹ Previous | 1 2 3 4 | Next ›
Most Helpful First | Newest First

Details

Real World Haskell
Real World Haskell by John Goerzen (Paperback - December 1, 2008)
$49.99 $42.21
In Stock
Add to cart Add to wishlist
Search these reviews only
Send us feedback How can we make Amazon Customer Reviews better for you? Let us know here.