Learn You a Haskell for Great Good!: A Beginner’s Guide 1st Edition by Miran Lipovaca (PDF)

Description

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 worldShort 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!

User’s Reviews

Reviews from Amazon users which were colected at the time this book was published on the website:

⭐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

⭐, 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,

⭐, 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,

⭐, 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.

⭐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.

⭐The ‘Learn You a Haskell’ book is an excellent introduction to Haskell. Having studied under one of the main contributors to the language, I had to learn much of the language in a very short space of time. Having read other Haskell textbooks this one is definitely the one to go with!The book itself is very nice quality. The wording is very clear and casual which is a very rare find in programming literature. You won’t get stuck wondering what words mean but at the same time it offers a very solid grounding (and even some more complex concepts!) for the Haskell language.Note that the book is essentially available in the form of the “Learn You A Haskell” website but it’s always beneficial to have a physical copy.I would definitely recommend to anyone wanting to study a functional language.

⭐Among the best introductions to a programming language I have came across, it gives me a similar feeling as when I first read “The C Programming Language” hard and fast without sacrificing. Assumes the reader is familiar with imperative programming and is looking to get started in functional programming. As such it will introduce concepts not particularly widely used across procedural or object orientated languages but does not introduce Haskell as a first language often contrasting against concepts from the imperative world. There is a lot to learn here and unlike many books on the topic this one is simultaneously accessible and not patronising.I should probably note that if you are already familiar with functional programming or have some previous knowledge of Haskell then it might be a little slower feeling than to me.

⭐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!)

⭐The content is great and surprisingly I’m sure this book goes into more detail than the site does (which is free to read on). Having a copy of this I prefer to read than from a monitor. Only 4 stars because my copy the print leaves a little to be desired and the finish on the cover isn’t the best.

⭐The book is written in a light-hearted but conscious manner. The code examples are clear and well chosen.If you are an experienced programmer in other language(s) you will often find yourself skipping/glancing over content. I was a bit disappointed that it doesn’t go into much depth, but I am giving it 5 stars, because even the subtitle states “A Beginner’s guide”. And it is a really good one.

Keywords

Free Download Learn You a Haskell for Great Good!: A Beginner’s Guide 1st Edition in PDF format
Learn You a Haskell for Great Good!: A Beginner’s Guide 1st Edition PDF Free Download
Download Learn You a Haskell for Great Good!: A Beginner’s Guide 1st Edition 2011 PDF Free
Learn You a Haskell for Great Good!: A Beginner’s Guide 1st Edition 2011 PDF Free Download
Download Learn You a Haskell for Great Good!: A Beginner’s Guide 1st Edition PDF
Free Download Ebook Learn You a Haskell for Great Good!: A Beginner’s Guide 1st Edition