http://book.realworldhaskell.org/

Real World Haskell, the book that everybody in the Haskell community has 
been talking about for months, is finally entering the final stages of 
production.

This is Haskell's "One Ring to Rule Them All" master tutorial book. It's 
written by the luminaries of the scene, and it's goal is supposedly to 
show you how to "solve real-world problems using Haskell". (Apparently 
many people still think that Haskell is an academian's language that has 
no place in the "real world".)

The full source text of the book is viewable from the link above. I 
haven't read it yet, but I'm curios to see if it really succeeds in its 
ambitious goals. I personally think Haskell is a fantastic language, but 
I'm really not sure it's "ready" for the real world yet. It's still 
rather lacking in libraries and documentation...

If you have a lifetime or two to spare, maybe you could have a read 
though the opening pages and laugh.

Post a reply to this message

Invisible wrote:
> http://book.realworldhaskell.org/

Hmm. The introduction seems to promise things that don't actually work 
for me. Chapter 1 seems nice, but Chapter 2... is... an entire chapter 
on the type system.

Now *I* understand why this is so. But a Haskell newbie? They're 
probably not going to understand. In normal programming languages, a 
"type" is just a name for a particular data structure. You have integer, 
floating point, character, string, boolean, and then various kinds of 
containers and probably something like a Pascal "record". What's the big 
deal?

Of course, Haskell's type system can do amazing things. In Haskell, 
changing a type signature can completely transform the way your program 
works. It can also wildly affect the efficiency of the code. It can help 
you automatically construct a test suite. And so forth. You can even 
*write programs* as type signatures!!

But none of this is obvious to a Haskell newbie. People used to normal 
languages won't understand what all the fuss is about - and will 
probably just skip the whole chapter...

Post a reply to this message

Invisible <voi### [at] devnull> wrote:
> Hmm. The introduction seems to promise things that don't actually work 
> for me. Chapter 1 seems nice, but Chapter 2... is... an entire chapter 
> on the type system.

> Now *I* understand why this is so. But a Haskell newbie? They're 
> probably not going to understand.

  There are basically two ways of writing this type of book, depending on
your target audience: Either make it a tutorial-style self-study book for
people who haven't used that language before, or assume your target
audience mostly consists of computing scientists. In the latter case the
book is more an academic paper than a self-study book.

  Of course you can try to go the mid-ground and try to appeal to both
target audiences at the same time, but that's a very hard genre to pull
out successfully. It's very easy to make the book just a bit too academic
for laymen to understand, and just a bit too mundane to keep the scientists
interested. In other words, it's difficult to raise interest in both target
audiences at the same time, without alienating at least one of them.

-- 
                                                          - Warp

Post a reply to this message

Warp wrote:

>   There are basically two ways of writing this type of book, depending on
> your target audience: Either make it a tutorial-style self-study book for
> people who haven't used that language before, or assume your target
> audience mostly consists of computing scientists. In the latter case the
> book is more an academic paper than a self-study book.

Agreed.

However, the title "Real World Haskell" seems to suggest that the target 
audience is supposed to be the first group, not the second group.

Post a reply to this message

Warp wrote:
>   Of course you can try to go the mid-ground and try to appeal to both

It's not just computer scientists that do this either. Both Wolfram's 
tome and http://en.wikipedia.org/wiki/Guns,_Germs,_and_Steel are books 
I've read that try to be a doctoral dissertation aimed at the layman and 
missing both audiences.

-- 
Darren New / San Diego, CA, USA (PST)

Post a reply to this message

IMO, one of the hardest things about teaching Haskell is figuring out 
which order to explain things in. The "things" are all very simple, but 
each "thing" is related to half a dozen other "things" in such a way 
that it's very awkward to figure out exactly where to start.

Chapter 1 began well, but Chapter 2 seems to be getting a bit lost. They 
give an example of how to use if/then/else, but it's a recursive 
example, so then they start on this tangent explaining about recursion, 
but in the middle they throw in strict vs lazy evaluation orders and 
start talking about thunks... woah, woah! Slow down there! One concept 
at a time, people. o_O

Post a reply to this message

Invisible <voi### [at] devnull> wrote:
> However, the title "Real World Haskell" seems to suggest that the target 
> audience is supposed to be the first group, not the second group.

  Academic people are real-world people who make real-word applications
too, you know... :P

-- 
                                                          - Warp

Post a reply to this message

Warp escreveu:
> Invisible <voi### [at] devnull> wrote:
>> However, the title "Real World Haskell" seems to suggest that the target 
>> audience is supposed to be the first group, not the second group.
> 
>   Academic people are real-world people who make real-word applications
> too, you know... :P

Yeah, and they have feelings, you insensitive clod! :P

Post a reply to this message

Invisible escreveu:
> Chapter 1 began well, but Chapter 2 seems to be getting a bit lost. They 
> give an example of how to use if/then/else, but it's a recursive 
> example, so then they start on this tangent explaining about recursion, 
> but in the middle they throw in strict vs lazy evaluation orders and 
> start talking about thunks... woah, woah! Slow down there! One concept 
> at a time, people. o_O

Whoa, seem things didn't improve since "A gentle introduction to 
Haskell".  Someone said:  "gentle as a heavy metal concert"... :D

OTOH, how can you possibly tell people about benefits of a functional 
language without mentioning recursion and tail-recursion?  How to tell 
what's so great about Haskell's type system without showing what it's 
all about?

They could just give short code examples of how to achieve practical 
stuff, but how would they explaing the code without some theoretical 
background about such issues and differences to imperative programming 
with outdated type systems?

It's not easy at all to try and write such book...

Post a reply to this message

nemesis wrote:

> Whoa, seem things didn't improve since "A gentle introduction to 
> Haskell".  Someone said:  "gentle as a heavy metal concert"... :D

http://arcanux.org/lambdacats/gentle-intro.jpg

> OTOH, how can you possibly tell people about benefits of a functional 
> language without mentioning recursion and tail-recursion?  How to tell 
> what's so great about Haskell's type system without showing what it's 
> all about?
> 
> They could just give short code examples of how to achieve practical 
> stuff, but how would they explaing the code without some theoretical 
> background about such issues and differences to imperative programming 
> with outdated type systems?
> 
> It's not easy at all to try and write such book...

Indeed. I've sat down to write a tutorial myself several times. It 
always seems to degenerate into "oh, wait, I can't use that as an 
example because it requires this *other* feature that I didn't meantion 
yet..."

As I say, Haskell's features are pretty simple, but there's about half a 
dozen of them, and they're all inter-related. It makes it really 
difficult to figure out where to start.

I don't know if you read it, but I really did think Chapter 1 started 
rather well. It's just that Chapter 2 seemed to skip randomly from topic 
to topic in an incoherant way.

-- 
http://blog.orphi.me.uk/
http://www.zazzle.com/MathematicalOrchid*

Post a reply to this message