Java celebrates its 29th birthday

#java #birthday #history #experience

Java celebrates its 29th birthday today! To pay homage to Java, I have decided to look at its walk of fame from the eyes of a developer (that is, your humble servant). As the narrative below is quite personal, it omits many key points because they were not important to me. On the other hand, it includes many points that other people may consider insignificant, but not me.

1989: Project Oak

Java didn’t get its name yet. It was called Oak and was a part of an ambitious project, including not only a language, but also an OS and libraries.

1994: Java 1.0

Oak was renamed to Java. Shortly after, Java 1.0 saw the light.
Those were the days of Green Threads in Java! But for better or for worse, they would be abandoned in Java 1.1 to appear later in Java 21. Also, there were no generics, and JMM was very different (and frankly, hard to understand and deal with).

In addition, AWT was already there, but Swing wasn’t.

1997: JDK 1.1

This is the year when things started to get standardized. There were multiple standards introduced: JDBC, RMI, Java Beans, i18n, etc. It’s hard to believe, but they all are still in Java and supported by frameworks such as Hibernate. Besides, they are changed in a backwards-compatible manner; many of us are in a love–hate relationship with this approach, right?

1998: J2SE 1.2

This year, Swing came into the game. Also, this is the year when JDK was renamed to J2SE: Java 2 Platform Standard Edition. This is because there was at least one other edition of J2: Mobile, a subset of Java intended to work on weak devices. I still remember my first time patching the Java heap size on my Sony-Ericsson five years later. And games were written in Java, too.

Also, CORBA was introduced. We still use it today but call it gRPC (just kidding). CORBA itself would live in Java for a long time.

2002: J2SE 1.4

Every Java release introduces a bunch of interesting changes, but I’m not going to enumerate them all because as I mentioned, I want it to be more of a personal story. The reason I brought up 1.4 is that it introduced Java Web Start and Applets, a way to call Java from a web browser. It seemed like magic: I could run a full-fledged application by clicking an icon in the browser. It might have been quite slow, but it was just unbelievably powerful for something working in a browser. Remember, JS was not a real thing for the front-end development back then, let alone the development of heavy logics.

By the way, Liberica JDK supports OpenWebStart in case you need it!

2004: Java SE 5

This was a huge one! Not only because it was the first release I worked with as a developer, but because it brought tremendous changes into Java. I dare to say that it’s the foundation of today’s Java. The release brought

Generics
Enums
The new (current) JMM (Java Memory Model)
java.util.concurrent
varargs

I think that these features made Java a modern language!
Also, it was the last release supporting Windows 98. Never liked it, I used to be a Windows XP person (until 2009, when I switched to Linux).

2011: Java SE 7

It'd been a whopping five years since the release of Java 6! I moved from total noob in development to something middle senior and spent almost all my career years with Java 6. I thought it was the last Java, and later we will switch to Groovy or Scala. I even brought both of them into production!

This release brought a lot of new improvements in terms of performance, invokedynamic and many other things, but for me, a young developer, it was a disappointment. I expected it to have lambdas. Groovy had them for quite some time already!

2014: Java SE 8

My dream came true. They released Lambda support! I immediately stopped using for loops and replaced them with streams. Sometimes it was smart, sometimes it wasn’t. It seems I was not alone: Java 8 is still used heavily in the bigger enterprises. And for those who are not planning the migration to newer JDK versions in the near future,there’s Liberica JDK Performance Edition that couples JDK 8 and JVM 17 and brings the performance of newer Java versions right to your door, almost no code changes required!

I will name one more thing: DateTime API that looks almost exactly as JodaTime API.

2018: Java SE 11

I can call this release the first backward-incompatible release I used. The thing is, some modules were removed and I had to add them as external dependencies. For example, Java EE was not part of JDK anymore, as well as all its annotations, etc. So I had to add them to my already huge pom.xml.
But do you remember that they added CORBA in 1998? It took 20 years to remove it, from Java 1.2 to Java 11! Would be cooler to remove it in version 12, right?

Java 11 brought many interesting things, for example ZGC and the native HTTP Client. I didn’t need to call new HttpUrlConnection() anymore! Also, they’ve deprecated the JS engine running on Java, called Nashorn. I didn’t mention it and never used it, but the interesting fact is: it was introduced in Java 8! It sounds like the pace really increased!

2020: Java SE 15

Nobody noticed this release because at this time, the release cadence was two releases per year. That’s too many releases to catch up with for a mere mortal!
Bit it was an interesting release because:

Shenandoah was officially introduced;
Text blocks appeared;
EdDSA encryption is built into the JDK.

The story goes on

After Java 11, there were two more LTS releases, JDK 17 and 21, and the next LTS release is due this September.
But at some point, I fell in love with Kotlin and Java and myself… We didn’t part ways, but I stopped following its evolution closely. The story doesn’t end, though, and there were many exciting features added to the platform, such as records, virtual threads, pattern matching, etc. And even more novelties are in the makings!
So let’s wish Java Happy Birthday and many years of prosperity ahead!