Java is free and will be

I am writing after a long time, so this has to start with the ‘Since the last time I wrote something’ joke, so here we go:

Since the last time I wrote a blog, Leicester City won the first ever title in their 134-year history. Chelsea hired a new coach to win the title, won the title with him, fired him and hired someone else to win the title.

Let’s start with the blog then, shall we? It’s about Oracle’s policy for Java updates and future roadmap. Oracle released an update a couple of months ago (here, under the ‘End of Public Updates of Java SE 8’ title), it read like this:

Java SE 8 is going through the End of Public Updates process for legacy releases.  Oracle will continue to provide free public updates and auto updates of Java SE 8, until at least the end of December 2020 for Personal Users, and January 2019 for Commercial Users.

This led to a belief that Java is no longer going to be free and Oracle will start charging money for the new versions/updates. This blog is about clarifying what Oracle’s update policy is, how Java versioning works and how it can impact us (i.e. developers). Before we deep dive into it, let’s read the title of the blog one more time, Java is free and will be.

Let’s first see how different JDK versions are maintained currently and how they are structured, have a look at the below diagram:

It looks like this image contains lots of abbreviations, so let’s list them down with their names:

• JSR:   Java Specification Request
• JDK:  Java Development Kit
• TCK:  Testing Compatibility Kit
• JCP:   Java Community Process
• LTS:   Long Term Support

Now, let’s put these pieces together and see how Oracle’s release cycle and different JDK flavours work:

• With every Java release, Oracle provides Development kit, called as Oracle JDK
• The OpenJDK community creates and maintains the (GPLv2+CE) open-source Reference Implementation (RI) of the Java SE Specification as governed by the Java Community Process (JCP) and defined through an umbrella Java Specification Request (JSR) for each feature release
• There are implementations of Java SE from various providers (such as Azul, Eclipse, IBM, Red Hat, Oracle and others), the most common of these being Oracle JDK
• Providers prove that their implementation meets all the requirements of the Java SE specification by having it pass all the tests of the relevant Technology Compatibility Kit (TCK)

Reading Oracle’s statement again, it says Oracle JDK 8 is undergoing the “End of Public Updates” process, which means there are no longer free updates for commercial use after January 2019. Does this mean we will have to pay to use the existing version? Absolutely not! We can still use the existing version without any issue and keep using it for as long as we want to. However, at a later stage, if Oracle fixes a security bug or any other issue (like NullPointerException, like most of us do) then, we won’t get it. We will still be stuck on the older version that doesn’t have the fix. In this situation, we would have two options:

• Get the paid updates from Oracle
• Switch OpenJDK version in our systems/servers to be one of the free ones (e.g. Red hat, Eclipse, IBM or Azul) as OpenJDK community will be maintaining these JDKs and the fix will be applied to these JDK flavours as per the specification mentioned in JSR

This would still raise some eyebrows and make people think that Oracle is no longer providing the free Java updates, so Java is not free. Chill, that’s not the case. Here’s why.

Oracle's Long Term Support (LTS) for future releases:

Oracle has adapted new 6-month release cadence (more on that here), which means there will be a new release every 6 months. Here’s how updates will work based on the existing as well as new release:

• Free updates for the version will be provided by Oracle for the first 6 months of the release. However, after 6 months, a new release will be out and there won't be any free updates for the existing release from Oracle. In other words, Oracle will lead the first six months of an OpenJDK LTS codebase, providing updates and producing Oracle OpenJDK builds, but will then afterward only provide updates for Oracle JDK, under a paid support plan
• After 6 months, Open JDK community will handle the updates and this means, we can still get the free updates for the Non Oracle JDK versions. The paid support applies to Oracle JDK only

Let’s elaborate this in depth (in terms of branching and builds). Let’s say Oracle is releasing Java 13 in September 2019 (they really are). They will have a github repo for that version, called java-13. This is how it will work:

• Both the builds for Oracle JDK and OpenJDK will be generated from the master branch of the repo java-13
• If Oracle fixes any bug, the commits will be made to master branch and the updates will be generated from it till March 2020
• On March 2020, 3 things would happen:
• Oracle will hand over the master branch of java-13 repo to OpenJDK community to actively maintain it
• Oracle will release a new version, called Java 14 and there would be a new github repo for it (let’s say java-14)
• Oracle will create a branch for java-13 repo, called java-13-paid-updates
• After March 2020, if a fix is made to any of Java 13 feature, it will be checked into java-13-paid-updates branch and not the master branch. Builds from this branch will only be provided to people who have subscribed to paid updates. Additionally, the info for the update will be provided to OpenJDK community so that they can apply the fix to respective JDKs
• Master branch of java-13 repo won’t be touched after March 2020, however, the fix would of course be present in java-14 repo so if we upgrade, we will get the fix for free

Just to go back in a bit of history, when Oracle stopped updates for Java 6 and 7, Red Hat stepped in and led OpenJDK 6 and 7 projects. And they intend to apply for leadership for JDK 8 as well (after January 2019). Going by this way, I won’t be surprised if Red Hat ends up owning Java, like Oracle did in 2009.

To summarise, this is what Oracle is trying to say:

“Move forward with us. If you can’t, pay us to support your legacy systems”

I don’t find anything wrong with it though. If it’s their business strategy, let it be. It doesn’t mean Java is not free.

By the way, all this discussion is limited to JDK only, and not JRE. If you don’t know the difference between JDK and JRE then well, *facepalm*.

Quotes' and facts' courtesy : Medium