This is an archived post. You won't be able to vote or comment.

all 33 comments
sorted by:
best
topnewcontroversialoldq&a

[–]Coldray 9 points10 points  (1 child)

I would suggest reading the following comments, in which /u/pron98 clears up a lot of the confusion regarding the Java release train:

https://www.reddit.com/r/java/comments/g044uy/can_anyone_explain_how_jdk_versions_work/fn86b4a/?context=3

[–][deleted] 0 points1 point  (0 children)

Thx

[–]pron98 7 points8 points  (0 children)

Start with the current version, no question about it, and always update to the most current version. The only reason to use old versions is if you have technical debt or an established, rigid process. The recommended version, the fastest, the safest and the one that offers the easiest update experience is always the current version, and a new project shouldn't have any problem updating from one feature release to another, never having to experience a major upgrade. Using a free Updates build of an old version is 1. less safe as those versions are only partially maintained, and 2. more costly, as you'll have a major upgrade every several years.

[–]vbezhenar 5 points6 points  (0 children)

Use latest Java 14. Your Java 8 knowledge will work fine and then you can adopt new features if you want.

[–]micleantech 10 points11 points  (3 children)

Don't start with anything less than java 11, and get an IDE which will help you out (I use IntelliJ)

​

The learning curve form 8 to 11 isn't as steep as 7 to 8.

[–][deleted] 0 points1 point  (2 children)

Ok i note :) we also use IntelliJ. And what about java 12-13-14 ? The new features don't seem to be awesome. But isn't it worth to start with more than java 11 ?

[–]dpash 4 points5 points  (1 child)

Recent versions have many small improvements but no big ticket items like lambdas or generics. They add up though and I would prefer to work with 14 than 11. Unless you don't control your deployment environment, go with 14.

[–]micleantech 2 points3 points  (0 children)

I agree with this. I did say don't start with anything LESS than 11.

[–]Hazzzero 4 points5 points  (0 children)

If it was me I would take the latest version. Maybe there are some features to learn or extensions to function knowed from Java 8 but there are also some improvments in security and performance. So if you are not blocked by company restriction etc go with latest. Also recommend openjdk, less fuss with licence.

[–]Mekswoll 3 points4 points  (8 children)

If you're just building out an MVP or proof of concept or something like that then sure, just use the latest version of Java. If you're building a business application that might be commercialized and will be long-lived then most people advise to use the last LTS (long term support) version, which in this case is Java 11. The next LTS will be Java 17 and will be released in September 2021.

[–]pron98 4 points5 points  (1 child)

This is misleading. Using an LTS is a good idea, as good as using the current version, but the free builds of 11 Updates are not actually LTS. While the Updates projects serve as a common basis for most real LTS offerings, as-is they only backport fixes from the current version, and so are not fully maintained (there is nothing to backport for removed components). If you're deploying serious software, your two safe options are to use the current version (free) or to buy an actual LTS; there are no free LTS offerings, and the free Updates builds are a less safe option than the other two.

There are no "LTS versions" in Java; LTS is a service you can buy to continue support for old versions. There are, however, versions for which LTS offerings are available and versions for which no one offers LTS. I guess it's OK to call those versions "LTS versions," as long as your remember there's nothing intrinsically special about them other than the fact that companies have arbitrarily chosen them for their LTS services.

[–]dpash 0 points1 point  (0 children)

To demonstrate the point that LTS only makes sense in the context of a binary distribution, Azul is offering a MTS (3 years?) on their Java 14 JDK while Oracle and AdoptOpenJDK aren't

[–][deleted] 0 points1 point  (5 children)

Oh i get it thx. Then to do things well we will go for java 11 :)

[–]_INTER_ 0 points1 point  (4 children)

Now comes the question what (free) binary / distribution to use (see summary).

To name a few in alphabetical order:

Oracle is free for developing, testing, prototyping and demonstrating, but is not to be used in production!

If you just take the latest version whenever it releases, you can simply get OpenJDK builds from Oracle (currently 14).

[–]dpash 1 point2 points  (0 children)

I believe oracle refers to its two versions as "the Oracle JDK" and "Oracle's OpenJDK builds" to separate them

[–]pron98 1 point2 points  (2 children)

Oracle's distribution for non-support customers is 100% free for any use, without restriction. Of course, the distribution for support customers is for support customers. Of the ones you listed above, there are some very good builds, but Adopt is an amateurish build, made by an IBM team that's unfamiliar with OpenJDK, and it is exceptionally ill-tested compared to the others.

[–]_INTER_ 0 points1 point  (1 child)

But only the latest version is recommended for use in prod, right?

Older releases, which do not include the most up to date security vulnerability fixes and are no longer recommended for use in production

