A favorite hobby-horse among various programming-related communities is to talk about why “Java is dead”, and further, that programmers working in the Java ecosystem should really look for greener pastures elsewhere. You see these sorts of posts pop up on proggit, for example, often enough for it to get old. That’s a lot of hot air, with plenty blowing in the other direction from various folks that have been pushing hard for significant improvements and changes to Java. Both sides are wrong, though, because as a result of its success and a series of historical accidents:
Java-the-language is dead.
Get over it, and realize that because of that fact, you’ll probably come to depend upon Java more than you ever thought possible.
The JVM is probably one of the most vibrant platforms for developing new programming languages there is, in part because of the status of Java-the-language.
First, let’s settle the premise. In comments on one of his recent blog posts, Joe Darcy, one of the fellows the heads up Sun’s management of the JVM and JDK (I’m not sure of his exact title and portfolio), said a couple of key things about the never-ending saga regarding closures in Java:
There are millions upon millions of Java developers who would have to learn about closures if they were added in the platform.
…there is far from unanimity in the Java community on the underlying choice of whether or not closures would be an appropriate language change for Java at this time.
OK, there it is, closures are never going to be added to the Java language. Done, and done. And if closures aren’t going in, then you can surely bet that other things aren’t going to make it, either. To further make the point, Joe commented on an earlier blog post of his here 1,saying in reference to a question about why the Java standard libraries don’t slough off deprecated APIs:
To date, we have valued continued binary compatibility with code calling the deprecated elements more than cleaning up the API.
This sort of stuff pisses a lot of people off, and leads others to propose mildly absurd things IMO, like forking the Java language into “stable” and “experimental” versions. This a lot of wasted effort.
It seems that Sun decided long ago, through pressure from its customers and developers, that compatibility is more important than innovating at the language level. With that, managing Java and the JDK became more an exercise in stewardship than anything else. The quotes above from an authoritative source are proof-positive that this is the case.
That may make the Java language dead with regard to features, but it’s hardly useless – it’s simply transitioned to be the stable “systems language” for the JVM that a large swath of programmers (who Sun likely correctly identifies as being uninterested in things like closures, syntactic improvements, etc. etc.) happen to use for applications as well.
Trading off “progress” for stability bestows upon Java at least two characteristics that are shared by other systems languages:
- screaming into the void about how improvements and changes should be made yesterday is generally pointless and irrelevant
- knowing that the language is essentially fixed for years to come means that it fades into the background as a very useful artifact for those that want to build on top of a system with well-known characteristics
A side effect of this is that the JVM is a very fertile spot for new(er) languages, where language implementers don’t have to worry about their building blocks being taken away or changed radically from year to year2. At the same time, the JVM itself has been getting tweaked and tuned heavily under the covers to support non-Java languages, not the least of which is Sun’s JavaFX, their entry into the post-Java JVM language fray3. So, you want your fork of Java that pushes boundaries? They are many and plentiful, so go choose one, already.
The upshot of all this is that it’s more likely than not that over the course of the coming years, your life (and quite likely your professional life as well, if you’re involved in software) will come to rely upon Java, the JVM behind it, and many different other language stacks built on one or both of those technologies.
Of course, interop between these languages is a concern: only APIs matching Java’s binary signatures are accessible by all languages, there’s no standard interface for closures, there’s no standard (sane) numeric tower, etc. etc. These things are frustrating if one happens to be working in a polyglot environment, but I’ve no doubt that necessity will draw the larger players in the JVM language space together to establish certain baselines to ensure interoperability.
In the end, we might have all been better off if the current state of affairs had arrived years ago. A steady drip, drip, drip of Java language improvements serves only to keep developers tied around what is functionally a frozen language, and away from superior alternatives (on the same JVM platform!) if they’re so inclined to look up from their work. Since the state of play vis á vis Java-the-language is clear, maybe those that care so deeply about programming language productivity, innovation, and progress can set about enjoying the advantages of the future that Java has ensured for us all.
1 I don’t mean to pick on Joe, BTW. He just happens to have been relatively visible of late, in conjunction with his appearance on the Java Posse podcast, as well as in various chatter around the recent JVM Language Summmit.
2 The reality is that if you’re a language implementer (or an aspiring one), you have two platforms to choose from, the JVM or the CLR, and it’s worth noting that the former appears to be outpacing the latter in terms of attracting innovation in language design. There’s a lot one can attribute that to, but having an essentially fixed baseline language (e.g. not what C# is at all) might be a minor contributing factor.
3 Worth noting is the fact that JavaFX has oodles of features that people have been banging on about for Java to get for years and years. This is further verification that Sun’s reticence to produce feature-rich languages has nothing to do with their technical capabilities or general motivations, but with decisions made about Java’s status driven by business considerations.