It is not the easiest language to learn. i recommend learning some other programming languages. Maybe python basics. Then maybe something higher level like C or C++ if you insist, or maybe Java. If your already an experienced programmer you may have the same experience as me. I found Haskell to be really interesting and a unique fun approach to solving issues. But keep in mind this is a functional language and object oriented programming is absent in this language. As a book i feel like its a good run though of how to program in Haskell. It provides interesting examples in it as well as being able to make a QR code scanner. If you read this book don't just skim though it. You will need to probably practise the examples multiple times and experiment a little. But if your paying attention and thinking about what they are saying in the book you should get the hang of it.

The book is a must-read for not only people who would specifically like to learn Haskell, but for any programmer who is open to new ways of thinking about computing.

It serves at least those purposes:

- Makes one an overall better programmer by teaching to think about problems in a functional mindset, thus teaching modularity and abstraction (because functional programs tend to be modular and abstract 'by construction')

- By introducing some of Haskell's extremely powerful libraries, such as STM and QuickCheck, motivates to search for equally unbelievably beautiful design decisions in casual programming

- Teaches one to program useful, reliable, fast, concurrent, tested, and-so-on real-world applications in Haskell

I beleive that the book will play a seminal role in popularization of functional programming, and, consequently, in increasing the number of good programmers and good code in the world :)

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.

Before purchasing RWH, I had already read the whole book on its website in beta form. Even though I have a decent amount of haskell experience, I was very very pleased with this book. So much so, that I bought the hard copy to have as a reference and because part of me felt like I owed to the authors. I should also note that the authors are often in #haskell and each of them have been extremely helpful to me in the past.

The authors do a great job of explaining the value of taking on the challenge of coding in a pure, functional language. As clock speeds stagnate and the number of cores available to programmers increases, this will only become truer with time. As the authors demonstrate, Haskell is uniquely positioned to take advantage of this new paradigm. The other paradigm shift is that this is the first major book (AFAIK) to address Haskell from a practical as opposed to academic perspective. It does so with shining colors.

I can't recommend RWH strongly enough for anyone considering Haskell. As a last note, even if you can't conceive of a single time that you will ever need to use Haskell, learn it anyway. It will blow your mind. Check the canonical powerset of a list function below if you still need convincing:

powerset :: [a] -> [[a]]

powerset = filterM (const [True, False])

I've tried to learn Haskell for two years now, every time giving up and trying again after a few monts. With this book I finally felt I learned it. It is a great book, mostly for the abundance of examples of fully developed projects. I still think they could have included the full code of every example, but it deserves five stars only for having brought me to the point where I can consider doing my own project in this wonderful language.

BTW the book is free online, but I like having my dead-tree copy.

This is both a great book, and a horrible book, for learning Haskell. In short, it's well-written, has good structure, and complete examples that enable you to follow along, but it's getting too old.

I feel I learned a lot from it, but it took a great deal of effort. Apart from breaks here and there, I started a year ago, and decided to devote one hour every morning to it. I also decide to rigorously type in everything in the book, in order to learn by doing.

What's good:

The book introduces Haskell without assuming that you know anything about the language. It tells you how to get started, even how you install Haskell on various operating systems, including Windows, Mac OS, and multiple variations of Linux.

Whenever there's a code listing, it starts with the name of the file, so if you're typing along, not only does it tell you what to type, but also in which file you should put the code. I found that tremendously helpful.

In the first many chapters, the code is introduced in order, which means that it compiles right away. In later chapters, when you see some more 'real-world' examples, the code doesn't compile right away, because it calls functions not yet defined. Sometimes I found myself typing for days before I could get everything to compile, and then I had to go back in order to try to understand what I just spent some hours typing.

The entire text of the book is legally available for free online at [...], so I could have simply cut and pasted from the site. Still, I chose to type, because I believe that the act of typing helps me retain what I've learned.

The online version of the book includes community contributions in the form of comments, and I found those indispensable.

What's bad:

First of all, the book is from 2008, and while that doesn't sound that terrible, unfortunately it predates some breaking changes that were added to Haskell since it was published. In general, I was able to handle the problems that arise from those breaking changes, often because someone had already blazed the trail before me. I found a few answers on Stack Overflow, but in general, most help was already available in the comments to the online version of the book.

