The future is now -- Java development in 2008

What do the past 12 months tell us about the year ahead?

The year 2007 was full of exciting plot twists, punctuated by growing excitement about dynamic languages, the open source evolution of the JVM, and the rise of Google as a strategic contributor to the Java community. The question is, what does all that tell us about the year ahead? Andrew Glover has some answers for Java developers who need to know -- now! -- what's coming in 2008.

French poet Paul Valery once lamented that "the trouble with our times is that the future is not what it used to be." Valery's comment was uttered years ago, yet his words are timeless for those of us living in the age of the Internet, fueled by the rise of the Java platform.

In the span of a little more than a decade we've seen Java applets come and go. We've seen the apparent demise of EJB, the rise of JSF, Spring, and Struts (not to mention the beginnings of Strut's slow decline), and the redefinition of Java itself into both a language and a platform. The Java platform has split into three branches (Standard, Enterprise, and Micro) and the JDK has been released to the open source community. The Java language has expanded to include annotations, generics, enumerations, advanced collections, and more. It has also begun to share its home, the JRE, with dynamic languages like Groovy, JRuby, and Rhino, to name a few. In fact, if you think about it, especially over the last few years, we've collectively watched as the moniker of Java has transformed from a language into a veritable platform.

What we've learned in the last decade is that Java is much more than a language or a platform: It's a community. It's an economic ecosystem. It's a living, breathing entity that has matured and grown into a veritable lifeline for a cornucopia of applications, and for large and small companies alike.

And so, despite some rumors to the contrary, I would argue that Java isn't going anywhere but up in 2008. Rather than peer into a crystal ball and try to divine the future, let's reflect on the major events and trends of the past year. Taken together, they reveal all we need to know about what's ahead in 2008.

Halcyon days

The year 2007 was a roller-coaster ride driven, most dramatically, by growing interest in dynamic languages, the open source evolution of the JVM, and the rise of Google as a strategic contributor to the Java community. What's more, wider adoption of unit testing, continuous integration, and other agile development techniques suggests that Java developers are beginning to view our craft as a profession that requires accountability. We are finally starting to focus on the quality and longevity of our code as much as its speed to market or immediate applicability in the enterprise.

All told, 2007 was a year of some clear triumphs, as well as some disappointments and squabbles that made for more bumps along the way than some in the Java community had anticipated. Consider the following major factors that shaped the year behind us.

Dynamic languages come of age

Groovy reached a pivotal milestone in 2007 with its 1.0 release, followed in short order by Groovy 1.5. Having come a long way over the course of five or so years, Groovy is positioned as an additional language for the JRE, not a replacement for the Java language.

Groovy's big selling point is its shorthand syntax, which simplifies everyday programming activities. For instance, opening and reading a file is a typically verbose construct to code in normal Java:

try {
     BufferedReader in = new BufferedReader(
        new FileReader(path));
     String line;
     while((line = in.readLine()) != null){
       System.out.println(line);
     }
     in.close();
    }catch(IOException e){
      System.err.println("Exception reading");
    }

But the same code in Groovy can be written much more quickly:

new File(path).eachLine{ line ->
     println line
    }

Basically, Groovy (like other dynamic languages) permits you to drop exception handling, types, and semi-colons, and even permits more concise coding constructs that make the code ultimately easier to read (yes, that File object above is Java's java.io.File).

1 2 3 4 Page
Join the discussion
Be the first to comment on this article. Our Commenting Policies