Learn You a Haskell for Great Good!: A Beginner's Guide

This book really blew my mind! It is superbly done. What I especially like about it is the way it hints at the underpinnings of Haskell (and functional programming) in category theory (and other formal systems); thus making them much more accessible and comprehensible. The discussions about monads are fantastic! The examples are first rate: it's well worth going through each and every one of them (slowly and carefully) to fully absorb the gold mine of insights each one can impart. (Even if you think you already understand the concepts: you might just find yourself seeing things in a novel and unexpected way! ;-) I truly hope the author will write another book. He has a real gift and talent; not only in explaining, but also in making things interesting. I actually found this book hard to put down. It really drew me in. (Not just any technical book can cast such a spell!) This book should be of great interest to F# programmers. F# materials alone will not give a reader enough insight into the milieu of functional programming to really appreciate monads (for instance). In fact, I say: to really learn C# you need to learn F#, and to really learn F# you need to learn Haskell. I also hope one day we'll have H# available as a fully integrated citizen of .Net (following in F#'s footsteps). Haskell to me is well worth learning because it is so pure. The lessons learned can then be mapped back to many existing technologies that one must work with. (Legacy technologies aren't going away anytime soon; but the good news is that the Haskell way of thinking can still be leveraged to great good in many venues.) The hand drawn artwork (done by the author himself!) added a lot to the tapestry and enchanting magic of this well crafted book. In conclusion: my greatest praise for this book is the way it took such a lofty and important topic and made it so amazingly accessible, fun, and fascinating. Kudos for a job well done!!!

