Sure, JDK 21 adds support for some much-needed quality of life features: sequenced collections, records, switch pattern matching, code snippets. But all of these features have been supported for YEARS in other languages that I've enjoyed: C#, Kotlin, Python. Java doesn't have anything as slick as LINQ (C#) or list interpretations (Python) for succinct map-reducing objects; Stream API is what you're forced to use, and it's clunky by comparison.
We write financial trading systems which require lowish latency (but not truly low latency) with rock solid stability, monitoring, tooling, etc.
We actually write idiotmatic Java in the sense we don't actually use object pooling etc. We have five 9s latency at below 500 micros. Which people in the industy will know is very much not low latency HFT style, but is enough for our competitive edge. And as I said, we can achieve this while still relying on idiomatic Java, which means we spend most of our time writing feature code rather than fighting the language. And by idiomatic Java I mean the right style for the right part of the code. We mostly write data oriented code, which low touch records/pojos and business logic outside of objects, but there are cases where we're more traditional OO style.
I have ex-colleagues who have moved elsewhere who use non-idiomatic java to achieve < 5 micros fastpath. That was several years ago, they may have improved that into the nanos now.
The online programming sub-culture loves to hate Java, because humans love being part of a fashionable in-group, and it is extremely fashionable to hate Java. Luckily, very smart people don't care about that nonsense and I get to work with a lot of those people.
Summary: I don't know if the stats show Java is in decline, but I doubt it. I still get many high salary job pitches from headhunters monthly.
I'm using Java with Quarkus for an enterprise app for the past 2 years as the project lead and I couldn't be any happier with my decision. We're upgrading to Java 21 in a week or two. The code we're producing is some of the most boring/straightforward code I've seen in a long time. Nearly all of our time is spent solving the business problem and the language never gets in the way. The dev experience is outstanding. With Quarkus we get nearly instant hot reloading. IntelliJ provides industry leading IDE. Oracle keeps releasing major enhancements to usability. Excellent ecosystem, testing frameworks, etc. It's hard to find any faults really. Yeah NULL is allowed in the language, but I cannot remember the last time we had a NPE.
The increase in Python tells you that its niche is increasing. It is, among other things, the language of data science and machine learning, which has a huge upswing lately. But that doesn't affect the absolute number of Java or C projects or jobs. It just tells you that a new thing is appearing.
If there is a chance in Java's utility, you see it more in C++ and C#, which occupy more similar niches. It's notable that C# is picking up; that's a trend that might be worth noting. And it's a bit puzzling that Java should fall below C++, and I suspect it has more to do with the vagaries of the metric.
But Java is for general-purpose programming, and that niche doesn't seem to be going away any time soon. If you want to get into data science, then by all means go learn Python. But that's less about picking up a new tool set as a change in careers.
#01 Python #02 C #03 C++ #04 Java #05 C# #06 JavaScript #07 Visual Basic #08 PHP #09 SQL #10 Assembly Language
IMO the fact that Visual Basic is in the Tiobe Top 10 at all is kinda sus, so it's probably worth also taking a look at the Stack Overflow 2023 Developer Survey results ( https://survey.stackoverflow.co/2023/#professional-developer... ):
#01 JavaScript #02 HTML/CSS #03 Python #04 SQL #05 TypeScript #06 Bash/Shell (all shells) #07 Java #08 C# #09 C++ #10 C
Indeed it's not fancy as "new" techs like Go or Rust and I agree it's ckuncky and verbose, but there are plenty new features and applications for modern Java.
Yes.
Take a look at the graph: https://www.tiobe.com/tiobe-index/java/
Java's original strengths were:
1) "write once, run anywhere": a huge improvement over the platform-dependent C / C++ that was widely used at the time,
2) easier to learn and safe replacement over C++ for many problem domains: finding / growing good C++ talent has always been a challenge
3) large, powerful standard library and massive third-party ecosystem: it made development rapid and much more like building with Legos than rolling your own libraries like many C / C++ shops did
Java's killer use case became backend and middle-tier enterprise software.
Today Java's strengths are less relevant:
1) You can "write once, run anywhere" with containers, Go (easier deployments over Java, lower resource usage compared to Java, easier to learn than Java), or Rust (easier deployments over Java, far lower resource usage compared to Java, harder to learn than Java, more performant than Java).
2) Java never fully displaced C++ for high-performance domains. Go and Rust are solid competitors to both Java and C++ depending on the problem domain.
3) Go and Rust both have wide adoption and third-party ecosystems that compete against Java's ecosystem.
I say this as someone who wrote Java enterprise software for many years. I don't hate Java. It has been very useful and paid my bills for years.
Java is not going away. There is FAR too much software written in Java and enterprises will keep on maintaining legacy software until they choose not to. Java 8 will probably go on for decades as long as someone keeps patching it and selling support. Java will slowly become another COBOL.
>> Was it caused by all that Oracle bullshit in recent years?
Partially.
Breaking changes in how the JDK / JRE worked between Java 8 and Java 9 were a contributing factor.
Oracle's licensing changes caused many enterprises to flee to alternative OpenJDK distributions, effectively causing some mindset fragmentation and encouraged enterprises and developers to look at alternatives.
I'm still using Java and improvements in it continue, and like COBOL it won't die completely, but there is a good argument for looking elsewhere for new projects especially long-lived infrastructure.
NoItIsNotInDeclineDueToItBeingAbleToBeWrittenOnceAndBeingAbleToRunEverywhere