This year will mark the tenth anniversary of the official launch of Java technology. It seems like only yesterday. No doubt there will be celebrations similar to the five-year anniversary, so I thought I would take this opportunity to step back in time and track Java's course.

In January 1996, less than a year before that first launch, the first full developer kit, JDK 1.0.2, was released. This was my first experience of the Java platform. Like many other developers I had been using C and C++ and myriad third-party libraries. Suddenly the ease with which anyone could build a UI, or a web applet, and make an application both thread- and networking-aware was exciting. I attended the first JavaOne in 1996 and it captured that energy, even with only 6000 attendees it was a sellout. Sessions overflowed, handouts disappeared in minutes, and were never to re-appear at any JavaOne conference again; many speakers were overwhelmed by speaking to a large conference for the first time.

The JDK 1.1 release appeared a year later and bumped along by way of maintenance updates for many years, finally ending with 1.1.8.

Some of you may remember that the only browser that initially supported 1.1 was Sun's own Hotjava browser. This lag in support for the latest runtime would lead to the modular Java Plugin and Java Web Start technology.

JDK 1.1 also introduced JDBC, RMI and the JavaBean model. The JavaBean component model, while introducing the powerful getter/setter pattern to the Java platform, also introduced the infamously deprecated methods in AWT. To move to the JavaBean pattern with as little risk as possible, AWT code that needed updating simply called the deprecated methods, which made removing them later unlikely. AWT also introduced the event-delegation pattern that would be heavily used by another step on the Java roadmap, the Swing project.

Project Swing, or the JFC components, had a parallel release train before being integrated into the JDK. Anyone remember com.sun.swing? The Netscape browser team already had a technology called IFC that Netscape had acquired and this was used as the basis for JFC. JFC was a pure Java graphical toolset and required a little support from AWT. However, the amount of work required was huge. Essentially anyone who was working on AWT was moved to JFC and Swing, All new development for features like accessibility and full drag-and-drop were earmarked for Swing only. The next step was to merge the Swing code base into JDK 1.2.

JDK 1.2 was supposed to be called JDK 2.0. Since its release was close to the millennium, even Java 2000 was considered. The naming discussions resulted in Java 2 version 1.2. The release didn't just include Project Swing, but it did include the Collections API, a new Java 2D rendering engine and a new sound engine. The last two technologies were adapted from existing third-party products and their integration put a strain on the release process. Some of the bugs introduced by this integration weren't fixed until the 1.4 maintenance releases and J2SE 5.0

Most developers have probably forgotten 1.2.1. It was a short-lived security bug fix. The true maintenance bug fix was 1.2.2. JDK 1.2.2 was also the first time Sun released a JVM port on Linux. The JVM itself was called the classic JVM and used a JIT compiler.

Waiting in the wings was the Hotspot JVM. Sun had acquired the technology that was used to power Smalltalk and had spent a lot of cycles getting it release-ready.

Unlike the JIT compiler, the Hotspot product was a full JVM in its own right. It used native operating system threads, where the classic JVM could also use the userspace threads called green threads and introduced new garbage allocation techniques, finer thread management and faster monitor locks.

J2SE 1.3 was released in 2000 and introduced the Hotspot JVM on all platforms. With such a fundamental change, it took until 1.3.1 for the JVM to be supported by all the tool interfaces.

The last five years are fresher in everyone's memory. J2SE 1.4 arrived in 2002, and introduced NIO, Java Web Start, a 64-bit JVM and Swing focus, performance tweaks and the logging API. It was followed by the 1.4.1maintenance release, which previewed an Itanium port and new garbage collectors. J2SE 1.4.2 brought the 1.4 release train into the station.

This brings us to the present times with J2SE 5.0. J2SE 5.0 focuses on improved startup time, new language features and system monitoring and improved product quality.

The Java platform has certainly come a long way in 10 years, but I'm sure you'll agree it's been an interesting ride.

Resources