For the past year, the Java ecosystem has seen interesting evolution. Java the language continues take its place as the new safety scissors of programming, but the pieces around it are getting better. The JVM is now acknowledged inside and outside of the Java community as really good stuff. Really interesting software like Hadoop and Cassandra are built on top of Java. Integration with languages like Ruby and Python is getting pretty good.
What’s most interesting to me is that there’s a competition going on for the hearts and minds of those developers who don’t like using safety scissors. This competition is a great experiment into what developers really want in a programming language. For a language nerd such as myself, observing this experiment is a lot of fun.
On one side you’ve got Scala. Scala looks a lot like Java. But on top of that it adds shorthands and pleasantries from Ruby, a really good type system reminiscent of Haskell, and other handy functional features. When you build up a hybrid language like this you, two things happen. First, a lot of people who look at their checklist, find everything they need and decide. Second, you get a pretty complex language.
Clojure, however, looks nothing like Java. It’s a Lisp, it simply can’t. Clojure borrows from Haskell too, this time borrowing ideas about state and how to avoid it and concurrency (notably software transactional memory). Clojure is a funny looking language at first, but there are some great ideas within it. Plus, it’s a relatively small language; it’s just that it’s a different kind of simple and almost every concept is new to many developers.
Both these languages are building up strong communities. Both are full of great people with energy and ideas. It’s quite possible that a winner-take-all situation won’t occur. I’d like that.
What’s most interesting to me is to see how people take to the languages. Will they go for the familiarity of Scala and deal with the complexity? Will they learn the simplicities of Clojure and rewire their brains? Will they prove the common wisdom wrong and learn both?
I’m watching with great interest.
Adam Keys is typing 
I’m curious why you consider Clojure to be a simple language. Every presentation I’ve seen on it has spent dozens of slides talking about the crazy huge assortment of language features based on a large number of fundamental concepts. Compared to Smalltalk, Clojure seems to be gigantic. Smalltalk has about 6 fundamental things in the language, and that’s it objects, messages, methods, classes, blocks, variables (local, instance, class, global). Scheme is even simpler, and so is SELF. Can you distill Clojure down to just a half dozen concepts?
By the way, I wouldn’t consider any system that is based on generic functions and multi-methods to be simple. It’s often ridiculously hard to predict what method will execute in those kinds of systems when things get large. Have you had experience to the contrary?
In my mind, Clojure has three main concepts: functions, sequences, and concurrency. Smalltalk has two: objects and methods. So on the surface, I’d admit that Smalltalk has significantly less complex. ;) In contrast, I haven’t wrapped my head around Scala enough to say what the main concepts really are.
My experience with all of these languages is as an interested bystander. I’ve not had the occasion to use any of them in anger, but I’ve read a bit about all of them and the works in anger of others.
I don’t think there will be a “winner take all” in this ergosphere. One of the most interesting things about all the JVM-targetting languages is that they can share linkage, transparently. So objects and libraries can be written in Java, Clojure, and Scala, and inter-operate without additional pain (over and above the pain of being in the JVM in the first place).
Agreed, in which case the interesting question becomes, what sorts of people are attracted to what sorts of languages? It might end up being something like Python and Ruby, where the languages are roughly comparable but the cultures are vastly different.