One of the best books I've read, period. I just finished this book recently, however I've had prior exposure to the language (although never programming formally in it): typeclassopedia, Programming in Haskell, Erik Meijer's on-line lectures, etc. (the usual resources) as well as all 1200 pages from Chris Allen,and Julie Moronuki's "Haskell Programming from First Principles" book. While this book doesn't have exercises, I think it has the others beat in one category: simplicity. I'm also of the school where I think it's effective to show someone a concept(s) then let them go out to apply it to their own projects rather than giving them an assortment of examples/exercises to do. Also, although some of the other references/books assume the reader as a pure beginner, this is the only book that sincerely holds true to their word and treats them as a beginner from it's first to last pages. The others I noticed tend to assume the reader has more experience as a programmer and even with the language as well as functional programming itself (I could understand why in typeclassopedia's case). This book is very well written compared to the others as well. The explanations of the concepts are very clear and straight to the point, with nice analogies and examples. Although in the printed edition there are some typos, the free version (available online) has the corrections- all you have to do is visit the section you're reading. But what's great about that is, because their explanation is clear, you'll have the knowledge to catch it, run a double check on their website and be on your way. As mentioned, it's about simplicity. One thing I really appreciate about this book, is it makes everything about the language first. It may not cover the more technical things like testing, stack, cabal, etc. But if you just want to learn about Haskell syntax and it's concepts (from currying to monads), this is the book for it.

I always liked Haskell and wanted to learn it. I tried Real World Haskell but while I enjoyed the language a lot the book frustrated me with its organization and unwanted deviation from the main point of introducing the language. This book is such a joy though. I actually decided to buy it after reading most of it online from the author's website. I don't find his narratives particularly funny but his introduction of the language was concise and extremely easy to understand. Most importantly, the book is full of useful pointers and has a minimal amount of jargon that put me to sleep. I think the fact that he was a student when writing the book must have helped. The book doesn't have any exercise but I never am one to bother doing those. Still, I find myself testing things out and going back to earlier chapters where I can easily find the relevant information because they are so concise and straight to the point. Highly recommended.

A young man from Slovenia, just 23 years of age, writes his first book documenting a difficult computer-programming language, in English, which is not his native language. Given these facts, you'd think the odds would be stacked deeply against any measure of success for him. Yet it appears that, with his book Learn You a Haskell for Great Good!: A Beginner's Guide , Miran Lipovaca has almost smashed the ball right out of the ballpark. It is easily the best text available for an absolute newcomer to Haskell, and would also benefit many who've already perused other Haskell books. Moreover, of the seven volumes on Haskell that I own, it's the only one that I've so far managed to read cover-to-cover (including, BTW, typing, testing, and hacking all the code in it. I have, however, come close to finishing Graham Hutton's book, Programming in Haskell , which in most respects could not be further removed from this one.) Another big "plus": Mr. Lipovaca's code actually COMPILES. All of it. (Professor Hutton, are you reading this?) I say "almost smashed it out," though, because there is room for improvement. Even at that, I think Lipovaca has, at the very least, hit a long triple, just bouncing off the top of the center-field wall, with this book. To begin with, I must disagree with the reviewers who've claimed, in one way or another, that the author has left out information important even to a beginners' text. On the contrary, the scope and breadth of this text are truly astonishing. Nowhere else have I seen monads, monoids, functors, applicative functors, and the like, treated with such thoroughness and patience. As one or two other reviewers have pointed out, Lipovaca has even managed to impart insight into how these constructs actually obey the same laws that are expected of their theoretical counterparts in higher mathematics, specifically category theory--without getting bogged down in technical details. This would be a stunning achievement for any author, let alone one who's just writing his first book! As a programmer/hacker of more than thirty years, one who's deeply immersed in the imperative programming paradigm, I've truly come to appreciate how Lipovaca divides topics into small, bite-sized, easily-digestible chunks, with (mostly) easy-to-follow code snippets, before moving on to the next chunk. Indeed, he appears to approach his pedagogy from the sympathetic viewpoint of one who has quite recently had to grapple with a welter of high-flying, highly abstracted, and theoretical texts, and who consciously wants to spare his own readers this sort of iniquity. If Mr. Lipovaca's book leaves anything at all to be desired, they would be the following: (1) More systematic use of exercises and problem sets at the end of each chapter; (2) Greater use of extended programming examples, and maybe a few programming projects that readers and hackers can really sink their teeth into. As for (1), despite the wealth of code snippets that the author provides, I still find myself wanting to test my assimilation and understanding, by forcing myself to complete a related set of exercises at chapter's end. To my way of thinking, in a beginners' text these exercises are absolutely indispensable. (Maybe it's just me, but without such exercises I always have the lingering, vaguely nauseated feeling in my gut that I haven't quite absorbed the relevant topics fully.) To take just one example: in his otherwise excellent discussion of randomness and pseudo-randomness (pp. 190-198), the author employs a snippet of code to intimate the beginnings of a rudimentary password generator (on p. 195). Here he misses a good bet, I think; he could have easily followed this up with a series of exercises cuing the reader to develop more powerful and refined versions of the password generator; for instance: "(1) Write a brief program that extends the password generator on p. 195 by generating a number of different passwords, the number of which the user can input from the keyboard; (2) Extend this program to allow the user to specify the length of the passwords generated; (3) Now have the program output the passwords in rows of five across, with all five columns aligned; (4) Develop your generator further, by allowing the user to incorporate upper- and lower-case characters, and/or numerals, and/or other typographical symbols, in the passwords;" and so on.* As for (2), greater use of extended programming examples and projects, Mr. Lipovaca begins to do as much with his Optimal Path program of Chapter 10, and with the examples used in the final chapter on zippers, yet it still strikes me that he could go much further in this direction. This is one of very few areas in which Graham Hutton's deeply flawed book, Programming in Haskell , truly shines. I would particularly like to see such examples deployed when readers begin swimming in really deep waters--such as when the discussion turns to creating types, use of applicative functors, monads, and suchlike. Happily, Mr. Lipovaca is as amicable and easy-going as his funny drawings suggest; I've corresponded with him on a few occasions, and he seems willing to address the use of exercises and projects in a subsequent edition of this book. If such an edition does come to pass, I will gladly shell out the bucks for it if the text is expanded to 450-500 pages, maybe with smaller chapters in greater numbers, and comes with copious examples to practice upon and hone the craft of Haskell programming. THAT book would be an absolute world-beater--and a "tape-measure" home run that bounces into the city streets.** __________________________ *Anyone interested in seeing this program realized should Google XGB Web and Software Design, visit the Programming page, and click the link that references code for the password generator. **Oh, and have I pointed out how much I LOVE the "I lie flat" feature of this book, with its semi-detachable back cover binding? I wish EVERY techbook had this feature.

