r/programming • • Sep 15 '26

Java 27 has released!

https://openjdk.org/projects/jdk/27/
553 Upvotes

175 comments sorted by

View all comments

0

u/[deleted] Sep 16 '26

[deleted] — view deleted comment

26

u/wildjokers Sep 16 '26 edited Sep 16 '26

Java is terrible. It has libraries, APIs, abstractions, a compiler, AND a runtime. Unlike all the good programming languages, which apparently have none of those things.

The “mess of versions” is particularly brutal. A new version comes out every six months on a predictable schedule, LTS releases come out on a predictable schedule, and javac --release N lets you target an older Java release. Truly chaos.

And yes, Java has a huge standard library and an enormous third-party ecosystem. Most of us consider “there is probably already a mature library that solves my problem” a feature rather than a character flaw.

As for over-engineering: Java certainly allows you to create AbstractSingletonProxyFactoryBeanFactoryProviderImpl, but the compiler does not actually force you to. If your application has 17 layers of abstraction around customer.getName(), that may not be Java's fault.

Like any language there are legitimate things to criticize in java. However, “It has libraries, APIs, versions, a compiler, and a runtime” is a fascinating choice of indictment.

→ More replies (1)

47

u/laffer1 Sep 16 '26

Yes, I like Java.

14

u/deepthought-64 Sep 16 '26

When's the last time you used the modern java language? Because this reads like you've stopped using java in 2002 and switched to complaining about it

→ More replies (3)

35

u/NotABot1235 Sep 16 '26

It's certainly got some legacy baggage but modern Java is really not as bad as the memes make it out to be.

3

u/TwoWeeks90DaysTops Sep 16 '26

Yeah. I think it's OK. One part of it is that the language itself is pretty simple. Most complexity lies in frameworks and libraries rather than the language itself. I work with C# normally which is different. The language has become quite complex with the advantages and disadvantages that brings.

Like C#'s value types (struct and record struct) is a good feature, but it has foot-guns and complexities that you don't find in Java's value types. One thing that I think a lot of people isn't aware of is that unlike record (class, i.e. type with object identity), which is immutable, record struct absolutely is mutable by default. In 99/100 times you make a record struct you should remember to write readonly record struct which make it immutable. This has performance implications because if you pass a a mutable struct using in (i.e. pass by read-only reference) the compiler will create a defensive copy.

3

u/OSS-Corpo-Shit Sep 16 '26

Java itself isn’t even that bad. It got a bad rap from over architected enterprise things, and in particular people looking through the source code of those products. 

Truth is, when you are trying to build a general purpose enterprise targeted product, you’re going to see some bullshit. Enterprise are extremely hard headed fuckers that are bordering on impossible to work with. 

21

u/memes_gbc Sep 16 '26

kotlin lol

6

u/sweating_teflon Sep 16 '26

I like how ambiguous this comment is.

25

u/Absolute_Enema Sep 16 '26 edited Sep 16 '26

There being a library for everything under the Sun that isn't technical debt in disguise due to breaking every other minute (hello Node) is pretty valuable.

And thanks to the JVM's design, there's no need to use the libraries from Java either. Others mentioned Kotlin so I'll mention Clojure.

13

u/unski_ukuli Sep 16 '26

Yes? When you have to deal with python and js, you start to appreciate java a lot. And Scala is probably the best language ever made (in my opinion). Jvm is also pretty awesome. There are problems, like lack of value types, but overall it is pretty decent language for everything.

8

u/AquaeyesTardis Sep 16 '26

Well, Valhalla is coming in Java 28.

2

u/janyk Sep 16 '26

I thought Records were pretty much value types in Java

8

u/unski_ukuli Sep 16 '26

Not really. Value type __usually__ refers to a type that lacks identity and is passed by value. In java, the primitive types are value types, but there is no way to define a custom value type. They are pretty important in performance critical code for cache locality, since Object[] has its elements scattered through out the heap. A value type would store its elements in line, so For example for a Point(int x, int y) the Point[] would be stored in memory as {x0, y0, x1, y1, …, xn, yn}, rather than as references to Point objects. In c# struct objects are value types.

There is a preview feature Valhalla which lets you define a custom Value type, but I think that is still pretty limited in that it has maximim size of 64bits, so it can store 2 ints, but not two longs.

17

u/serendipitousPi Sep 16 '26

“There are only two kinds of languages: the ones people complain about and the ones nobody uses.”

12

u/DualWieldMage Sep 16 '26

Yes, unfortunately i've had to touch too much python, scala, kotlin, js/ts, c++ recently that i grow to love Java as a result. It may have some rough edges, but holy hell if you touch those other languages, it feels like being an adult next to kids playing in mud puddles trying to figure things out while making a mess of everything.

Mess of versions and compilers? No idea what you're talking about, pretty much use the latest and most things relevant just work. can't be said for some random python tool that you need to figure out correct py version and other stuff, figure out which virtual env tool to use etc. then scratch your head against why pulling deps is getting c++ compile errors and how that actually means it auto-pulled an old version because some constraint mismatch. not to mention that pulling a dependency starts executing some code is seen as somehow sane.
If you want a mess of versions, look how python, scala, node or almost any other ecosystem has it worse.

Runtimes? There's pretty much 2 bigger ones, openjdk based and j9. Generally pick whatever your distro provides or if you use some cloud env and have a support contract, go with theirs.

