
Why Haskell is beyond ready for Prime Time - raju
http://intoverflow.wordpress.com/2009/01/13/why-haskell-is-beyond-ready-for-prime-time/
======
thomasmallen
Advanced languages like Haskell will never reach Prime Time in the sense of
the term because they're too challenging. Similar to the "Python Paradox,"
except that Python's easy to learn. There's a strange appeal (that we all
still can relate to) that's led people to prefer simple junk like ColdFusion
to better-designed, more useful languages over the years.

~~~
jimbokun
Object orientation eventually "won" in the market. Unfortunately, it was
adopted by the general programming public in the form of Java, not Smalltalk.

It seems like functional programming is similarly "winning" as an idea. Anyone
who thinks about programming much agrees that a language where you can't pass
a function as a value, or construct functions at runtime, is pretty broken.

The question then, is whether Haskell is the new Smalltalk of functional
programming, and what language will play the role of the functional
programming Java.

~~~
11ren
I think part of Lisp's success was that academics liked it, so when they did
clever stuff, it was related to Lisp. Today, it seems that academics like
Haskell (is it true?), and so when they think of clever stuff, it will be
related to Haskell.

The "Java of FP" could be C# or F# (although Microsoft isn't willing to go
multi-platform, so that might stop it becoming "successful", by many
definitions).

But honestly, I don't think there is a powerful enough vector available to
carry FP. C had Unix. Java had the net. A novel way to think about the next
"Java of FP" is to think of what vector could matter, and then what FP
language is well-placed to be carried by it.

Mobile phones are all I can think of at the moment, but no FP has come of it;
the netbooks (which are becoming phones) are plain ol' PCs; and the iPhone
runs Objective-C (doesn't it?). What's the next IT revolution?

Actually, time_management is right: the next IT revolution is clearly multi-
core.

 _EDIT_ : I keep hearing about Intel's CUDA for multicore on GPU's, but it's
pretty much the anti-FP, being "recursion free"
<http://en.wikipedia.org/wiki/CUDA#Limitations>

~~~
ionfish
There's a project called GpuGen intended to allow the compilation of Haskell
code to CUDA.

[http://www.galois.com/blog/2008/08/29/gpugen-bringing-the-
po...](http://www.galois.com/blog/2008/08/29/gpugen-bringing-the-power-of-
gpus-into-the-haskell-world/)

There's also something similar called Obsidian:

<http://lambda-the-ultimate.org/node/3016>

~~~
ionfish
And if you'd prefer to read the original papers, rather than presentation
slides...

<http://www.cse.unsw.edu.au/~chak/papers/gpugen.pdf>

[http://www.cse.chalmers.se/~joels/writing/dccpaper_obsidian....](http://www.cse.chalmers.se/~joels/writing/dccpaper_obsidian.pdf)

------
brl
Rather than writing blog articles touting how great your favorite language is
for general purpose programming you should write some code.

When you have more non-trivial applications written in Haskell than a Haskell
compiler and a DVCS it will be a lot more credible to talk about it being
ready for 'Prime Time'.

~~~
eelco
I'll give the same reply as was given in the comment thread of the article,
which you apparently didn't read.

<http://hackage.haskell.org/packages/archive/pkg-list.html>

~~~
brl
Hasn't changed since I last looked at it. Still a big clusterfuck of esoteric
math libraries, wrappers for useful things written in other (practical)
languages, and a handful of half finished clones of libraries and applications
first written 10 or 20 years ago in C.

~~~
wernerv0nbraun
about a package a day is being added to hackage, so my guess is that you are
just spewing uninformed bullshit.

you don't know anything about haskell, hackage, or anything related. stop
commenting until you do.

------
sctb
The author is asserting that Haskell, the language and the tools, is ready for
`Prime Time'. There is also a sustainable community of smart and enthusiastic
Haskell hackers.

The developer mainstream may not be quite ready for Haskell, but Haskell is
ready for them.

EDIT: Meant to be in reply to thomasmallen: "Advanced language like
Haskell..."

~~~
stcredzero
Is the developer mainstream any better than it used to be?

~~~
bpyne
I think it is or will be soon enough. The internet made communication between
geographically disparate developers so much easier. It's become mature enough
that there are sites now where curious developers can congregate and exchange
ideas.

When I started in the field the internet wasn't on the radar of businesses.
Email accounts were uncommon never mind blog sites. Most book stores didn't
carry books on academic topics. Besides, the wave of OO was just starting to
gather so 9 out of 10 books were on OO or C++ or both.

Developers are now exposed to more and can share code and techniques. More
complex problems are shared now causing curious developers to stretch their
limits.

The largest problem I see now with adoption of Haskell is the us/them
mentality of field trained developers vs. academically trained ones. I'm in
the former group. While not all academically trained developers code/design
well, the median one has been exposed to a wider range of coding problems and
tools. Our ability to share ideas and problems on the internet levels that
playing field if we let it.

In short, yes, mainstream developers are ready for Haskell/Lisp/OCaml/etc. We
need to get over the "that's just for academics" mentality. They are tools,
thought out by people with lots of brains and time on their hands, to solve
problems. The only thing holding us back is our mentality.

------
smanek
Being able to search for functions/libraries by type signatures is very, very
useful.

~~~
silentbicycle
Though thinking about functions/libraries in terms of their type signatures
is, in itself, a pretty new concept to a lot of people.

~~~
time_management
I remember, about a week into my exposure to Ocaml, asking what a functor was.
"It's a function from a module to a module."

My response was along the lines of, _What?_ It turns out, though, that Ocaml
functors are really cool and can provide some of the functionality of
Haskell's type classes.