Fundamental concept about Haskell: higher order function, functor, type classes are clearly explained. Although you can't learn functional programming skills by this book, but for Haskell language, this book is enough. There are some humor in this book, some people might not appreciate it(but I do), but it won't confuse you, you can ignore them without missing anything about Haskell. The pictures made by author is very funny, too. Functors and monads are actually from category theory, you should check it out if you like the concept. Monoid is from abstract algebra, read a good abstract algebra book would help a lot if you are a computer science student. Standard CS in college only mention abstract algebra in discrete math course, which is not enough.

Incrementally explaining Functors, Applicative Functors, and Monads makes it easy to grab. Even though some examples are not clear enough, the book is the best among the books I read on Haskell. It starts from functions and makes them operate on lists and then lifts the logic to category theory while keeping it simple and practical. I always think that a well organized short book gives more than the book of thousand pages that are full of unnecessary statements. I enjoyed reading the book. Thanks to the writer.

Learn You a Haskell for Great Good is a seminal book in recent Haskell pedagogy, and unlike most books on technological subjects, I actually was able to summon the will to finish it cover to cover. Others have praised Miran Lipovaca's ability as a very young Slovenian author to write a coherent book on a difficult programming language that is fluent in both American English and American culture; praise is deserved for this impressive feat. That said, I think the book is somewhat flawed in its approach, and I'm not sure I would have spent the time to work through its 360 pages if I had a chance to get the time back and re-do my introduction to Haskell from scratch. Much of this review will read as a negative tirade, so let me first state that the book does accomplish a basic set of goals for an introductory text. The reader will learn the essential syntax of the language. Haskell has some of the most beautiful and sensible constructions I've ever seen in computer science: for instance, type variables and type classes allow for astonishingly powerful yet correct polymorphism, and the Maybe monad is sheer elegance in modeling a computation that could potentially fail. The clear excellence and usefulness of these constructions does shine through in this text. That said: The book is painfully verbose. While the silly drawings throughout the text are mostly cute and fun, the immature and occasionally insensitive humor both in the text and in code snippets gets old quickly. The bulk of examples are trivial and not intellectually very interesting, and the effort to make them humorous costs a lot of keystrokes. A lot of text is devoted to Sound And The Fury-esque literal translation of code snippets; this becomes tedious after the reader is 200 or 300 pages into the book and has already gained some basic fluency with syntax in functions and Haskell's type system. I think I disagree with the principle of the "Hello World" program showing up 152 pages into the book. I feel like my learning started to accelerate after the Hello World, simply because the understanding of IO empowered me to start writing throwaway Haskell scripts to solve simple problems in my day job. This doesn't mean I'm advocating writing non-idiomatic mock-imperative Haskell in the main function: solving real computational problems with nontrivial functional programming takes hard-won practice. IO is the gatekeeper to reality, authentically motivating the working programmer to do this practice. The verbosity and lack of an early entry point to start productively using Haskell are exacerbated by the lack of exercises or theoretical depth. There are some very deep concepts in Haskell, and I feel like this book had me skating on the surface a lot of the time. In an exercise-free text, I expect some depth and consistent interest from the worked examples. There are a few pretty nice examples. One is to implement a reverse Polish notation calculator with a fold. Another, with birds landing on and taking off from a tightrope walker's balancing pole, makes the power of monads completely transparent. But then there's the crippled implementation of Dijkstra's shortest-path algorithm (which is never mentioned by name) - one is left agonizing about whether and how Haskell actually enables a nice implementation of the general algorithm. One of the few substantial end-to-end programs featured, which gets and sets the state of a todo list in the filesystem, is not only banal but buggy - apparently so boring that Lipovaca just copy-pasted previous code snippets into the final program without actually testing the resulting software. (To its credit, the book's superficiality and lack of exercises does improve the reader's chances of actually finishing.) Working through the code examples while reading the book makes it clear that Haskell is very much a living language, as it sometimes takes significant modification to get them to compile and run, particularly in the second half of the book. Since the book's writing, Haskell's standard library facilities have evidently been heavily re-organized, implementation of things like bytestrings and random numbers has changed, and the Functor-Applicative-Monad Proposal was implemented. Major portions of the code and text are simply incorrect in the current version of Haskell (GHC 7.10.2) as a result. A new edition of the book is warranted if only for this reason. At the end of the day, the book's purpose seems a bit schizophrenic. It caters to a less sophisticated beginning reader with verbosity and an unwillingness to refer to undergraduate-level computer science knowledge. But the world of monads, monoids, and functors is nothing if not sophisticated, and beginning reader would probably be happier solving the book's simple examples with simple techniques in a simple imperative language where IO and control flow are front and center. The more sophisticated reader is left feeling tantalized, still uncomfortably far from the breakthrough where he or she can solve meaty problems with game-changingly productive, airtight abstractions. Both types of reader probably stand to benefit from Learn You a Haskell, but neither are likely to come away completely satisfied.

