CODEWITHSUNDEEP
programming-languagesscalahaskellclojure
i_like_monkeys
i_like_monkeys

Reputation: 247

What factors could determine whether Clojure, Scala or Haskell will gain traction?

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?

Upvotes: 32

Views: 9407

Answers (9)

Don Stewart
Don Stewart

Reputation: 137987

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.

Upvotes: 17

VonC
VonC

Reputation: 1327264

On the top of my head:

  • good IDE support (with refactoring)
  • stable enough specifications
  • clear policy about backward compatibility (in term of sources, binaries and behavior)
  • frameworks and tools around the language (like code static analysis, code coverage, ...)

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

Upvotes: 20

Thora
Thora

Reputation: 1

Haskell or Ruby will sweep evryone in the world. Chances are more for Ruby to be successful since Haskell is complex and difficult to learn.

Ruby 2.x will become father of 'Scala and Clojure'. It will have new version with high speed, GIL removed and built-in modules for Parallel processing, functional programing, macros.

Thinking further, more libraries are to be built in ruby for various tasks. This will be done once the version 2.X will come with all the above mentioned feechurs.

I believe Matz and Antonio !!!!!

C++, Java, .NET, Python, Scala will be seen in musuems. XXXXX
C, Perl and PHP will still live for small apps/tasks.
MySQL, Oracle, SQLServer will also be seen in 'db section' of museum. XXXXX
SQlite, PostgreSQL will be still alive outside.

Cheers,
Ur man

Upvotes: -4

Pedro Rolo
Pedro Rolo

Reputation: 29970

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.

Upvotes: 0

Matt R
Matt R

Reputation: 10523

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.

Upvotes: 2

stonemetal
stonemetal

Reputation: 6208

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.

Upvotes: 2

sastanin
sastanin

Reputation: 41541

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.

Upvotes: 3

oxbow_lakes
oxbow_lakes

Reputation: 134310

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.

Upvotes: 10

DigitalRoss
DigitalRoss

Reputation: 146141

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.

Upvotes: 3

Related Questions