A Quarter of a Century of Java
May 29, 2020 | 20 MIN READ
May 29, 2020 | 20 MIN READ
February 12th, 1996. This is a significant date for me personally since it was the day I started work at Sun Microsystems as a Solaris Systems Engineer. It was also two weeks and six days after the release of the Java Development Kit (JDK 1.0).
Of course, the origins of Java go further back than this; James Gosling and others started work on a new programming language in 1991, and it was the May 23rd 1995 when Java was officially announced to the world.
So here we are, twenty-five years after the official launch of Java. I thought it would be interesting to share some of my memories of how Java has changed over that time.
Initially, when I first heard about Java, I was rather dismissive. OK, I thought, a new programming language and this odd thing called HotJava, which was a browser written in Java.
Since I’d only been using the world-wide-web for a bit over a year, I was less than excited. My focus (at that time) was on UNIX, writing low-level code for (if I remember rightly) a diskless version for Telco applications. All done in C.
When I joined Sun, it was still to do things in the UNIX space, only now it was Solaris.
Then one day in early 1997, someone asked me to do something that changed not just my career but, really, the rest of my life. They asked me if I could give a presentation on Java…
I still have the presentation I gave; it’s 64 slides long. The first 42 slides deal with language syntax, then 18 on AWT and 4 to wrap things up. I was amused that on one of my slides, I recommended using the Vector class for linked lists. Err, what? I also, apparently, gave a demonstration of Java Workshop.
That really set my course for the next 23 years. Having done a number of presentations and read a book on Java, I decided it would be useful to gain some real-world experience of its use. Back in the late 90s it was easy to move around in Sun, so I joined a team developing internal business apps in Java and learnt a lot; both how to use Java well and how to use it incredibly badly.
After that, I joined the JavaSoft part of Sun as a performance engineer working with ISVs before making a move to the wonderfully named, Java Evangelism team at the beginning of 2001. Since then, I’ve been lucky enough to present a pretty wide variety of Java-related topics in 58 countries covering six continents.
One of the most incredible things about the way Java has flourished as a development platform is through the community. In particular, I’ve always been amazed by the passion shown by Java User Groups (JUGs), and I’ve been fortunate enough to visit many of these over the years. Conferences like Devoxx, Jfokus, JavaZone, JavaLand and many more have all grown out of these groups and provide a wealth of information to help developers get the most from Java.
Of course, Java itself is a massively overloaded term and has referred to a quite mind-boggling array of technologies, features and APIs over the years. Here are a few of the ones I either think were significant or I particularly liked:
Although most phone manufacturers put Java ME on lots of phones, some significant problems prevented its success. Different handset vendors versions were mostly incompatible in terms of additional libraries (the core Java ME set was too small to do anything exciting) and getting an app onto your phone required far more technical skill than was reasonable. What they needed was an app store…
Moore’s law and, more importantly, the iPhone, effectively killed Java ME. A few die-hards continued to use it for some embedded applications, but an attempt to revive it in the JCP recently was unsuccessful.
Sadly, the price per unit was prohibitively expensive (it needed to be more like a Raspberry Pi than a low-end laptop), and the project died out. I still have a few left, as you can see:
This didn’t really get much adoption despite some valiant marketing efforts and in 2011 was re-written entirely as a set of Java APIs. This was (and still is) much, much better and provides a more modern (and straightforward) way of developing user interface code in Java. Supporting things like CSS and later 3D make this, in my opinion, a really great piece of technology. I’ve written loads of JavaFX code and really love it.
This did provide some fun demos like Greg Bollella’s industrial robot at JavaOne and Audi using it to drive a TT up Pike’s Peak autonomously.
There were lots of others that were great ideas but didn’t quite work out in the end: Personal Java, JavaOS and Java for the Advanced Intelligent Network (JAIN), to name but a few.
As a language, Java has evolved over the last 25 years in a way that has, with few exceptions, provided excellent backwards compatibility. I was able to run some (although not all) of XXX
One thing I have to highlight is Java version numbering.
Initially, we had JDK 1.0, which was very logical. Then we got JDK 1.1, which (to me anyway) was already a mistake. With the introduction of things like inner classes, it should have been JDK 2.0. Next came (logically, based on 1.1) JDK 1.2 but unfortunately, marketing got involved, so it was decided to rebrand this as Java 2. Except engineering didn’t get the memo, so we had Java SE 2 version 1.2 then Java SE 2 version 1.3. Things got even more complicated because it was decided to introduce an extra digit, thus Java SE 2 versions 1.3.1, 1.4, 1.4.1 and 1.4.2.
Because the next version of Java introduced significant language changes, marketing got involved again. Behold! Java SE 2 version 5.0 (but java -version still shows 1.5). Finally, it was determined that there never would be a Java 3 and we didn’t need the extra digit, so we got the new, streamlined Java SE 6. That should be it, right? No, sadly not. The internal version still came back as 1.6 and even though we had Java SE 7, 8 and 9, we weren’t finished changing the version string yet. Finally, in JDK 10 we have JDK 10.0.2 (although bizarrely, that second digit will only ever be zero). Hopefully, that’s the end of it!
Of course, over the years, Java has not been without its controversy.
As Java started to take off, rising in popularity right alongside the dot com bubble, Microsoft decided it could ‘improve’ on Java. This took the form of removing certain APIs from the core library java namespace and adding a few they felt were missing. The net (if you’ll excuse the pun) result was two incompatible Javas. Something Sun really didn’t like, since it broke the whole, “Write once, run anywhere” idea. After much legal wrangling and the birth of C#, Microsoft paid Sun $1.9b in compensation. It’s great to see that, for the last few years, Microsoft has become one of the most vocal proponents of Java and offers a fully supported build of OpenJDK (in the form of Zulu) on its Azure cloud.
Roughly at the same time, a lot of people started calling on Sun to make Java more open from a definition perspective. Some people thought there was a need to let an independent standards body take over and define the platform. Someone like ANSI (who published standards for C and C++) or ECMA (who did the same for C#). Given the marketing value of Java, Sun was not keen to do this, and so in 1998, the Java Community Process (JCP) was created. The role of this new organisation was to develop standards for all different aspects of the Java platform. Rather than this just being done by Sun, any interested parties were invited to join. This was a success, in that many companies like IBM, Nokia, SAP and even Google joined as well as some notable individuals like Doug Lea. Different aspects of Java were assigned to Java Specification Requests, each of which had its own expert group (EG). With Java SE 15, there are now 390 JSRs (along with 27 maintenance JSRs, a feature that is no longer used). In theory, each JSR should result in three things:
This certainly addressed the issues of an open specification and meant that other organisations were now in a position to be able to provide alternative implementations of Java technology. The most notable of these was developed by IBM, who developed a clean-room implementation of the JVM, J9.
Early in the new century, there were increasing calls for Sun to make Java open source. The popularity of Linux had shown this to be successful, and many people thought Java should be set free. Working for Sun at the time I remember some people were keen on this idea and some were vehemently opposed.
In 2005, the Apache Harmony project was started that intended to develop an open-source, free Java implementation. Although Sun provided the JDK freely, the license used included a field-of-use (FoU) restriction, which prohibited the use of Java in embedded applications.
In order for the Harmony project to be able to provide a real Java alternative, what they developed (which at the time was Java SE 5) would need to pass the TCK. Sun refused to license the TCK to Apache without including the FoU restriction. Apache found this unacceptable.
After some discussions that did not resolve the issue, in 2007, Apache wrote an open letter to Sun regarding their issues with acquiring the TCK. Sun’s response was to announce their intention to release the source code for the Sun implementation of the JDK under the GPL. Thus, was born the OpenJDK.
Unfortunately, this did not satisfy Apache, which led to a situation of stalemate that considerably hindered the development of the core Java platform. JDK 7 was released on July 7th, 2010, 4 years, 6 months and 26 days after JDK 6; easily the longest time between Java releases. This resulted from a combination of things: the dispute with Apache, Sun’s engineers being diverted to work on JavaFX and the acquisition of Sun by Oracle. Having taken control, Oracle set about sorting things out. They did this with clinical efficiency, convincing IBM to switch sides to the OpenJDK and making it clear that the TCK license was never going to change. As a result, on December 9th, 2010, Apache resigned from the JCP; less than a year later, the Harmony project was retired.
Then there’s the whole Google and Android situation that I’m not even going to get started on…
Although nobody truly knows the exact number, I think it’s safe to say that there are millions of Java developers around the planet. If you look at the surveys of which are the most popular programming languages, Java is always at or very near the top. Indeed, when I’ve been presenting at JUG events, there’s generally at least one recruitment agent there looking for people with Java experience.
With almost predictable regularity and practically ever since Java was a year old people have been predicting the death of Java. I certainly don’t see it anytime soon. The value of the JVM as a managed runtime environment is beyond question. Whether you use Java, Kotlin, Scala or any of a myriad of languages to write your code, they can all be compiled down to bytecodes.
We can’t, of course, forget about JavaOne, the annual (at least until 2017) conference for the latest and greatest in Java. I didn’t start attending JavaOne until 2002 and missed a couple of others. Still, I certainly attended quite a few of these events, twice being awarded the status of JavaOne Rock Star. I was also twice part of the keynote with James Gosling, first showing off my ‘wearable’ computing demo in 2004 and then my JavaFX screen projection demo in 2009. One of the fun things about JavaOne was the show device, which I often got sucked into buying. I finally got rid of my Sharp Zaurus only a couple of years ago. I still have a Java Ring, and I’ll be keeping that.
No retrospective of Java would be complete without mentioning Duke. Even he went through a couple of iterations. Originally, he was going to be called The Software Agent (as he was supposed to be a helper built into the UI of the Star 7 PDA). Joe Palrang, who drew the original character, called him Fang (because he looks a bit like a tooth, which is a common mistake non-Java people make when they see him). Sun PR didn’t like this, so he became Duke, the mascot of Java. He even stared in his own comic, “The Amazing Adventures of Duke” (which lasted for only one edition from Sun’s marketing department).
Many Duke T-shirts have been made, as well as a wide range of other swag. Here’s my favourite, which I think I got from a Sun event in Japan.
I’ll finish by quoting James Gosling, the Father of Java from the foreword he wrote to “HELLO WORLD(S)!” From Code to Culture: A 10 Year Celebration of Java Technology”
“In the early 1990s, a small group of us from Sun Microsystems were given the opportunity to spend all of our time thinking of what ‘the next big thing in technology’ would be. What we created was a hardware-independent software platform unlike any other. We thought it was pretty cool, and so did our developer friends. But at that time, I don’t think any of us really had any idea of what we had done, not to mention how it would change the world. I certainly know I didn’t.
And, of course, it wouldn’t have happened if it weren’t for the Java developer community. Developers are the ones who really made Java technology a success over the years. Their ingenuity, creativity and millions of hours of contributed help has made the Java platform what it is today. We’re lucky to have millions of developers constantly driving it forward into the future.”
Even 15 years later, that’s as true as ever.
Happy birthday, Java!