Given that it's impossible to see into the future, what factors related to Clojure, Scala or Haskell are likely to determine whether one of them catches on?
Are there cultural or economic issues that could give one of these languages an advantage over the others?
Or are none of these languages likely to gain traction because of their conceptual complexity?
On the top of my head:
Scala, for instance, is still evolving and moving "too fast" to be "largely" used even though some big projects have already adopted it.
Edit: November 2009
See Refactoring to Scala DSLs and LiftOff 2009 Recap presentation, Slide 10 and 11:
Martin definitively "gets it" about the importance of having high quality Scala tool support
From the Haskell world, I see the main things to continue to push on as:
Besides this, it is hard to say. Some random thoughts: Haskell's been around for 20 years, has a very large user base, and plenty of commercial support. Clojure is tiny in comparison. Scala and Clojure get "free points" by running on .NET or JVM. Does that matter? How much does the runtime matter? GHC has a very fast custom parallel runtime, because it isn't the JVM, but people like to use the JVM. Same for .NET. Does maturity/stability matter?
And on top of all of this, who is doing the best outreach?
Oh, and we have The Industrial Haskell Group.
OK, I'll take a wild guess. I think the factor needed for success is "can it do Java's job?".
The real thing that Java does is static typing. While this is annoying for small programs it allows the construction of large stable systems. It allows refactoring with confidence.
Think about it: every language has kind of a maximum size program that it supports. To go over that size requires increasingly above-average design and implementation.
As a secondary consideration, Java is quite fast and has a rather complete library.
So, I'm guessing those are the criteria, and so Scala has a chance.
The only negative is the difficulty of running cheap shared server web hosts with the JVM.
I think that to break into the big league (i.e. C, C#, C++, Java) they need widespread acceptance from a few large companies which do in-house development but are not themselves software houses. I'm think of large banks, insurance companies, service-companies, management consultancies etc.
However, there is a big barrier to this acceptance these days; namely support, market and stability. Without a large company like Sun, IBM or Microsoft providing support it's going to be very difficult to persuade companies like these that any new language is a safe bet.
Without persuading these companies, the market for developers familiar with the languages will be small. As long as there is a small base of users, the language can afford to make backwards-incompatible changes requested by the community. Hence a vicious cycle of non-mainstream-adoption.
Some of these languages may easily gain acceptance first in non-commercial and open source environment. More or less what happened to Perl, Python, Ruby (and some other languages).
Ease of deployment of the software (think apt-get) and freedom of the programmer promotes language diversity in the open source world. Once some of the software becomes sufficiently important, the language becomes immortal in terms of support. Once its immortal, it is a safe bet for everyone. Small developers will be first, and if they gain some advantages from using the language, big companies will follow.
So, it's a matter of which community is more friendly to open source (teaching, documentation, infrastructure) and which language allows a programmer to be more productive.
Backing by a large software development company. Look at what it took Java and C# to get where they are. That is what it will take for others to get there as well.
One cultural factor is how similar a language is to existing popular languages. For example, the evolution of C -> C++ -> Java -> C#.
Haskell has the largest gap from the mainstream, with an unfamiliar syntax, runtime stack, programming paradigm and a community oriented much more towards academia than industry.
In my humble opinion, the main factor regards the outcome of the research aiming at providing implicit parallelism in purely functional languages. If/when this will work, then Haskell is likely to become the mainstream.
As for Scala and Clojure... Scala has the historically more acceptable syntax. That's an overkill. Some can argue that Clojure has a macro system, but macros are expressively equivalent to clojures, so this is not a real advantage.
Anyway, I believe that statically-typed languages are not appropriate for all the areas, namely Web Development. And curiously nowadays there's a tendency to make everything web-based. I do not think that Ruby was a hype: It is maturing very fast.