I am finishing the chapter on monad transformers. I read everything up until now. Seriously, I never read technical texts so quickly but this is amazing. Yes I'm definitely joining the lines of people singing praises to your work. When I graduate as a mechanical engineer, a couple of years from now, I want to get as far from steel and parts design and as close to software as possible. Maybe if the teaching materials in my area were as pedagogically sound as your book I would have been captivated by mechanical engineering as I've been by software.
The chapters up to the hairy-sounding typeclasses (starting from Monoid) were easy enough as I've been trying to learn Haskell for over one year. However I found them full of pearls and very worth reading! In particular, the discussion about data structure spines and the use of undefined to study language semantics really hit me in the face as awesome.
This theme of I finding useful insights in things I had already learned via cis194 and NICTA (hugs to you, @bitemyapp) continued through the "basic" typeclasses. Monoid up to Monads. Then I felt confidence for the first time on some typeclasses: Foldable and Traversable. The latter one, in my opinion, is very very poorly explained by all the other materials I had read. Now I am on truly new territory with monad transformers. You gave me the motivation: the need to compose monads and then you explained it all in a clear understandable way.
Thank you very much, this is truly amazing. I wish the Haskell community growth continues, and long live to the ML-like type systems!
Seriously . . . I struggled through Monoid, Functor, and Applicative exercises. I learned things about the typeclass system I didn't know that I was missing -- while making Arbitrary instances for them, I swore at my computer and googled furiously and vowed I'd never write another line of Haskell and then came back for more.
After all this, I get to Monads . . . and I just get it. "Oh, so that's what a Monad is. No big whoop." I wanted the ecstatic gasp that comes with the onrush of enlightenment. I wanted to bask in the radiance of esoteric knowledge. I WANTED TO CLIMB MYSTICAL MOUNTAINS.
Before Monads -- Chop wood, carry water.
After Monads -- Chop wood, carry water.
When @haskellbook is done, it will be an unexpected milestone for #haskell. There will forever be Haskell before, and Haskell after.— Jason Kuhrt (@JasonKuhrt) February 13 2016
Hi Chris & Julie,
Wanted to drop a note thanking you guys for writing Haskell Programming. I'm an intermediate Scala developer and had been looking to get into the deep end of FP but frustrated since a lot of the Scala literature seems to be either "Here go read this Haskell" or "Ignore 65% of this post, it's just Scala being weird". I have had a few half-hearted attempts at learning Haskell, but found the resources either difficult to follow or lacking in usefulness.
In that context, your book has been a breath of fresh air. I'm only just getting into the bits with Reader and State, but I've already gotten two valuable benefits that I haven't gotten out of other materials in the past: 1) a good enough intuition to start reading example Haskell and kinda-sorta know what's going on, and 2) my first "whoa, that's cool" moment with liftA2 and the applicative of functions. #1 in particular is great, since it helps leaps and bounds with reading a lot of the FP work out there that assumes familiarity with Haskell.
Thanks again for writing the book! I can't wait to read the rest of it.
Chris and Julie's book really is about the most practical Haskell book out there. You learn about both high-level constructs like Semigroup and Monad as well as 'down-to-earth' tasks like using Cabal and QuickCheck. The book is long, but not slow--a large fraction of it is made up of examples and exercises. You can tell it's written by someone who's taught Haskell to programmers before. Haskell is a deep language, but this work helps repudiate its reputation for academic mysticism by showing you how to use it in the real world!
.@haskellbook is easily my favorite tech book of 2015. Go get it.— Matt Green (@mattgreenrocks) January 11, 2016
This is a book that will teach how to learn. It dives in and out and back in again; so you don't miss anything. And it’s so painless and complete that you won’t appreciate how much you’ve learned until you have a chance to reflect. This is a ‘learners text’, it’s super-well thought out with tons of exercises that keep you moving along in your complete journey to becoming a competent Haskeller. I’ve read a few Haskell books, and with this one, I didn’t get bored once. I even took it on my vacation; I couldn’t put it down. Buy it, you won’t be disappointed!
I want to thank you for your great help. After munging through the last chapters 5-7 you released, i begin to understand the way Haskell of thinking & coding. I even dare to read through haskell.org stuff without feeling like an idiot. Cannot await the next stage on this trip!
one of the best technical books I have read these past few years. @haskellbook has definitelly made me a better programmer, thank you— Adrian Rosian (@whitecitycode) February 9, 2016
This haskell book explains complicated ideas in the most effective and simplest way I have ever seen in any programming book. If you can only read one Haskell book then read this Haskell book and you will not be disappointed.
TFW when you apply things learned from @haskellbook in Swift!— Sebastian Grail (@sebastiangrail) February 12, 2016
Oh boy, everything is a fold! I just got to the fold chapter in your book, and it hit me like a brick a couple pages in that pretty much everything we've seen up to now can be implemented with a fold. Not that I hadn't seen the idea before, but just realized how powerful of an idea it is :)
This is the best book on s/Haskell/any programming language/g I have ever read. Thank you so much!
Despite it still being in development with many expansions to come, my experience with the current 800 pages (now 912) of Haskell Programming has quelled any skepticism I had about its thoroughness or potential use to someone who had already spent two very devoted months studying Haskell. Having read books, blogs, and participated in Haskell's IRC channels during all of that period, thus covering most of the topics that are in the book, I felt like this would end up being more of the same: something that's useful (retreading over similar ground genuinely builds skill and understanding), but perhaps not an optimal use of my time (there are plenty of resources that already exist with which a person can do that, and I felt most suited to 'intermediate' resources).
Yet, Haskell Programming is so damn comprehensive, and so well structured, that it provided me with something that no other resource has been able to: an assurance that once I make it through a chapter, I will have learned the most critical things about its topic, and that anything which demands further elaboration ought to (and will be) addressed later on where it can be more deeply understood. So far the book has been very thorough about addressing each topic in as much depth as is sensible. I was tempted to skip the earlier chapters, but I'm very glad I didn't, and that the book clearly expresses why doing so is a bad idea in its introduction. Though it is targeted towards beginners, it ramps up at every chance it gets; it just doesn't want to make you lift weights before having you stretch. It is neither simple nor inaccessible, which is about perfect for learning.
Here's a short list of what I learned in those chapters that seemed like old news to me: I never really learned much about the Lambda Calculus, nor realized how much it explains how Haskell actually evaluates functions. I thought I'd understood Lists, but I'd never even heard the term "weak-head normal form". I supposed I was good at folds, but didn't realize that I could be great at them if my mental image of how they worked was enhanced. I figured I knew what data types were, but didn't have a deep intuition for the relationship between a type constructor and kinds, and a data constructor and algebra; I had no idea that learning why the hell | meant the data was a 'sum type' how having two or more arguments made it a 'product type' would actually be useful for reasons other that not impressing people with your boring knowledge (turns out they help you reason about code complexity and make smarter decisions with your data structures). I finally understand why a newtype is useful for reasons other than performance. I realized just how conceptually similar a Monoid + Functor and an Applicative Functor are.
Haskell Programming has thus put an end to the always-trying-to-figure-out-which-resource-is-best optimizing attitude that drove me from resource to resource in search of an understanding that usually takes more time and focus than most of them offer. Haskell has a sizable ecosystem, but it's really more for people who are 'intermediate' and above, and it turns out that intermediate Haskell knowledge is quite the tall order. Thankfully, this book's express goal is to take us there. Yes, you can learn Haskell without Haskell Programming, but with it you'll have one of the best inanimate companions you could hope for in that journey. It promises depth, and it really does offer it. It promises comprehensiveness, and I direct your attention to the current page count and pending additions. It promises clarity, and I promise you it has it. I also promise you that you won't learn Haskell more quickly any other way right now. If you're new to the language, have studied it for a couple of months, or basically are anyone who can't comfortably read through a library on Hackage right now, you'd probably love this book. Otherwise, you should probably read it anyways as a lesson on pedagogy.
Every time I approach 100% completion of @haskellbook, new chapters get released. 18ch in and still no end in sight. I'm ok with this.— Jesse (@thunk_life) January 11, 2016
Picked up @haskellbook finally! Great job you two-- this is written excellently.— Alex (@jacrough) January 11, 2016
"Structure and Interpretation of Computer Programs" has its credit, but @haskellbook is now my #1 recommendation for FP beginners.— Irio Musskopf (@irio) December 26, 2015
Speaking of @haskellbook - I also thought Monad Transformers were waaaaay above my level ... got more optimistic recently!— Sigrid Keydana (@zkajdan) February 24, 2016
Chris and Julie understand the landscape of teaching and learning Haskell well, and they are happy to be your guides through what is traditionally a minefield. They cheerfully come to this task with a well-reasoned, thoughtfully prepared, staged approach.
You might find yourself wondering what all of the hype of difficulty was about as you read this book, but don't mistake this for luck or a fluke: this is the genius of Chris and Julie's choice in topic ordering, well-rounded explanations and step-by-step introduction: they leave no gaps! It seems obvious in hindsight, but this is simply good design.
Viewed from this modular stack of understanding and knowledge, Monads seem almost disappointingly obvious.
This book makes learning Haskell possible, joyful, clear, and approachable. It doesn't talk down to you as you read it, and its authors are happy to put the huge effort required in to making the sharing of Haskell's foundational in-plain-sight secrets a delightful, fun, experience. Let me assure you, this is no small feat. Buy this book! Expect to learn a lot, work hard and enjoy the fruits of your labour.