>> And, as I keep pointing out, that isn't what I said. I said the core
>> language design is simple and clean.
>
> The thing is that this is NOT what you said (or rather, what you
> implied). Your claim was (or appeared to be) that Haskell is simple and
> elegant AND a "solution for everything".
>
> We keep disputing the latter, while you keep insisting on the former
> (which we're not disputing in any way).

It seems the confusion here is "solution for everything".

It seems you guys think that I meant "every possible computing task that 
can ever exist". Obviously Haskell does /not/ solve every such problem. 
Indeed, it doesn't solve /most/ of them, due to the much-discussed 
extreme lack of libraries. Want to load a JPEG image? Good luck with 
that. I could come up with dozens of other examples off the top of my head.

What I meant was to contrast Haskell against C# and languages like it. 
With most mainstream languages, somebody will be writing a program, and 
find that some facet of it is really awkward to structure. Basically, 
the language doesn't solve that well. So they invent yet another new 
feature to solve that problem - or rather, to solve one particular 
instance of it. And then later somebody else invents another, in 
compatible, new feature to solve a slightly different instance of it. 
And so, after a few decades, we have a feature-encrusted language which 
/still/ doesn't solve all the problems.

The "problems" that I was discussing are not "can I interact with legacy 
systems?" or "have I got good multimedia support?" or "does my toolchain 
support distributed processing well?" Rather, I was talking about 
problems such as "can I express the core application logic in a robust, 
maintainable, bug-free way?"

Object-oriented programming was supposed to make everything polymorphic 
and wonderful. But then they discovered the container problem, so they 
invented generics. And then they figured out that sometimes, you want 
multiple inheritance. So they invented multiple inheritance, and decided 
to not use it and have "interfaces" instead, for no really defined 
reason. And then they decided that having eight-billion interfaces like 
"Runnable", "ScrollEventListener", "DragEventListener", 
"CheckBoxEventListener" and so on was just stupid. So Eiffel invented 
"agents", C# invented "delegates", and Java offered the "reflection 
API"; all of them different attempts to solve the same language design 
problem.

This is the kind of stuff I'm talking about. All these different 
languages, all with lots and lots of "features" for trying to solve 
stuff. And then there's Haskell, which consists of just 6 constructs in 
the entire language, and solves all of it.

[OK, I take that back: Records with named fields is a joke in Haskell. 
But the language solves everything /else/ pretty damned well.]

Post a reply to this message