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

Miran Lipovaca (Author)

Book Description

Publication Date: April 18, 2011

It's all in the name: Learn You a Haskell for Great Good! is a hilarious, illustrated guide to this complex functional language. Packed with the author's original artwork, pop culture references, and most importantly, useful example code, this book teaches functional fundamentals in a way you never thought possible.

You'll start with the kid stuff: basic syntax, recursion, types and type classes. Then once you've got the basics down, the real black belt master-class begins: you'll learn to use applicative functors, monads, zippers, and all the other mythical Haskell constructs you've only read about in storybooks.

As you work your way through the author's imaginative (and occasionally insane) examples, you'll learn to:

• Laugh in the face of side effects as you wield purely functional programming techniques
• Use the magic of Haskell's "laziness" to play with infinite sets of data
• Organize your programs by creating your own types, type classes, and modules
• Use Haskell's elegant input/output system to share the genius of your programs with the outside world

Short of eating the author's brain, you will not find a better way to learn this powerful language than reading Learn You a Haskell for Great Good!

Excerpt from the Introduction

Haskell is fun, and that’s what it’s all about!

This book is aimed at people who have experience programming in imperative languages—such as C++, Java, and Python—and now want to try out Haskell. But even if you don’t have any significant programming experience, I’ll bet a smart person like you will be able to follow along and learn Haskell.

My first reaction to Haskell was that the language was just too weird. But after getting over that initial hurdle, it was smooth sailing. Even if Haskell seems strange to you at first, don’t give up. Learning Haskell is almost like learning to program for the first time all over again. It’s fun, and it forces you to think differently.

NOTE
If you ever get really stuck, the IRC channel #haskell on the freenode network is a great place to ask questions. The people there tend to be nice, patient, and understanding. They’re a great resource for Haskell newbies.

So, What's Haskell?

Haskell is a purely functional programming language.

In imperative programming languages, you give the computer a sequence of tasks, which it then executes. While executing them, the computer can change state. For instance, you can set the variable a to 5 and then do some stuff that might change the value of a. There are also flow-control structures for executing instructions several times, such as for and while loops.

Purely functional programming is different. You don’t tell the computer what to do—you tell it what stuff is. For instance, you can tell the computer that the factorial of a number is the product of every integer from 1 to that number or that the sum of a list of numbers is the first number plus the sum of the remaining numbers. You can express both of these operations as functions.

> Read the Introduction (PDF) in its entirety.

Editorial Reviews

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.

Product Details

• Paperback: 400 pages
• Publisher: No Starch Press; 1 edition (April 18, 2011)
• Language: English
• ISBN-10: 1593272839
• ISBN-13: 978-1593272838
• Product Dimensions: 7 x 1 x 9.2 inches
• Shipping Weight: 1.6 pounds (View shipping rates and policies)
• Average Customer Review: 4.6 out of 5 stars  See all reviews (36 customer reviews)
• Amazon Best Sellers Rank: #85,734 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, read author blogs, and more.

Most Helpful Customer Reviews

50 of 50 people found the following review helpful

5.0 out of 5 stars Haskell can be this simple May 30, 2011

By Marijn Haverbeke

Format:Paperback

I'm not sure what kind of trick the author is pulling here, but this guide managed to walk me through all important Haskell concepts without ever making any of the material sound complicated. I had, through sheer force of will, managed to understand monads a few years back, so I didn't start from zero -- but somehow none of the mind-bending I remembered from last time was necessary this time around. Even terms like Applicative Functor and Monoid, which I assumed to be things only category theory wizards could possibly be interested in, are exposed by Lipovaca to be relatively simple, banal concepts with everyday uses.

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.

58 of 59 people found the following review helpful

4.0 out of 5 stars A solid introductory text that needs exercise sets and more extended programming projects September 9, 2011

By Gordon M. Brown

Format:Paperback|Amazon Verified Purchase

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. Read more ›

39 of 39 people found the following review helpful

5.0 out of 5 stars Learn You a Haskell April 29, 2011

By Dan WC

Format:Paperback

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!. Read more ›

11 of 11 people found the following review helpful

5.0 out of 5 stars Another Great Haskell Book (not just for beginners) April 14, 2011

By D. Leimbach

Format:Paperback|Amazon Verified Purchase

I saw this book in it's early stages when it was an open document online. I pre-ordered the book in August of 2010 and just received my copy a couple days ago. It was totally worth the wait.

The book says it's for beginners, but it walks from some fairly early topics all the way to Zippers, which, prior to this book confused me a good bit.

I recommend this book to anyone interested in Haskell as the different perspective on the approach of learning it can be enough to provide new insights to the language.

My only wish is that the author could have covered Enumerators, Iteratee and the like in the style of this book.