- Amazon Student members save an additional 10% on Textbooks with promo code TEXTBOOK10. Enter code TEXTBOOK10 at checkout. Here's how (restrictions apply)
Learn You a Haskell for Great Good!: A Beginner's Guide Paperback – Apr 21 2011
|New from||Used from|
Special Offers and Product Promotions
Frequently Bought Together
Customers Who Bought This Item Also Bought
No Kindle device required. Download one of the Free Kindle apps to start reading Kindle books on your smartphone, tablet, and computer.
To get the free app, enter your e-mail address or mobile phone number.
About the Author
Miran Lipovaca is a computer science student in Ljubljana, Slovenia. In addition to his passion for Haskell, he enjoys boxing, playing bass guitar, and, of course, drawing. He has a fascination with dancing skeletons and the number 71, and when he walks through automatic doors he pretends that he's actually opening them with his mind.
What Other Items Do Customers Buy After Viewing This Item?
Most Helpful Customer Reviews on Amazon.com (beta)
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.
The book doesn't go into any of the really hairy stuff, such as monad transformers, the subtleties of laziness, or unsafe IO, which are probably required for serious Haskell programming. But I guess it's excused, since it does call itself a beginner's guide. It *does* do a very fine job of showing how purity, type classes, and category theory concepts provide mind-blowingly elegant solutions to real, practical programming tasks. As such, I've started recommending it to anyone who asks for a good introduction to functional programming.
First a caution: Learn You a Haskell is not designed for non-programmers - it is not a guide to learn how to program. Rather, it's a guide for programmers who are used to imperative languages (like C, Java, or even Fortran) to learn about functional languages (and, obviously, Haskell in particular). What's nice about this book compared to other typical programming guides is that it's engaging to read; it's funny and cute, and the content is consistently clear. Also, the order in which the material is presented makes sense.
The book starts out with a few chapters on the basics. Lipovaca shows how to call functions, use lists and tuples, and understand the basic type system. He goes on to explain pattern matching, recursion, and higher order functions - the bread and butter of functional programming. The descriptions and examples (and even the doodles) are great. He goes through the toolkit of many commonly used functions (reverse, zip, map, fold, ...) and shows how to implement them from scratch.
Chapters 6 though 10 focus on actually using Haskell to write real programs. Modules are covered briefly before a great section on type classes. These can often be confusing to new Haskell programmers as they are very different from classes in a language like Java, but Lipovaca provides plenty of examples and clear explanations to make the learning process smooth. Next, input and output is introduced. Nothing very complicated is addressed - it's limited to basic console and file I/O - but it's more than sufficient to give a pre-monad overview of I/O. Chapter 10 is almost like a halfway point in the book. We use what we've learned so far to make a nice, useful, functional program before delving into the deeper type classes that are so critical to advanced Haskell programming.
The next few sections are where LYAH really shines. Where many Haskell resources introduce monads all at once with little reason for why they exist or how they were designed, Lipovaca builds into them beautifully. We start with a clear explanation of functors, then applicative functors, then monoids, and finally monads. It makes the following chapter on some common monads (Reader, Writer, and State) seem downright easy. (I'll admit: I had trouble with the State monad for a while when I was first learning Haskell - I wish I'd read this earlier!)
The book ends with a chapter on zippers that seems oddly out of place. Where most of the other chapters build from their predecessors, this one had nothing to do with anything from the previous few chapters. I think it would have been much better suited just before or after chapter 10 than as the climax of the book.
Overall, LYAH is a solid beginner's guide to Haskell. It covers most of the basics, does a great job with the beginning advanced material, and is fun to read to boot. I would have liked to see a section on Arrows, as I find myself using them more and more, but I recognize they're still pretty fringe right now, so I see this as only a minor fault. If you already feel comfortable with applicative functors and monads, this book won't provide much new material for you, but if you're anywhere from having no idea about Haskell to still afraid of the state monad, I highly recommend Learn You a Haskell For Great Good!.
This is where I felt the book was at its weakest. It attempts to use the same teaching mechanics from the first ten chapters, but the subject matter imposes a steeper assimilation curve and demands a more patient treatment (not to mention a few practice exercises and least a superficial introduction to using monads as modeling tools).
While "Learn You a Haskell" remains a decent introductory book (and though it pretends to be nothing more than this), I felt that it tried to span some complex subjects which it treated too casually. Some of the material appears to be a little outdated as well. These are the reasons why I'm taking two stars.