I downloaded this book as a free pdf from the book's website initially. After reading through a significant portion of the pdf, I decided to purchase the print version in order to have a handy chunk of dead tree to use (I prefer dead tree versions of books, generally speaking) and to support the author, because I thought the cook was simply fabulous. I must admit, first, that I had previous exposure to functional programming (in the context of scheme), so my review may be a bit biased. That being said, I felt that this book did an amazing job at providing a very informal, well paced introduction to both the Haskell language and functional programming in general. Unlike most of your "for dummies" books (as well as all of the similar variations of that general genre), however, you won't be insulted by ridiculously dumbed-down explanations or suffer from way too many forced puns, jokes, etc. The author does take a very lighthearted approach, employ humor, etc., but it seems much more natural and is much less obnoxious than most books which attempt to take such a route.

La programmazione funzionale è un paradigma nient'affatto nuovo (si pensi al Lisp) che sta ora vivendo una seconda primavera, principalmente grazie alla grande resistenza agli effetti collaterali indesiderati (chi ha provato a programmare in C sa di cosa parlo!) e maggiore semplicità di debug anche su progetti grandi e complessi, ma anche grazie alla comparsa di nuovi linguaggi come F# di Microsoft e ancora di più Haskell. Il testo di Lipovača è ideale per chi parte da zero, sia con il linguaggio sia soprattutto con il paradigma. Non solo la sintassi e le funzionalità principali sono spiegate, e la filosofia è ben illustrata: ma soprattutto, lo stile invoglia a proseguire la lettura e andare avanti con la sperimentazione, virtù rara in questo genere di manuali. Sia che si voglia usare l'interprete Haskell come semplice calcolatore per risolvere problemi di media entità, sia che si desideri un'introduzione alla programmazione funzionale che consenta poi di passare a testi più approfonditi, Learn You a Haskell fro Great Good! è un investimento solido che ripaga molte volte il denaro speso.

One of the top 10 programming book. Allows you to get slowly into functional programming. Once you're done with this one, I suggest you look at Haskell from the first principles (the purple book).

I have been reading Real World Haskell, but after reading the first hundred pages I felt that I where missing a few things. I then bought Learn You a Haskell, which I find to be absolutely fantastic at explaining the basics of Haskell. The flow is on the verge of being perfect, whenever I think I'd like to move on, the book does. There is a little humor here and there, which I like, and the drawings are also quite enjoyable. It explains subjects, even some which where hard to grasp by other sources, really well. The combination of Real World Haskell and this book is great. This is a friendly book, which will dress you up nicely for the journey into the dragons den (Just kidding, Haskell is a beautiful language!)

This book taught me to how to make proper use of the Functor, Monoid, Applicative and Monad classes and their instances, something I've been meaning to get around to learning for ages. The explanations of these were exceptionally clear and easy to follow.

Este libro es una verdadera joya para aquellos interesados en aprender sobre programación funcional. Está escrito de manera clara y accesible, con explicaciones detalladas y ejemplos prácticos que hacen que el aprendizaje sea muy fácil y ameno. Lo que más me gustó de este libro es que no solo te enseña los conceptos básicos de la programación funcional, sino que también te guía a través de la implementación práctica de algoritmos y estructuras de datos en Haskell. Es un enfoque muy completo que te permite no solo entender la teoría, sino también aplicarla en situaciones reales. El autor tiene un estilo de escritura muy ameno y humorístico que hace que la lectura sea muy agradable. Además, el libro está estructurado de manera lógica y bien organizada, lo que facilita el seguimiento del contenido. En resumen, si estás interesado en aprender programación funcional y buscas un libro que te guíe de manera clara y accesible, este libro es una excelente opción. Con su estilo ameno, explicaciones detalladas y enfoque práctico, estoy seguro de que aprenderás mucho y disfrutarás del proceso.