Thursday 22 July 2010

The Next Big JVM Language talk JavaOne

I'm talking at JavaOne 2010 on the subject of the "Next Big JVM language" (S314355). I suspect that it might cause some controversey!


Before writing the talk, I wanted to get some feedback from the community. So, I've got some basic topics and questions I'm looking for feedback on.

1) What makes a language big and popular?
Lots of people have drawn up lists - Steve Yegge has one (take a look!). But what criteria do you believe make a language big and popular? Static or dynamic? Fast or just fast enough? Lots of features or few? Simple or complex? Does syntax matter? etc. etc.

2) What might be different between a big JVM language and a big language in general (without the JVM restriction)?
Dot NET has several new languages, but they can't be considered. However, if you've seen an interesting idea then thats interesting here.

3) Is it important to reuse existing Java libraries?
Java has a big ecosystem. How important is reusing all those libraries. Or would a fresh start with a new higher quality (less cruft) core library be preferred.

4) What languages should I consider?
I've got Groovy, Scala, Fantom and Clojure on the list, but what else? I'd love to see blog posts by language authors tackling the question of why their language matches the session title.

5) If its none of the above, why not? What are you looking for?
While a random wish list of features is interesting, remember that this is about the next big JVM language. Does your idea fit that?

6) Can Java reinvent itself?
What about java itself - could a reinvigorated Java retain its crown.


