The State of Java/JVM in 2012

Is Java dead? What's ahead for programming languages running on the Java Virtual Machines such as Scala, JRuby, and Clojure? We take a closer look.

By Brian Doll, Principal Performance Analyst, New Relic

There's been an amazing rise and fall since it's widespread use began in the late 90s. In this article we'll look at where it's likely headed in 2012.

In the beginning, Java was thought of as fast, lightweight, and portable, and it was seen as an amazing collection of progressive APIs to deliver next-generation applications for a new breed of developers. When Java 1.2 was released, early adopters were right to celebrate -- Java brought with it thousands of new programmers ready to build a staggering number of businesses during the first dot-com wave.

Java adoption in the enterprise was swift and widespread. CORBA was out and SOAP was in, bringing along with it ideas such as Enterprise Service Bus and other large middleware-oriented architectures. Java application-server vendors were pushing the latest in advanced J2EE support, cluster management, session federation, disaster recovery, business rule processing, and a whole host of other features. According to Sun, the network was the computer; according to Java vendors, the application server was the application.

However, what started as a fast, lightweight, and feature-rich language turned bloated, slow, and hard to manage. It had become exactly what it had aimed to replace.

2012 Prediction #1: Java as we know it is dead, but in 2012 the JVM (Java Virtual Machine) will rise

Java, with the bloated app servers, the mountains of XML configuration, and the non-standard implementations of J2EE has since been relegated to that familiar dumping ground we refer to as the "legacy technology" pile. The Java we once knew is dead. Sure, we rely on many large systems built with the technology, but science helps you if you're starting a new project with these tools.

What made Java great initially, however, is still there at the center. The unsung hero of Java is the JVM (Java Virtual Machine) itself. The JVM is far from dead, and, in fact, the JVM will see a continuing resurgence in 2012 -- but under different names. Languages such as Scala and JRuby, maybe even Clojure, offer unique capabilities and are well-suited for different types of systems, but are all built on top of the JVM. In these languages and others, the JVM will gain another wave of new developers to impress.

2012 Prediction #2: Programming Languages running on the JVM such as Scala, JRuby, and Clojure will see increased popularity

Scala, which is sometimes seen as the next generation of the Java language itself, has seen impressive growth in 2011 and will continue to see it well into 2012. JRuby, which is a compatible Ruby implementation that runs on the JVM, has seen steady growth in the Ruby community for its performance and stability; it provides a unique opportunity for Ruby developers to use Java libraries in their code. Clojure is a powerful Lisp dialect that runs on the JVM focused heavily on concurrent programming that allows developers to use existing Java libraries.

With the JVM secured as a standard in enterprises worldwide, these three languages hosted on the JVM can be adopted easily and will gain more popularity in 2012 -- already many top companies are building their own services with JVM-hosted languages. Twitter's services are written in Scala, some LinkedIn services are written in JRuby, and travel site Kayak.com has back-end services written in Clojure. In 2012, these next-generation JVM-hosted languages will bring solutions to unique system challenges, all without the need to battle with corporate operations about how applications written in them will be deployed.

2012 Prediction #3: It's going to be a polyglot world -- companies will focus more on picking the right tool for the job rather than choosing to use one language over another

Early Web applications were not that different from the client-server applications of times past. Large servers would process a request, build a response, and send it back to the client. Today, Web applications rely just as heavily on third-party APIs as they do with their own business logic. These API (Application Programming Interface) services require performance and stability above all else.

We've seen the rise and fall of programming-language popularity, and in the past languages battled for enterprise dominance. Today, we define winning by different criteria: which language plays well with others. Java developers can feel close to home with JVM-based languages, which introduce a new approach to programming while still making use of the many useful and well-performing Java features.

Companies large and small are finding that instead of picking one language over another, they are picking the right tool for the job. Dev teams in 2012 might build Web applications in Ruby, services in Scala, and system integration in Java. Polyglot teams by definition are more flexible and can more easily adapt to changes, regardless where that change comes from.

Tips for Java Developers in 2012

My advice to Java developers is simple:

  • Learn another JVM-based language and see what all the fuss is about
  • Check out how lightweight Java Web apps can be with the Play! Framework
  • Get your lightweight apps and Java services in the cloud on Heroku
  • Profile your Java apps to show off just how fast they are (my company, New Relic, offers such a tool)

Brian Doll is the principal performance analyst for New Relic, a company specializing in Web application performance management. He has been building things on the Web for over 14 years and has extensive experience in retail, media, technology, and financial service industries in both start-up and large enterprise environments.