Product Description

This easy-to-use, fast-moving tutorial introduces you to functional programming with Haskell. Learn how to use Haskell in a variety of practical ways, whether it's for short, script-like programs or large and demanding applications. Written for experienced programmers, "Real World Haskell" takes you through the basics of functional programming at a brisk pace, and helps you increase your understanding of Haskell in real-world issues like I/O, performance, dealing with data, concurrency, and more as you move through each chapter. With this book, you will: understand the difference between procedural and functional programming; learn about Haskell's compiler, interpreter, values, simple functions, and types; find your way around Haskell's library - and write your own; use monads to express I/O operations and changes in state; interact with databases, parse files and data, and handle errors; discover how to use Haskell for systems programming; and, learn concurrency and parallel programming with Haskell. You'll find plenty of hands-on exercises, along with examples of real Haskell programs that you can modify, compile, and run. If you've never used a functional language before, and want to understand why Haskell is now coming into its own as a practical language in so many major organizations, "Real World Haskell" is the place to start.

Product Details

• Amazon Sales Rank: #28447 in Books
• Published on: 2008-12-05
• Original language: English
• Number of items: 1
• Binding: Paperback
• 710 pages

About the Author
Bryan O'Sullivan is an Irish hacker and writer who likes distributed systems, open source software, and programming languages. He was a member of the initial design team for the Jini network service architecture (subsequently open sourced as Apache River). He has made significant contributions to, and written a book about, the popular Mercurial revision control system. He lives in San Francisco with his wife and sons. Whenever he can, he runs off to climb rocks.

John Goerzen is an American hacker and author. He has written a number of real-world Haskell libraries and applications, including the HDBC database interface, the ConfigFile configuration file interface, a podcast downloader, and various other libraries relating to networks, parsing, logging, and POSIX code. John has been a developer for the Debian GNU/Linux operating system project for over 10 years and maintains numerous Haskell libraries and code for Debian. He also served as President of Software in the Public Interest, Inc., the legal parent organization of Debian. John lives in rural Kansas with his wife and son, where he enjoys photography and geocaching.

Don Stewart is an Australian hacker based in Portland, Oregon. Don has been involved in a diverse range of Haskell projects, including practical libraries, such as Data.ByteString and Data.Binary, as well as applying the Haskell philosophy to real-world applications including compilers, linkers, text editors, network servers, and systems software. His recent work has focused on optimizing Haskell for high-performance scenarios, using techniques from term rewriting.

Customer Reviews

Elevates Haskell from a theoretical distraction to a useful tool
I had been searching for a clear, concise reference for Haskell for years before I discovered this book.

The trouble with most existing Haskell tutorials and texts is that they always approach Haskell from the point of language theory: why Haskell is cool, but always fail to show how to actually improve the quality of your programs using a different paradigm.

This book is different. By insisting on being thoroughly rooted in practicality, it enables discussion of some of Haskell's more abstract corners (Monads and Monad Transformers) from a perspective of why they'd be useful to *me*, and how *I* could use them to solve programming problems that are mucky in other languages.

And for the first time, it all clicked. I at last understand Monads and why they exist. And since no other Haskell reference has ever done that for me, I can't recommend it highly enough.

A previous commenter has mentioned that chapters do tend to depend on previous examples in other chapters, and that makes this book useless as a reference. I disagree: I think there is significant didactic power in the approach of doing it once the hard way, because when concepts like Monads are introduced, it has an opportunity to do it again the right way, and suddenly Haskell's awesome expressive power is laid bare.

The wrong way to teach (programming)
I really wanted to like this book. The title alone seems so appealing. Instead of the usual, often dry, approach to teaching functional programming by means of mostly mathematical examples, this book takes a completely different approach by using realistic problems. At the same time the book seems targeted at people new to both Haskell and functional programming in general. Sadly, after reading this book I no longer think this is a viable approach to teaching.

Subjects are introduced as a "side-effect" (no pun intended) of developing fairly complex realistic programs. The authors seem eager to prove that Haskell can indeed be used for this. Unfortunately, this means they lose track of the teaching aspect. Not only do you have to learn difficult programming subjects (such as monads), you also have to understand the individual problems in the book.

This makes the book more confusing than necessary. Many chapters in the book refer back to earlier (large!) examples. Even if you read the book from start to end, it becomes a problem having to remember and understand each of these problems. But the worst effect is that it becomes nearly impossible to use the book as a reference.

One positive point about the book. Unlike most (all?) other books on Haskell it focuses on GHC with all of its extensions instead of restricting itself to the academic Haskell-98 standard. Thank you for that!

EDIT: After having read some parts of the book a second (and third!) time, I have a few more good points to add. Some of the sections on monads are quite well-written actually. I also like that the authors pay attention to good, general programming practices such as "encapsulation". This is essential when writing scalable and realistic programs - no matter what language you use.

I still stand by my initial review. But I feel I was a little to harsh in the rating. So I'd like to give it one more star... but it doesn't seem like Amazon will let me do that. :/

Could have been so much better
I agree with the other readers who say they just got frustrated by the author's inability to illustrate his point through simple, atomic and self explanatory examples. I enjoyed the first few chapters, because the author had not yet built up a critical mass of backward references, but after that I wanted to skip a whole load of stuff that wasn't relevant to me. However skipping ahead to chapters on things like Monads, I find it referring back to previous chapters, which in turn refer back to previous chapters and so on. I tried to read the whole thing linearly, but the examples are too specialised for me to bothered by them. I just can't bring myself to care about bar code reading programs, no matter how much I try - and there is a whole chapter on this!
The book isn't all bad, the early chapters are good, and I some Haskell concepts did `click' for me from reading this book. The author's style when steered away from examples that run into pages is clear and good.
The problem is its combination of being rather long, and that it *really* has to be read in a linear fashion.

You can pick up the language just as well using online tutorials and the user mail list is pretty helpful if you get lost on concepts like Monads. I think there are far better tutorials on Monads on the net now than this book, although I accept there are a whole load more terrible explanations on the net, and you'll need to read 10 bad ones to find 1 good one - bit it is the quickest way to learn the concept.

What Haskell needs is author capable of producing a book like the "Effective C++" series. It assumes fairly basic knowledge of the language (you can pick that up from anywhere). What it does is in very small, autonomous bite-sized chunks, it addresses 1-per-small-chapter points on style and implementation. The examples are kept so very simple (although often interesting) they can be explained sometimes in a paragraph - the code is never more than a few lines, yet the author manages to convey very complex ideas very elegantly.
The trick is to use absolutely numpty higher concepts as examples - strip away *everything* but the problem itself; we'll think of our own complex examples relevant to our own use once we've cracked the framework of the concept.