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

I just skimmed it, and it seems very comprehesive.
It doesn't address monads until the half-way point,
and then doesn't dwell on it long, and it has lots of
concrete examples of how to use some of the more
important libraries.

Post a reply to this message

Orchid XP v8 wrote:
> 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..."

	Recursive tutorial for a recursive language...?


-- 
All hope abandon, ye who enter messages here.


                    /\  /\               /\  /
                   /  \/  \ u e e n     /  \/  a w a z
                       >>>>>>mue### [at] nawazorg<<<<<<
                                   anl

Post a reply to this message

Mueen Nawaz wrote:

> 	Recursive tutorial for a recursive language...?

LOL! I like it...

Post a reply to this message

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

This book gets stranger and stranger.

It explains how to work the compiler in the middle of a lesson on 
writing a simple library. It goes through a lengthy explanation of how 
to manually invoke all the compilation states, rather than using the 
trivially easy automated compilation system. And it generally seems to 
be introducing concepts here, there and everywhere in no coherant order.

Most puzzling. I was hoping for better than this...

[I'm still hoping the chapters on "practical stuff" might actually tell 
me something I don't already know - like, for example, how to make 
useful libraries actually compile on Windoze...]

Post a reply to this message

Invisible wrote:

> This book gets stranger and stranger.
> 
> It explains how to work the compiler in the middle of a lesson on 
> writing a simple library. It goes through a lengthy explanation of how 
> to manually invoke all the compilation states, rather than using the 
> trivially easy automated compilation system. And it generally seems to 
> be introducing concepts here, there and everywhere in no coherant order.

Impressive. It spends a whole chapter showing you how to develop a 
library, how to compile it the hard way, and how to construct a Cabal 
package from it - but it *doesn't* mention how to upload this package 
onto Hackage, the central Haskell online package database. What's some 
omission, eh? (I mean, *why* would you bother to package something for 
distribution other than to distribute it??)

It also fails to mention the easy compilation method anywhere. Genius.

Post a reply to this message