After a decade+ in Java, my conclusion is that Java cannot capture repetition in many common real use cases. The addition of lambdas in jdk 8 will expand the scope of what can be captured but will still not cover control flow use cases.
Even when you can actually capture the abstraction (many common "design patterns" are examples of this), you will find that doing so increases the overall size of the code (you must create new interfaces, factories, etc etc). The downside is that making more general, higher abstraction systems are by definition more complicated in Java.
I want to build large maintainable systems and the ability to create powerful abstractions that simplify my code is essential. I have moved to Clojure which so far has delivered on these needs. I don't know as much Scala but my impression is that it also satisfies these goals. At the very least, I'd say that both Clojure and Scala consider this kind of thing to be in scope as a goal.
It's easy to make a language that is more concise than Java. I think it's harder to satisfy the goals I specified above (which are only indirectly related to conciseness).
I haven't studied Ceylon enough to tell whether it makes progress towards building better abstractions.
For me it's look like groovy, more a syntax cleanup than a new language.
And as far as I know Scala, it enable to create 'better' abstraction like you are doing in Clojure (great language too from what I used).
Its funny to me how people often say after 5/10/whatever years of java I conclude that its limitations are [insert your limitations]
Why the hell did it take you 10 years? If you work with a language for a year MAX and you can still not creat good abstractions. Why do you stick to it?
The guy that made Ceylon said something like that too.
(Sure your job could be java, but I think most people here do programming in there freetime as well. Why did you not move to CL, Haskell, ML, python or something. If more people would have done that these languages would be a lot better of now)
Alot of wat you get from clojure you could of gotten from CL 10 years ago. Why didn't more people think of this that way?
At least we can agree on the point that clojure is awesome and that we are really happy to have scala and clojure today.
I spent many years building some pretty good production software in Java and it certainly paid my mortgage and let me grow in important ways. I did tinker in the background with Ruby, Erlang, Python, Groovy, etc etc and tried to bring them in as testing tools or whatever when I could. There are still many things I like about Java and working in Java obviously makes your work available to a vast number of programmers.
I feel incredibly lucky that Clojure (and Scala and ...) are possible choices now and that I've managed to get to an experience level where I can make the judgement to recommend it and have an employer listen to me.
I do apologize for not personally making the majority of the industry use Common Lisp 10 years ago. My bad.
Some people use Java in spite of the language: they just like the vast libraries.