One or two chapters are so severely impacted by the breaking changes that I gave up on making the code compile, but in most cases, I managed. Often, it was difficult, and I was stuck for days, but I also believe that I learn something valuable about the language from having to troubleshoot old code.

There's a good answer on Stack Overflow on [...]4 that summarises which parts of the book are obsolete, and which parts are still good.

Another, unrelated, problem with the books is that the exercises are often ambiguous or just formidable. A few of them, I could solve in a couple of minutes; some of them, I spent weeks on; and some I simply gave up on.

Summary:

I learned a lot from this book, but it was also because I was willing to put serious work into it. For that reason, I consider my efforts worthwhile, but I'd probably not recommend this book to someone interested in an introduction to Haskell today. Too bad, because it's the only Haskell book I've read so far, so I don't know of an alternative to suggest.

The book is a perfect introduction to Haskell for people who already know a bit of programming. There are practical examples of useful projects done in Haskell, and the author seems to have a great knowledge of the underlying language which he manages to pass down to the readers.

Real World Haskell will show you a lot of tricks and good practices. I bought the book because of this and I'm not disappointed. I'm giving it a four because I miss a few topics, and the examples are sometimes not very "real world". Still a good book though.

wow! many years ago I wrote my thesis on ML type system and its extensions possibilities, and now that I'm sixty this book is really a joy.

Haskell represents the legacy of ML philosophy and this book makes it available to everyone with clarity and freshness. I strongly advice it even if you will continue to program in c javascript php etc.

haskell helps you to think in a new clear way!

After a lifetime of programming in declarative languages like C, C++ and Java, I find it difficult to switch into the functional programming mindset. I suspect this is more to do with my age than anything else. I’m particularly interested in how to build systems that effectively make use of modern multi-core computers, assuming that we’ll soon have computers with hundreds of cores. In spite of what some experts say, I have grave doubts about our ability to reliably build such systems in the likes of Java; yes, there will some people who will be able to do it, but how will the common or garden developer do it?

Enter functional programming. Erlang has the ability to succeed with multi-cores, though I have my doubts about its efficiency; it’s great for network-heavy applications, but is it quite so great for compute-intensive apps? I’m not convinced yet that functional programming (Erlang excepted) has the ability *right now* to build hugely scalable multi-core apps - but I think the potential is there, and any developer putting the effort into becoming proficient at functional programming may be hugely rewarded in the future.

Given this hypothesis, how to go about it? Haskell has a reputation of being an extremely pure functional language. It also has a reputation of being very hard to learn. This is where “Real World Haskell” comes in. If you study this book right to the end, you’ll have made the mindset switch. Be warned though, it has 650 pages and is heavy going. Not because it’s badly written; on the contrary, it’s written very well. It’s because there’s a huge amount of technical stuff to put over. Recursion, folds, partial functions, lambda functions, typeclasses, and monads anyone? (Write programs using recursion in Java etc, and get used to stack overflows; not the best way to write highly stable apps).

Back in the 1990s I went through another mindset switch - from procedural thinking to object thinking. I’m finding this one harder. After studying a couple of hundred pages, and having studied Erlang previously, I began to experience the mindset switch. Unfortunately it was fragile, one minute I was thinking functionally and the next back to declarative. The real world intervened though, and I had to stop the study; so I slid back to declarative thinking. Real soon now I’m going to take another run at it. Of all the Haskell books, this is the one I’ll use. I’ve found others either too simple or too academic; for me, this book is just right.

I love this computer language and I love this book. Well done!

Having a background in science, with this book I felt the way I used to feel with college textbooks back in my student days - you're happy if you can digest a page or two in a day. But once you understood the stuff, the knowledge becomes a part of your internal thinking and reasoning.

Chapter 10 with its ad-hoc monadic parser is ``a newbie killer''. The discussions of parseByte on the website with the text of the book helps. Reading on the state monad helps to understand the chapter too.

Out of several Haskell textbooks on my bookshelf (pretty much all you can find on Amazon & internet bar Bird's books), this is the one I refer to most often and quickly find an answer.

You may need other Haskell books too but you can't go wrong with this one.