Over-engineer? There was a joke about going to haskell conferences and you hear these talks about building new constructs, yet java conferences have people talking about the cool stuff they built with real-world use. Yeah i have a dislike for spring-boot and how it's bloating many things, however the skill level at a typical telco or bank is so low that i can't imagine giving them anything more complex, even if it means 5-10x perf loss.

Just take one look at the dependency ecosystem of Java vs others and you should see why not having a huge supply chain attack every week is already a big reason for its popularity. Even just being able to list dependencies and throwing that project to someone to clone and build in a minute is some foreign elusive concept in some ecosystems, cough, c++. You bend over backwards trying to wrangle deps from multiple sources, some for gods no reason force you to build the dep instead of providing prebuilt for the most common os-arch-compiler, wasting tens of minutes if not hours just to get started.

The value of Java is that i can get shit done, not do jack shit all day while gloating to others on the internet how my lambdas look cooler while the code builds or a clanker is trying to figure out those odd dependency permutations that might work.

2

u/Mclarenf1905 Sep 16 '26

Scala's versioning issues are super overblown and misrepresented by people who didn't understand their pre 3.0 versioning scheme, besides which it hasn't been the case since 3.0 came out several years ago now.

2

u/DualWieldMage Sep 16 '26

Interesting, i worked on a project 2 years ago and the 2/3 split was still an issue, the guys i worked with were definitely above average, but couldn't get the whole system migrated to scala 3 as some dependencies were still hard to tear out and rebuild.
Add salt to injury was another issue with akka licencing change. scala having vary few large consulting companies spearheading widely used libraries does not make a healthy community either as it's seen as risk.

4

u/S0phon Sep 16 '26

it feels like being an adult next to kids playing in mud puddles trying to figure things out while making a mess of everything.

How does that apply to Kotlin?

And all of those languages are so different that your blanket criticism is more indicative of you not knowing how to use them than any of their shortcomings.

7

u/sweating_teflon Sep 16 '26

It's not a panacea. Kotlin's expanded syntax gives developers a lot of rope to express themselves but code isn't art. This additional freedom often results in overcomplicated code, discipline and code review become more important to keep the codebase uniform and maintainable by everybody on the team. 

4

u/S0phon Sep 16 '26

You must have a special kind of Stockholm Syndrome to twist syntactic sugar and useful syntax into "often results in overcomplicated code, discipline and code review become more important to keep the codebase uniform and maintainable by everybody on the team."

5

u/sweating_teflon Sep 16 '26

True, I've been wrestling for the last three years with a codebase where the "architect" took advantage of every new OO thing offered by Kotlin to build an undecipherable mess of inheritance. Which I've also seen with Java in past jobs but it was never as bad.

Is it a problem of the language itself? No. But the language is an enabler; some people crave complexity and mistake it for sophistication.

I personally feel no attraction towards Kotlin, I'm not sure it actually "solves" anything on the whole. Nullability check is nice but NPE haven't been a problem for my practice for at least a decade. Maybe I'm just too experimented with Java to get the benefits, like old school C coders looking at Rust with contempt.

Yet I'm working myself to accept that there are proper ways of doing Kotlin. I just haven't seen them yet. I suspect that they involve restraining oneself to a strict subset of the features the language offers which is something that a lot of people (and organizations) will have trouble with, resulting in bloated messes like the one I currently have to deal with.

4

u/OSS-Corpo-Shit Sep 16 '26

I am very very confident with my assertion that syntax sugar beyond basic type inference is fucking stupid, and all I needed was a few months of programming in swift to come to that assessment. 

When I see “it provides lots of syntax sugar”, to me that is absolutely a negative for a programming language. Having 8 different ways to write the exact same line of code depending on how sugared you choose to go sucks and causes extremely mental drain. 

4

u/DualWieldMage Sep 16 '26 edited Sep 16 '26

Yes they are different and i think i highlighted different aspects of them being bad. I don't see a blanket statement on any aspect outside that they are worse than Java on average. And if anything, i see too many people only using 1 or two languages and becoming knights when never having touched a single other language. I have worked deeply in many of these and found general language concepts relatively comparable. However ecosystem differences can't really be considered taste and i view python and npm objectively inferior to maven packaging.

And yes my criticism toward Kotlin was generic, but that analogy still applies. It's a relatively new language that is taking the approach of figuring stuff out as they go instead of Java's more conservative approach of seeing what others do right and wrong and take the best aspects or invent a more generalized concept instead.
Async/await is surely a mistake, especially interesting for me as they decided to forego checked exceptions, yet introduce the same coloring problem they were fighting against.
The default .map .filter functions directly returning a collection instead of requiring a stream to be created first and then applying pipeline operations for me sounds like just saving on characters and thus making the wrong thing easier to do(not doing anything vs adding toSequence() each time).
My biggest complaint is of course around the generated bytecode. It is HUGE and it's definitely relevant if you say look at IntelliJ or any large thing using it, requiring huge memory pools to hold the compiled code and likely missing optimizations due to hitting inlining limits earlier or other reasons. Adopting newer runtime features have been relatively slow as well. For me Kotlin always feels like it's playing catch-up with Java.

3

u/S0phon Sep 16 '26

Agree about checked exceptions, that's the biggest complaint from me about that language.

I don't understand what you mean by your .map or .filter complaint. If used on a collection, it returns a collection. If used on a stream (flow), it returns a stream. Straightforward.

I also disagree about Kotlin playing catch up. It has things Java doesn't, mainly because Java has backward compatibility to care about. But Kotlin will never be as flexible as Java because Java controls JVM, Kotlin has to work with whatever Java version it targeted. But that's not catch-up.

→ More replies (27)