Definitely overstated and not good advice for beginners.
My advice to beginners would be:
- Read all the Haskell books available at your disposal. (In addition to LYAH and the Hutton book, I would say Learning Haskell From First Principles and Get Programming with Haskell are great, https://www.manning.com/books/get-programming-with-haskell, http://haskellbook.com/)
- When you hit something that doesn't make sense in one source, try referencing it in another source.
- When you have some experience writing programs in Haskell, refer to some older books like Real World Haskell. There may be a few issues compiling the examples, but nearly all the techniques in the book are still widely used and you learn about the language has progressed in the last few years. This gives you a compass to read and maintain older Haskell source code).
- Read as much Haskell code as you can from popular libraries (Pandoc, XMonad, and smaller libs as well).
1. Someone who has never programmed before, and is perhaps young. Someone who has to be guided. A novice.
2. Someone who is new to this particular language, but is experienced at programming generally; who is attempting to learn the language to use it "in anger" (i.e. with a specific goal in mind and a timeline for that goal); and who is willing to "do whatever it takes" to learn the skill. A journeyman beginning a new path.
A novice needs a definitive textbook. A journeyman-beginner, on the other hand, needs definitive primary sources, however scattered.
If you're a high-school student learning precalculus, what do you need? A math textbook.
If you're a post-graduate student learning some specific arcane sub-discipline of math to see whether it could be used to solve the novel problem you've decided to do your thesis on, what do you need? Primary sources. All the journal papers in that field you can get your hands on. There's no one textbook that could possibly help you; the only truth you will find is the truth "between the lines" of everything you read.
When I was first learning to code I can remember deciding to stick with one learning resource so as to not overwhelm myself. Eventually I hit a road block and wasn’t able to push past it. I blamed myself for not being able to understand what I was reading. I wasn’t smart enough.
When I tried again years later, instead of sticking with one resource I flicked between several different ones at once. Seeing how different people explained the same concept was extremely helpful in getting things to “click”.
While LYAH may not be ideal, isn't calling it "terrible" a tad too harsh?
FWIW I learned Haskell using LYAH and enjoyed it thoroughly. It was my first time learning a language with such a high focus on functional programming, but I think this book did a good job of teaching it.
If anyone is familiar with it, Landau and Lifschitz is my kind of book ;)
EDIT: I've just skimmed the Hutton book. It looks great! That's what I mean. You don't have to be dense or incomprehensible or dry. Just stick to the point and explain as clear and concise as possible.
I rarely speak with enthusiasm... but teaching or explaining programming to people just gets me really, really excited. Putting myself in the shoes of a novice who is about to have some realization about the nature of an algorithm makes me shiver with anticipatory glee.
It's hard not to put that into my writing. It's not fake in the slightest—it's the only time I can let it shine through just how much I love this stuff, and it'd be fake to hide it. Even the constant "cute analogies" are part-and-parcel of this exuberance—symptoms of temporary hypomania brought about during the writing process.
Certainly, I could go back and edit all this stuff away. But, really, should I? I never had a role-model who was as excited about programming as I am. I wish I had had one. I, therefore, find it hard to restrain myself from being that person for others.
Well it's fine for beginners, because beginners want easy explanations and many examples to start with, instead of very precise definitions which requires a precise math vocabulary.
If you're learning the basics of Computer Science you usually don't have to do this so Haskell is a great language then.
If you'd like to see for yourself what that course was like, here are lecture notes (and assignments, and mid-term exam): https://www.cmi.ac.in/~madhavan/courses/programming08/index....
Orwell (Haskell predecessor) was used later at Oxford, and I think ML at the other university. "Preparing to study Computer Science at Cambridge" once said "Teaching yourself to program can lead to your picking up bad habits that will hinder your progress later. In particular, you should avoid languages like C++."
Much of the language seemed like magic, but ANU had a culture of throwing students in the deep end to keep us humble about what we knew.
(no referral link)
I've used Rust, SML, and a bit of Scala so I don't feel like it should be that difficult to pick up Haskell. Next time I get the urge, I'll try Hutton's book.
Some chapters are really basic and easy to read (like the chapter on recursion), and others are insanely dense and thick and basically unintelligible the first time through (like the chapter on functors).
We tried reading it for a book club once, and the weeks with the easy chapters there was no discussion to be had and the weeks with the difficult chapters ended up being "did anyone understand any of this?" and trying to figure it out together - which was somewhat helpful, but the book just really ended up being an excuse for us to learn together and not a resource in and of itself.
Then again, Hutton's book seems legitimately criticized too for beginners looking at the reviews I'm seeing on Amazon with some preferring or suggesting LYAH as a needed complement. So to each their own.