http://cdsmith.wordpress.com/2007/07/29/37-reasons-to-love-haskell-playing-off-the-ruby-article/

You don't really need to even click that, do you?

Well, maybe you do... Basically there's a "37 reasons to love Ruby" 
article, so this guy did a copy for Haskell. While I applaud this, some 
of the "facts" are rather dubious...

#3. "It's dynamic. Lots of Haskell applications feature dynamic code 
loading." Er, yeah... if you have the damned compiler installed! What 
you *can't* do is compile a module and then dynamically link it in 
later. You *must* have the actual compiler available. And it's _very_ 
hackish and awkward to get it to work. It's not a compiler feature, it's 
a low-level C library that somebody hacked together which sort-of works. 
It's a nightmare to use it though!

#6. "It's multi-platform." Yeah, but unfortunately the Windows version 
is running under Cygwin using the GNU toolchain (e.g., GCC, GAS, LD), 
and almost all libraries involving binding to a C library spectacularly 
fail to compile on Windows. All the APIs are fairly POSIX-centric so you 
generally can't access Windows-specific functionallity. And so forth.

#8. "It's innovative." Well, perhaps. I love the way he cites a whole 
bunch of features and "these are rare in other languages". Er, but *all* 
the features you cited are features of the type checker! :-P (Why not 
mention, say, concurrency and parallelism?)

#10. "It has a smart GC." Er... looks pretty primitive compared to 
Smalltalk, actually.

#11. "It's a scripting language." You have *got* to be kidding me! Sure, 
many things in Haskell are one-liners. But typically anything that 
involves talking to the outside world has lots of small but fiddly 
details that take heaps of code to sort out. Hardly a nimble scripting 
language!

#15. "It's intuitive." Hahahaha... nice! (The argument does kinda make 
sense - the learning curve is steep because you really do have to learn 
new stuff, not just new syntax for doing the same old thing. And the 
Haskell syntax is as intuitive as it can be considering that. But 
still... stretching it a little, eh?)

#16. "It handles exceptions well." You... have... GOT to be kidding me! 
If you try to read a non-existent directory, there is *no way* to 
distinguish from a "this filename is invalid" error and a "this file 
doesn't exist" error and a "there was a hardware error" error. (You 
*can* at least distinguish "access denied".) Asynchronus errors are a 
nightmare with lazy evaluation too!

#17. "It has advanced array types." Ha...haha...hahahaha! You've got to 
be kidding me! The API is *horrid*! There is mile after mile of 
functionallity missing. And there are all kinds of inconsistencies in 
function names, etc.

#25. "It pays attention to details." I can't even determine what the 
hell he's talking about here...

#27. "It has a rich set of libraries." Oh come *on*!! You cannot be 
serious! That ball was on the line! Er, I mean... Haskell lacks 
libraries for just above every possible task you can name! Want to read 
a GIF file? Sorry, can't do that. Want to send a PGP-encrypted email? 
Sorry, no SMTP support, no PGP support. Want to compute a CRC32 
checksum? Sorry, no library for that. Want to play an AVI animation? 
Guess what? No library.

But best of all: What libraries do exist do *not* work on Windows. Ever. 
There are 12 database libraries, and none of them compile on Windows. 
There's a wxWidgets library - doesn't run on Windows (in spite of the 
special Windows-specific setup routine). There's a libSDL library... can 
you guess? Doesn't work on Windows.

Haskell - Great language, just don't try to communicate with anything.

#28. "It has a debugger." Finally. It took long enough. And it's a **** 
to use.



Overall though, I still thing Haskell is a great language. But then we 
have this:

http://intoverflow.wordpress.com/2009/01/13/why-haskell-is-beyond-ready-for-prime-time/

Reading this, you'd think Haskell has the most awsome tools EVER! Sadly, 
it's not true...

"Availability of quality libraries"

Only on Linux. And even then with huge gaps. And the overwhelming 
majority of libraries were once somebody's one-man project, and lay 
long-forgetted. And most of them utterly lack any documentation at all. 
Oh, and Hackage is really quite clunky to use.

"Project Management"

Setting Haddoc up in such a way that it works properly is seriously 
hard. (OTOH, it now comes with the compiler, which should radically 
improve this!)

GHC is "the most advanced compiler anywhere", is it? Sure, I'm 
enthusiastic about it, but this seems over the top to me.

(E.g., you can't compile different parts of the same program with 
different versions of the compiler. Therefore *all* libraries must be 
shipped in source-code form because the compiled versions only work with 
one release of the compiler. Not so "advanced" now, eh?)

"Technology"

"[Haskell] stands alone in its simultaneous support for many language 

another 10 years."


better support for concurrency than any other language[...]"

Wow, calm down there partner! Let's not get carried away here. Haskell 
is an impressive language, but I'm sure somewhere there's something that 
beats it in functionallity terms.

"To get a sense for how wildly amazing Haskell-related technology, check 




Except that it doesn't work. Nice try though...

"Community"

"Lastly we come to one of the most special features that Haskell offers: 
its unique developer community."

I really can't comprehend where this myth that Haskell has a great 
community keeps comming from. It isn't true!

If you ask an easy question, you will get 200 replies before you can hit 
the send/receive button. If you ask a hard question, or a less 
interesting one, you get silence. And if you *dare* to suggest that 
calling something an epimorphism is a bad idea, you'll get flamed off 
the planet!

Sure, generally the people are quite friendly. This is hardly unique to 
Haskell though. The POV-Ray community has always been quite friendly, 
but you don't find them calling themselves "unique".



very special. Every day there are new developments in the community that 
push the boundaries of technology, enabling people to write 
sophisticated programs in less time and with greater reliability. There 

have somehow been gifted to us today."

Again, I don't think Haskell has ever done anything that can be called 
truly "ground-breaking". If anybody knows different, let me know...

- We didn't invent pure-functional proramming with lazy evaluation and 
automatic type inference. (Indeed, Haskell was designed because there 
were already *too many* such languages, and they wanted to replace them 
all with just one.)

- We didn't invent curried functions, high-order functions, maps and 
folds, and all the other high-tech stuff that abounds in Haskell. This 
stuff appears in any half-decent functional language. (E.g., I imagine 
Lisp probably did it years before us.)

- We didn't invent algebraic datatypes. Those existed for decades before 
us. (Although they're fairly rare in real programming languages.)

- We didn't invent type classes. It's an unusual feature, but it was 
around long before Haskell.

- We didn't invent monads either. We borrowed them from category theory.

- We certainly didn't invent parallelism annotations. (As I understand 
it, even languages as backward and retarded as C have those now.)

- We didn't invent Software Transactional Memory either. That was an 
idea that researchers thought was cool, and it eventually got borrowed 
by Haskell.

- We didn't invent Nested Data Parallelism - that's another exciting 
research project somebody else did years ago that recently got 
integrated into Haskell.

Indeed, I'm having trouble finding anything that Haskell itself actually 
created or perfected. Arguably we have the best G-machine 
implementation, but all that means is we have a compiler that produces 
fast code. It's not a language feature.


Even more amusing are some of the comments:

- There's no IDE for Haskell, but "I don't think an IDE is really 
necessary". Well *sure* you don't. Because you haven't got one yet! :-P

- Some guy rightly complained that you can't [easily] define two 
datatypes which have fields with the same name. This is obviously a 
pretty silly limitation. I love the reply "but that's good though". Uh, 
yeah, lotta logic there.

- Most significantly: "Haskell will be 'ready' for 'the real world' when 
we start seeing real, large-scale applications written with it. Until 
then, nobody is going to care." I think this just about sums it up, 
really...

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

Post a reply to this message