Menu
Haskell is concise, safe and faster to use, whereas Scala is also concise, fast and safer with many libraries support. Haskell has first-class functions and pure, whereas Scala is strict and impure to use in terms of functional programming features.
Scala is faster than Clojure. The microservice development is efficient.
In principle, Clojure can be just as fast as Java: both are compiled to Java bytecode instructions, which are executed by a Java Virtual Machine ... Clojure code will generally run slower than equiva- lent Java code. However, with some minor adjustments, Clojure performance can usually be brought near Java performance.
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.
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.
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.
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.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With