82 of 84 people found the following review helpful
Gordon M. Brown
- Published on Amazon.com
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.
45 of 46 people found the following review helpful
- Published on Amazon.com
Haskell is a wonderful language - it's functional, strongly typed, elegant, and lovely to code in. However, to many programmers (even seasoned ones), it's daunting to learn. As a Haskell programmer trying to spread the joy of Haskell to friends and coworkers, this is a real pain. However, I have used Learn You a Haskell For Great Good!, by Miran Lipovaca, for some time now to help get others into Haskell, and I'm thrilled that it's finally been published as a physical book by No Starch Press.
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!.