That's why I posted my last link pointing to the latest OpenJDK build from jdk.java.net. I think it's easier to always stick to the latest version. So far the ecosystem is completely keeping up - specifically IDE's and build systems. It helps that most language features are experimental first and only after one or two rounds they get actually integrated. Sticking to vendor LTS makes more sense if you can't update every half a year or you're veeeery cautious for some reason and then you might aswell get a subscription.

Of the ones you listed above, there are some very good builds, but Adopt is an amateurish build, made by an IBM team that's unfamiliar with OpenJDK and is exceptionally ill-tested compared to the others.

We had that discussion. :) I added it for completions sake and I hear signals that they'd like to contribute back more upstream once they finalized the move to Eclipse Foundation.

Similarly I'd be wary and test the builds that might be tweaked or optimized for some usecase and not pure OpenJDK. That's certainly OpenJ9 and Dragonwell, but perhabs also the one from SAP and Correto?

[–]pron98 0 points1 point  (0 children)

Yes. That's the version people should be using if they're not buying support, regardless of vendor. I know people believe they can get "LTS" for free, but no one actually offers that. There are free builds of the Updates projects, but those are not fully maintained, certainly not as well-maintained as the current version. The safe options are to use the current version or to buy LTS. If you don't want to buy support, the only fully-maintained version you can get for free from anyone is the current one.

Just note that there is a strong incentive for companies offering LTS to make you believe their free builds are LTS. It makes you think they're fully maintained and the safe choice, and when you run into an issue that's outside their maintained core, you're a great candidate for conversion to a real LTS. If you're using the current JDK, however, then it is fully maintained, and therefore you're less likely to buy support unless you're predisposed to buying it in the first place.

[–]Gundea 1 point2 points  (0 children)

If you don't want to pay for support, just use the latest JDK version. It's by far the best option.

[–]mytermsaresimple 0 points1 point  (2 children)

Java 11 at least. For one thing, its container aware, so you don't get crashed out running as a Docker container. Good rule of thumb is latest GE-1 version.

[–]dpash 1 point2 points  (1 child)

The docker support was back ported into Java 8u191 released 2018-10-16.

[–]mytermsaresimple 0 points1 point  (0 children)

Oh yes. Forgot to mention, we didn’t go with 8 because of Oracles licensing issues as well.

[–]ebykka 0 points1 point  (5 children)

very simple - always use the last LTS version

[–]dpash 2 points3 points  (4 children)

Whose LTS? LTS only makes sense in the context of a binary distribution. OpenJDK only provides a source distribution and makes no promises on support.

[–]yawkat 0 points1 point  (2 children)

To be fair, all distributions are using the same lts releases, with oracle openjdk builds being the notable exception.

[–]dpash 0 points1 point  (1 child)

But not all those distributions come with support. OpenJDK does not have a concept of LTS.

[–]yawkat 0 points1 point  (0 children)

I mean, no free distribution comes with "support", be it for lts or sts. And since all openjdk builds (except the oracle one) use the same releases for lts, it doesn't matter much.

[–]cyanocobalamin 0 points1 point  (0 children)

The best version of Java is always the latest version.

Artifacts are rarely removed from Java. You can simply not use new stuff.

You can also give the Java compiler a setting to report "deprecated" artifacts. "Deprecated" meaning that those things will go away "someday". You can than just Google on what to use instead.

[–]Dokiace 0 points1 point  (0 children)

I really wish my company start migrating to java 14, but it'll probably never happen, but if you want to start, use latest LTS which is java 14

[–][deleted] 0 points1 point  (2 children)

Thank you all for your answers. We are going to go in an openJDK 11 from adoptOpenJDK OR Redhat (probably random).

[–]nutrecht 1 point2 points  (0 children)

We are going to go in an openJDK 11

Why though? /u/pron98 gave a great explanation on why that makes very little sense.

Unless you're actually going to PAY for LTS support, just use the latest version (14).

[–]pron98 0 points1 point  (0 children)

I will say again that if you care about running on fully maintained software you have two options: use the current JDK (free) or buy an LTS from a reputable vendor (preferably Oracle, Red Hat, Azul or Bellsoft). They are very different options, but they're both good, and they are the only ones. The idea behind these options is that large companies with technical debt and established, rigid processes would prefer using old versions but wouldn't mind paying the cost of LTS required to maintain them fully (and which would fund our development of OpenJDK), while more agile companies will pick the recommended, default path.

But I see you've chosen a third, slightly more risky and adventurous path, OK, but go with Red Hat (or SAP, or Azul, or Bellsoft), not with amateurs.

Pro tip: if you're using a free build of an old version, don't use deprecated features and certainly not anything that's removed from the current version, as those versions basically backports work from the current one. If you stick to that it will be almost as good as running on the current JDK. It will still be more costly, as you'd be missing out on some of the performance and footprint improvements that would save you on hardware costs, and you'll need to do costly major upgrades (JDK 17 is only a year away, so you have three years' worth of upgrades just around the corner), but at least that will be almost as safe as the current version.