Feedback is definitely wanted, by comment, email or new blog posts. Its a broad topic, but the more feedback the better (or more controversial) the talk will be! (And I'll be starting writing this weekend...)


  1. 4) probably, you could include JRuby

  2. Gareth Johnson22 July 2010 at 13:25

    My favourite by far is Fantom.

    I love its practicality and common sense
    approach to software development.

    I really like the middle of the road approach
    it takes to dynamic and static typing.

  3. I think any next-gen JVM language needs to offer at least the following:
    - No attempt whatsoever at backwards language compatibility.
    This gives the chance to fix some of the things that would be Really Hard to Do with the state of Java:
    - Properties
    - Real Generics (ooh, and if I can have partial specialization I'm a happy man indeed)
    - Some form of closures
    - Better switches (strings, enums, etc.)
    - Better null handling, particularly around primitives
    - Partial classes

    But I think we should keep what's very much NOT broken with Java:
    - C-style syntax that doesn't look like line noise
    - Type-per-file
    - Easy access to runtime metadata
    - Consistency of style (a .java file is, in general, understandable in situ, without having to understand the whole compilation ecosystem)

    I'd be fine with breaking backwards compatibility with most of Java-the-libraries, as long as there was some reasonably well-defined way that you could wrap java-the-libraries for interchange. Give a few key primitives and you could wrap what we want (JDBC, JMS) and not what we don't (horribly broken generics collections, j.u.Logging, j.u.Date).

    Clojure: Too Lispy. Lispy languages will never appeal to most journeyman programmers.
    Scala: Language Kitchensinkitis. Too much of what seems to pass for good/clever Scala is so DSLed up that it looks like line noise. If I wanted to program APL I'd do so.

  4. I do think it's time to draw a line in the sand. We've learned so much over the last 15 years where Sun's adherence to binary compatibility kept Java from befitting (mangled generics, pseudo-properties & events, complex type-system etc.).

    Fantom appears to be the cleanest, simplest and most pragmatic way to go. If Scala appeals to the top 20% of developers, then surely Fantom appeals to the remaining 80%. That ought to tell a story right there. Fantom is, however, less cool and gets less press than deserved.

  5. No need ask this to anyone. Scala already win the race. Only a static lang can replace java and it can use all existing java libs, this is a must. Only scala can be compared with the c# (the most advanced language that has use in industry).

    And also check the how many question does scala got and others.

  6. I would love Groovy++ to be considered. A lot of information is available at and at project page

  7. Not a jvm language, but I think google's go language has the potential to become big because it's simple and poweful. I'd love to see similar on the jvm..

    Also, Scala 2.8 std library looks much better than previous releases.. however, I feel it has too many 'features' and Scala code is far from as readable as Java - at least until Java7 with type annotations :-(

  8. You mentioned .NET, why not a port of C#'s syntax:

    Seems to nicely solve all of Java's syntactic warts. Put an Eclipse IDE on top of it and I think you're good to go.

    Scala is awesome, but its new type system and new library, while both great, also bring in some extra complexity. Specifically integration works great for Scala-using-Java but not so well for Java-using-Scala, which can get ugly. You have to start doing implicits by hand, using the "foo_=" methods, etc.

  9. @birdost Shouldn't the fact that it has a lot of questions asked about it on stackoverflow be irrelevant? At best it shows that the language is too complex and at worst it shows that the development world is in a pretty poor state of knowledge.

  10. 1)

    - compelling frameworks specific to the language
    - productivity advantages
    - unique and useful abstractions

    - IDE support is hugely important for JVM languages

    - ability to reuse Java libraries I essential to me

    - I agree that Scala should be considered (even Groovy creator James Strachan thinks Scala is cool)
    - Kresten Krab Thorup's Erjang is interesting, but I doubt it will be a primary JVM language, but more of a utility for particular domains

    - Erjang is compelling because it has Erlang-style first class pure message passing

    - No. Java is good as is and should continue to be part of the ecosystem. New JVM languages should provide the closures, meta-programming and other programming styles. Java itself should not be altered any further.

  11. Brian Schlining23 July 2010 at 01:16

    3) Is it important to reuse existing Java libraries?

    4) What languages should I consider?
    I've used Scala, Groovy, and Clojure. I like Scala, it's pretty slick, but I find that I don't use it much. It's pretty close to Java and I can get Java to do what I need, so I haven't had any real need to use Scala. Also, You have to compile Scala code on the version you intend to deploy it on; that's very annoying. Groovy on the other hand, has been immensely useful. It's a great adjunct to Java. It's great for prototyping and scripting Java classes together.

    6) Can Java reinvent itself?
    Certainly. Real Generics would be nice. Real Properties would be better too. Also, better/easier native code integration than JNI (JNA does help there)

  12. The first question to answer is what's the definition of "big" ?

    Ignoring the JVM for a moment, which (general purpose) programming languages in history were "big" ?
    Which ones are "big" now?

    Here's my rough draft (almost certainly wrong)

    Definitely (are/were) big:
    C, C++, Java, Visual Basic

    Probably (were/are) big:
    Fortran, Cobol, C#

    Maybe (were/are) big (but probably not):
    Perl, Shell, PL1, Smalltalk, Pascal / Delphi, Powerbuilder

    Weren't / aren't (yet?):
    Ada, Forth, Lisp, Python, Ruby, Scala, Objective-C, Lua, APL, (etc)

    Different people will draw the line in different places. You might think smalltalk or lisp were (are) "big", but in that case it's not going to be too hard to find other languages that will hit the same level of popularity.

    But if you're looking to find something that's as big as Java (or C, C++, VB, ...) then we'll be waiting a long time.

    The other way to interpret the question is to accept that no language will overtake Java as the 1st tier JVM language (in the short term), and ask which of the 2nd tier JVM languages will rise to the top of that pack.

    In that case your current choices come down to:
    * Fantom
    * Scala
    * Groovy
    * Clojure
    * JRuby

    And I'm not sure there's much evidence for one of those rising too far above the others. If anyone is going to, it's Scala.
    * Groovy's had long enough and hasn't gotten that far, I can't see it having a rebound now (but then, that's what people said about Ruby 8 years ago)
    * Clojure is Lisp. People don't like lisp (you can argue that they _should_, but the fact is, they don't), so I can't see it being really popular.
    * JRuby is primarily focused on being a damn good Ruby implementation on the JVM, rather than a way to co-exist with Java, so while I can see it being popular, I think it will be popular as a Ruby implementation, not as a Java alternative.
    * Which leaves Fantom and Scala. I think Scala has more mind-share, and more chance of being the "winner".

  13. I think your talk should focus on Groovy. It's a very approachable and powerful language. Much easier to pickup, in my opinion, than Scala. Groovy is what Java should be.

  14. I have dabbled in Groovy, Scala, bit of Jython and JRuby, and finally Clojure. My vote goes for Clojure and here's why:

    I rule out Groovy, Jython and JRuby due to their lack of performance/concurrency-primitives/Java-interop.

    Scala is interesting and solves Java verbosity problem but adds the complexity of type-system. Also, the handling of immutability is not clean. Java-interop leaves a lot to be desired. Perhaps Java 7/8 will adopt things from Scala and then we may not really need Scala.

    Clojure, though vastly different on syntax, is an intellectual leap ahead from the Java cruft. Its handling of immutability, Java-interop, closures, concurrency primitives are state-of-the-art. Macros in Clojure are unheard-of in other languages. No wonder Clojure is seeing such huge growth in usage - look at the graph:,+groovy,+jruby,+clojure

  15. Also, see this:

  16. Fantom

    Scala is to involved for the general developer, it will always be a niece language just because of that.

    Fantom has the right amount of features and it can be compiled to the CLR, JVM and JS.

  17. My votes are for Groovy++ because it is my beat at long term. It is exactly that I would ask for Java 2.0. It will have the posibility to embrace the Java developers with better and similar syntaxis and great support for Domain Specific Languages and all the great features of the Groovy language, at the same time that it has a set of amazing features like "compile time checking of code, as fast as Java performance of compiled code, easy mixing of statically and dynamically typed code, very powerful type inference, tail recursion, traits, extension methods (compile time categories), standard library of utilities for functional programming, concurrency and distributed computing"

  18. I second both Shantanu and Mikael. Groovy++ and Fantom are the competitors, mainly because they don´t try to be too radical. That way they don´t throw away the good stuff from the existing paradigm.

  19. Jonathan Gibbons23 July 2010 at 20:25

    I've always thought it would be interesting to investigate a language that honors the JVM class constructs (e.g. Java syntax for classes, method signatures and fields) but which explores new not-necessarily-compatible syntax within method bodies. The result would provide maximum interoperability with existing code yet release us from the shackles of compatibility within the implementation of classes and methods.

  20. The Next Big language has very little to do with advanced language paradigms, and such, as is documented in the preceding comments in my opinion.

    The NBL will be the language that makes mediocre developers relatively productive, and does so, better than Java.

    There are plenty of languages that are technically better than Java. But that is not what makes a language the next big thing.

    The world is full of below average programmers working at all kinds of companies. If these companies could see a mild improvement in productivity in these folks over what can be had with Java, they will jump at the chance to change.

  21. :) If anyone thinks replicating Java's ecosystem is a good idea, a kind of survey might be needed to assess e.g. number of code lines just of all OSS Java sofware, libraries, tools, etc. actually used by companies. Java might be verbose, but my guess is it would go to trillions. OSS would also probably look tiny compared with proprietary stuff existing.
    Also take all the books, blogs (including this one), tutorials etc. written on Java and things Java related. It is a huge amount of work done over years.
    No reason to leave JVM and Java compatibility.

    For me personally all this recent years' talk about and work on new languages seems only as a protest against Java's slow evolution.

    In a broad picture:
    We had C, it was great, but kind of lame without OO. So we moved to C++. It was great, but not exactly safe and programs written in it were full of bugs. Then came Java, with a real multi platform promise, cool standard apis, greatly enhanced safety was almost the same as our beloved C++.
    C#/.Net? May be a better 'Java', thanks to their often backward incompatible redesigns. But we all know how MS is and their ways have less power over software world as time goes.

    Maybe a real progress will be when the new Java owner decides to, for the first time, release a bit backward incompatible version of Java with some of the 'Java Puzzlers' book content fixed. (And decreased verbosity maybe?) The kind of incompatibility that would be possible to adapt existing stuff to without committing enormous resources.

    Java is already relatively old. But do we have a big reason to move somewhere else as we had in the past? I do not think so.

    The rest is just lazy Java students complaining in my opinion :)

  22. To answer 1 to 3:
    To me, BIG means that the Programming Language is widely used; used by professionals (at enterprises), students (at universities) and hobbyists (at home).
    What makes a language big then?
    1. Syntax matters. Most of the modern languages running on the CLR and/or JVM support almost the same number of features. The only difference between them is really the syntax you need to accomplish the same stuff. Programmers will say: that language is C-Like syntax? Then I will give it a try (C++, Java, C#, D and then Go).
    2. It COULD be Multi-Paradigm, but to be BIG, it MUST support OOP, which is in fact, the most widely used paradigm out there. Again, nowadays, most of the languages support OOP, even if they were conceived to be Scripting or Functional. Why? Because to be BIG (widely used) it needs to support what all kind of programmers (professionals, students, hobbyists) are familiar with.
    3. Is not only the language, but the IDE support as well that makes a language BIG (widely used).
    a. First, because “Syntax Matters”, it needs to support: syntax highlight, intellisense, auto-competition, code generation, etc.
    b. Second, it should allow you to build several types of applications such as: web, desktop, scripts, console, services, etc.
    c. Support debugging.
    4. It needs to be FREE to use. Not necessarily Open Source, but just FREE, so anyone can use it, build stuff with it and enjoy it.
    5. Interoperability with other Languages. This is accomplished by languages implemented on top of the JVM or CLR. That’s one reason why a BIG JVM/CLR language is better than a native mono-language only environment. Another benefit is that if your favorite language does not support a feature you want/need you can do it in a different language and mix it nicely.
    6. Libraries/Frameworks support. Languages running on top of the JVM/CLR runtimes get the benefit of using several existing stable libraries. Of course you can always build your owns if needed.

    4 and 5:
    You should definitively consider.NET languages. Just look at what they have achieved and just port them to the JVM.
    Java/JVM Languages to consider are: Java, Groovy, Jython, JRuby, Fantom and Scala, but also you can try Sleep (Perl) and Rhino (Javascript)
    If you can consider .NET languages you can try: C#, VB.NET, C++/CLI, F#, Boo, Phalanger (PHP), IronPython, IronRuby, Delphi Prism, Zonnon, Nemerle, Cobra and JScript.
    If you are going to use your language to do scripting only then you should try Powershell, Eagle (Tcl), Sleep (Perl), but if you want your language to be BIG then you need a language that supports OOP hence you should try any language mentioned above.
    6: It doesn’t matter. Java is ok as it is now. It has been that way for so many years now. If you want it to be something else then try another language (Scala?).

    If you want to know some info about all the languages mentioned above then you can have a look at my blog which is: where I talk about CLR, DLR and JVM languages and how they compare.

  23. A "big languages" made something easier or better than its predecessors. Java, for example, simplified programming compared to C++ a lot. I've heard that a C++ programmer makes 50 % more errors compared to equivalent Java code!

    Big languages have to be powerful, but don't have to be too complex. Scala is really powerful and as such avoids some of Java's complexities. Take a look how Java is used today: OOP is broken up with annotations and reflection, which breaks up static typing as well. Or look at the web framework "Spring Roo", which uses AspectJ to reduce the lines of code at the expense of a hard to understand system. All that could be avoided with a more powerful language like Scala.

    Maybe the question whether static or dynamic typing is better is a bit overrated. PHP, Python, JavaScript, and Ruby proved that even large systems could be built with dynamic languages. I consider the compact, easy to change code as the advantage of dynamic languages. Whereas statically typed languages help to avoid coding errors and perform usually much better. Scala code is concise, thanks to type inference, and it is even possible to do "static duck-typing" with Scala! The main source of complexity in Scala exists due to the Java compatibility, I think of "implicits" and the generics here.

    The ability to use Java libs is a strong argument for a new JVM language, but it can lead to otherwise unnecessary complexities. I think that the Java libs are needed for a transition phase. The more popular a new language becomes, the more new libs arises.

    A few years ago I started to use Groovy, but I was disappointed quickly. Groovy doesn't perform well (even it is better today), Groovy needs a lot of Java magic under the hood what makes debugging and reading stack traces a pain. And Groovy is conceptually weak. The pseudo dynamic type system leads to curiosities like that you can't override a method with "def" return type with another method with the same return type. Groovy is a relatively bad languages compared to Scala.

    But is Scala the answer to the question for the next big JVM language? It is the most promising I know, but Scala can be abused to write really hard to understand code and that could be a show stopper. I think one important factor for a programming language is that the average developer can understand and write code. Think of a language you'd like to read code of not so good developers in. I think about Python, since Python has relatevly few concepts, a minimalistic syntax, and the languages is more strict than Perl, PHP, or Ruby. And, yes, syntax matters! Syntax is the surface of a programming language we have to see every day.

    I don't believe that Java can reinvent itself. The changes were much to far-reaching. Compatibility with old Java code had to be broken. My favourite next JVM language would be something like Scala but with fewer features (like implicits).

  24. hi there!

    following my previous comment and your suggestion about a blog post, I wrote about your post on my own blog. Have a look at:


  25. Stephen Colebourne25 July 2010 at 21:57

    Just wanted to say thanks for all the comments so far - really useful thought :-)

  26. Homoiconicity would be nice. I would follow everyone how would lead us out of the reflection, JDK-proxy, AOP, APT, bytecode manipulation and source generation hell. I think these have to be simplified and unified.

  27. I realize this is a 4-year-old post, but I'm a bit disappointed to see ColdFusion (CFML) overlooked here. Even though it started as tag based and written in C++ back in 1995, it was released with a full rewrite in Java back in 2002 (Before Scala was even officially released) and has matured to a modern scripting language featuring Java interop, closures, dynamic typing, and OO patterns. Sure, it's for web scripting and not a general purpose language, but
    CFML remains a very productive platform-- one of the most-used and most mature JVM languages out there but people refuse to acknowledge it.


Please be aware that by commenting you provide consent to associate your selected profile with your comment. Long comments or those with excessive links may be deleted by Blogger (not me!). All spam will be deleted.