5.0 out of 5 stars Awesome, mind-bending read
A very nice, thought-provoking read. The theory and the hands-on examples are mixed in a perfect ratio to turn your imperative mind inside out.
Published 2 months ago by Mátyás Lipták
9 of 9 people found the following review helpful
3.0 out of 5 stars Frustrating
I have mixed feelings about this book. My girlfriend thought it was my favourite book because I was always reading it and it became very well-worn. However, the real reason I couldn't put it down was because I couldn't understand it. The main problems with the book are:
1. The code examples are too interdependent. If you get a mental block (or get bored),...
Published on 16 Jun 2011 by skytreebird
Most Helpful First | Newest First
9 of 9 people found the following review helpful
3.0 out of 5 stars Frustrating,
This review is from: Real World Haskell (Paperback)I have mixed feelings about this book. My girlfriend thought it was my favourite book because I was always reading it and it became very well-worn. However, the real reason I couldn't put it down was because I couldn't understand it. The main problems with the book are:
1. The code examples are too interdependent. If you get a mental block (or get bored), you can't jump to another chapter to `take a bite from a different side of the cake' because most code just builds on the code developed in previous chapters. So if you skipped the previous chapter you're stuffed. Even if you didn't skip the previous chapter, you will be doing well if you can piece together the `actual' code from all the fragments littered throughout the chapter - some of which are red herrings (ie code fragments that are there to show you how not to do it).
2. There is a step change in pace around chapter 10, which goes from the pace of a Sunday drive to light-speed, almost as if there was a change of author. The chapter is way too dense and tries to get too many concepts across at once. This is also the chapter that has the greatest number of mistakes, so for me it was like hitting a wall, my progress practically slowed to a halt and I was seriously debating whether to continue with the language.
That said there is some good stuff in here, it just needs a re-think. If you are new to Haskell, I recommend you check out `Learn You A Haskell for Great Good' first and come back here if you are a masochist.
14 of 15 people found the following review helpful
2.0 out of 5 stars Could have been so much better,
This review is from: Real World Haskell (Paperback)I agree with the other readers who say they just got frustrated by the author's inability to illustrate his point through simple, atomic and self explanatory examples. I enjoyed the first few chapters, because the author had not yet built up a critical mass of backward references, but after that I wanted to skip a whole load of stuff that wasn't relevant to me. However skipping ahead to chapters on things like Monads, I find it referring back to previous chapters, which in turn refer back to previous chapters and so on. I tried to read the whole thing linearly, but the examples are too specialised for me to bothered by them. I just can't bring myself to care about bar code reading programs, no matter how much I try - and there is a whole chapter on this!
The book isn't all bad, the early chapters are good, and I some Haskell concepts did `click' for me from reading this book. The author's style when steered away from examples that run into pages is clear and good.
The problem is its combination of being rather long, and that it *really* has to be read in a linear fashion.
You can pick up the language just as well using online tutorials and the user mail list is pretty helpful if you get lost on concepts like Monads. I think there are far better tutorials on Monads on the net now than this book, although I accept there are a whole load more terrible explanations on the net, and you'll need to read 10 bad ones to find 1 good one - bit it is the quickest way to learn the concept.
What Haskell needs is author capable of producing a book like the "Effective C++" series. It assumes fairly basic knowledge of the language (you can pick that up from anywhere). What it does is in very small, autonomous bite-sized chunks, it addresses 1-per-small-chapter points on style and implementation. The examples are kept so very simple (although often interesting) they can be explained sometimes in a paragraph - the code is never more than a few lines, yet the author manages to convey very complex ideas very elegantly.
The trick is to use absolutely numpty higher concepts as examples - strip away *everything* but the problem itself; we'll think of our own complex examples relevant to our own use once we've cracked the framework of the concept.
1 of 1 people found the following review helpful
1.0 out of 5 stars Simply not good enough,
This review is from: Real World Haskell (Kindle Edition)I bought the Kindle edition of this book having done functional programming with other languages before (Lisp and Scala). The first third or so of this book was material very familiar to me from those other languages and even here I found the book hard work. There were mistakes where the description in the text did not match the sample code. There was an instance of sample code not compiling, and infact the compile error was printed into the book in place of where the program output was expected (maybe this is only present in the Kindle print). Sample code was often too abstract using identifier names that did not help me to understand what the sample code was trying to achieve (ironic for "real world" haskell). In other cases the sample code required functions that would only be implemented much later in the book (very confusing if you are trying out the samples as you read).
The next third or so of the book was new territory for me, and here I found myself often second guessing the text of the book. I suspected mistakes but did not have the confidence to know for sure. At this point the online version of the book proved to be very helpful ([...]). Here there are plenty of online comments from readers of the book that correct many of the mistakes and clear up confusion. Take a skim at some of the comments there before you buy to get an indication of the types of problems this book has.
I gave up on this book at roughly the two thirds mark, and am now instead reading "Programming in Haskell". I have yet to complete this alternative book but so far it is of much higher standard than Real World Haskell.
3 of 4 people found the following review helpful
3.0 out of 5 stars Its a fair attempt at explaining the incomprehensible,
This review is from: Real World Haskell (Paperback)If you like getting down and dirty with code then this is the book for you. Unlike some books that deal with the theory of Haskell first, Real World Haskel gets you walking though code right off the bat. At first I felt like I was making real progress but this was, for me at least, a false dawn as things slow down after the first few chapters, but I think this is the fault of the subject and not the book. Although some of the examples used were a little esoteric (a whole chapter on a bar code reader!) I have to give the authors credit because this book explained a difficult subject in an understandable way. In my view its worth reading if only to find out if Haskell is the right language for you.
5.0 out of 5 stars Awesome, mind-bending read,
This review is from: Real World Haskell (Paperback)A very nice, thought-provoking read. The theory and the hands-on examples are mixed in a perfect ratio to turn your imperative mind inside out.
10 of 14 people found the following review helpful
5.0 out of 5 stars Elevates Haskell from a theoretical distraction to a useful tool,
This review is from: Real World Haskell (Paperback)I had been searching for a clear, concise reference for Haskell for years before I discovered this book.
The trouble with most existing Haskell tutorials and texts is that they always approach Haskell from the point of language theory: why Haskell is cool, but always fail to show how to actually improve the quality of your programs using a different paradigm.
This book is different. By insisting on being thoroughly rooted in practicality, it enables discussion of some of Haskell's more abstract corners (Monads and Monad Transformers) from a perspective of why they'd be useful to *me*, and how *I* could use them to solve programming problems that are mucky in other languages.
And for the first time, it all clicked. I at last understand Monads and why they exist. And since no other Haskell reference has ever done that for me, I can't recommend it highly enough.
A previous commenter has mentioned that chapters do tend to depend on previous examples in other chapters, and that makes this book useless as a reference. I disagree: I think there is significant didactic power in the approach of doing it once the hard way, because when concepts like Monads are introduced, it has an opportunity to do it again the right way, and suddenly Haskell's awesome expressive power is laid bare.
4 of 6 people found the following review helpful
5.0 out of 5 stars Excellent introduction to practical use of Haskell,
This review is from: Real World Haskell (Paperback)I am no newcomer to functional programming languages, having spent a few years with Lisp and a little with ML as well, but I never really got Haskell under my skin, because of the difficulty to really, fully understanding Monads, and monadic programming, and the very high level of abstractness Haskell encourages. Thanks to this book, and the references it contains to online material and articles, I now have much more familiarity with the idioms, the abstract level of code, and good programming style of Haskell as well as how better to think about problems in Haskell.
Through out the book, the focus is constantly on how best to use Haskell, in particular to give the reader a good feeling for what constitutes good programming style, and why in each case.
In the context of a subject I've not often found the ending of a subject to leave me missing an explanation for why things are done this way, or why things were done in a certain way. In the the few cases this happened things were quickly cleared up by just reading (or in a single case jumping) forward. I haven't left a topic unsatisfied with the depth, width, or any lack of detail.
The book may be an introduction, but fortunately it doesn't shy away from advanced concepts like Monad Transformers, and why they are more essential than Monads themselves when talking about the Monad programming style. Over all GUI, concurrent and parallel programming, databases, network and web programming, system programming, error handling, profiling, and optimization, package installation, and many other earthly issues are among just some of the subjects presented in the book. There is enough to get everybody going. I can also recommend the book "The Fun of Programming" by Jeremy Gibbons, if you want more fun or odd examples, rather than the more real, smelly examples that you'll find in this book.
All the examples are thankfully not toy examples, but real world examples with enough complexity to be meaningful in a realistic context, and at the same time they incite to learn more, and inspire how to solve other problems of similar structure. There is plenty of code, but thanks to Haskell's conciseness, it never weighs down the content of the book, and actually allows meaty examples to be shown, all the while without ending up as just code listings without much explanation.
The book keeps walking this wonderful line between theory and practice, where every bit of theory is practical theory supporting real world work. In some ways it reminds me of the Bell Labs culture of excellence which also walked this edge. It's difficult to keep this equilibrium, but the book does a very good job in this respect as well, making it joy and pleasure to read. It never becomes dry, or dull to read. It dives into particular details when needed, and postpones complex topics dilligently, although in early examples it doesn't try to hide that more is going on, and gives forward references, but they never disturb the current reading flow, and it's safe to jump forward and then back again, if one just cannot wait.
One of the many things I was very happy about, was the very good explanation of how the non-strictness of the language makes it possible to introduce space leaks, if you blindly use idioms from strict languages. I was possitively surprised to find out that very often what is considered a naive solution in a strict language (like Lisp or ML) often is a very good, and efficient solution in Haskell, making the code even better, and beatiful to read and maintain.
I am deeply impressed with how much width and depth the authors managed to put into the barely 700 pages of the book. There's hardly any typing mistakes, and I've already used the index, and appendices on several occasions. I've been reading from the beginning, and actually picked up good bits and pieces from the beginner tutorial in the first chapters, even though I am no spring chicken, but very soon I found my self jumping to forward references without any trouble or bother. I expect the book will be very useful to look up forgotten things, or things you just want to freshen up on. I've already needed to do this in later chapters, when showing alternatives to earlier examples that I needed to refresh.
The authors of this book has managed with all the many reviewers and contributors to make this the flagship book for Haskell in the coming years, and a really impressive one at that. I am reminded of Peter Seibel's book "Practical Common Lisp" which does the same for Common Lisp.
And Haskell? I have become really enthusiastic about this language and especially its advanced type system. It takes a little while to get used to the very high level style, but in the end, it has raised the level of my unit tests to better, and more problem domain oriented levels, killed much boiler plate code, if not nearly all of it, and improved my thinking about the structure of programs and program design in ground breaking ways. I haven't tried this since I jumped on the Lisp and Prolog wagon some years back. Everything in Haskell seems to get on stereoids when you do it the Haskell way. Quickcheck unit testing was one of the things that impressed me.
Haskell is an unavoidable language, even if you don't end up using it in your day job. I am a better programmer for it.
One surprising use of Haskell which may seem odd to many, is that I've found Haskell really good for scripting. The conciseness of Haskell code, and the type system, and all the orthogonal features of Haskell have a synergetic effect which is really in itself beatiful, and suddenly turns such a boring drone task into a joy to do.
There are many good things in this book, and I feel like I've touched upon too few things to really give a detailed enough impression of the book, but I hope it is complete enough to be useful to others considering whether to buy this book.
14 of 21 people found the following review helpful
2.0 out of 5 stars The wrong way to teach (programming),
This review is from: Real World Haskell (Paperback)I really wanted to like this book. The title alone seems so appealing. Instead of the usual, often dry, approach to teaching functional programming by means of mostly mathematical examples, this book takes a completely different approach by using realistic problems. At the same time the book seems targeted at people new to both Haskell and functional programming in general. Sadly, after reading this book I no longer think this is a viable approach to teaching.
Subjects are introduced as a "side-effect" (no pun intended) of developing fairly complex realistic programs. The authors seem eager to prove that Haskell can indeed be used for this. Unfortunately, this means they lose track of the teaching aspect. Not only do you have to learn difficult programming subjects (such as monads), you also have to understand the individual problems in the book.
This makes the book more confusing than necessary. Many chapters in the book refer back to earlier (large!) examples. Even if you read the book from start to end, it becomes a problem having to remember and understand each of these problems. But the worst effect is that it becomes nearly impossible to use the book as a reference.
One positive point about the book. Unlike most (all?) other books on Haskell it focuses on GHC with all of its extensions instead of restricting itself to the academic Haskell-98 standard. Thank you for that!
EDIT: After having read some parts of the book a second (and third!) time, I have a few more good points to add. Some of the sections on monads are quite well-written actually. I also like that the authors pay attention to good, general programming practices such as "encapsulation". This is essential when writing scalable and realistic programs - no matter what language you use.
I still stand by my initial review. But I feel I was a little to harsh in the rating. So I'd like to give it one more star... but it doesn't seem like Amazon will let me do that. :/
0 of 1 people found the following review helpful
5.0 out of 5 stars Excellent book for Haskell,
This review is from: Real World Haskell (Paperback)It is an excellent book for Haskell. You can learn to use this lenguage from the begining, step by step. It is very easy to follow the guides and start to programm with Haskell.
1 of 4 people found the following review helpful
5.0 out of 5 stars Best introduction around,
This review is from: Real World Haskell (Paperback)If you want to get into Haskell without getting bogged down in mathematics, this book is a fantastic, practical introduction. Getting your head into the maths will eventually lead to great gains with Haskell, but if you want a pragmatic introduction that will give you a taste for the awesome power and beautiful elegance of Haskell, I strongly recommend this book.
Most Helpful First | Newest First
Real World Haskell by Donald Bruce Stewart (Paperback - 2 Dec 2008)