Java is one thing they did right. Most enterprises are looking to move away from Oracle. I think there will be niche cases where rewrites don’t make sense. But for one of the big telecom providers I work for - the decision was made in 2020 to move off of Oracle. It’s not a flash cut but we’ve significantly reduced reliance. There are some critical apps that are still on it, but those are capped in maintenance mode until their replacements are ready.
Java is in the best shape it's ever been in. Jdk development and performance are through the roof and the developer experiences gets better with every release.
Java's in great shape now, but the period between when Oracle bought Sun (~2010) and about 2017 wasn't great, and there was a lot of concern about Java's future. I think most people who moved away from Java then haven't looked back.
I believe that is mostly due to Sun's stagnation and lack of funding. Oracle released Java 7 in 2011 and Java 8 in 2014, which is arguably the start of modernizing Java.
I assumed it was Kotlin and/or Android. Oracle otherwise seemed fine to treat Java like IE6. It was only as alternatives (rise of Go, Rust, Clojure, etc) increasingly made the language look bad that really started to push development.
I don't think Oracle/OpenJdk really cares about Kotlin. It's usage is still minuscule compared to Java the language, and you're still using Java the platform by using it. I'm not sure they're really concerned about Rust either because it doesn't fill the same use cases. Go might be a concern, but who knows. I personally find Go the language to be worse then Java the language.
Pretty common attitude from folks who have never worked in one of the BigTech companies where Java rules (Amazon being a prime example). Since they never encounter Java in the "SF-style Startup" world, they assume that it must be dead. Meanwhile hundreds-of-thousands of Engineers deal with hundreds-of-millions (billions?) of lines of Java every day
My assumption is the poster wants to imply Oracle destroyed the good will and interest for people to start new Java projects after the licensing changes and subsequent shakedown. Java clearly still runs all over the place and will for a while (although plenty of people trying to keep java but get away from oracle).
The Java goodwill is mostly gone and I see zero new orgs trying it so while Java is still alive and well the mindshare has definitely been squandered given the capability that Java has.
Java is one of the giants and there are tons of existing and new projects that use it. Hotspot is the choice for high performance programs. Approaching its performance even with C++ requires a dedicated team of experts. Look at QuestDB, or Netflix, as current examples of projects choosing Java.
The languages that get a lot of airtime on HN like Rust, Go, and OCaml are way down in a tier of languages that get a lot of blog posts but enjoy relatively little traction in reality.
> Hotspot is the choice for high performance programs. Approaching its performance even with C++ requires a dedicated team of experts.
It's very surprising to hear you say this, as it's so contrary to my experience.
From the smallest programs (Computer Language Benchmarks Game) to pretty big programs (web browsers), from low-level programs (OS kernels) to high-level programs (GUI Applications), from short-lived programs (command-line utilities) to long-lived programs (database servers), it's hard to think of a single segment where even average Java programs will out-perform average C, C++, or Rust programs.
I hadn't heard of QuestDB before, but it sounds like it's written in zero-GC Java using manual memory management. That's pretty unusual for Java, and would require a team of experts to pull off, I'd think. It also sounds like it drops to C++ and Rust for performance-critical tasks.
It's a statement of my experience in the performance achieved in practice by real developers who lack dedicated language support teams. And even the ones who enjoy dedicated language support teams. I could point to gRPC. gRPC-Java is slapping gRPC-C++ sideways. Why is that? Because when a codebase is increasingly complex, the C-style lifetime management becomes too difficult for developers to ponder, and they revert to relying on the slower features of the language platform, like reference counting smart pointers.
I think hybrid implementations, where a project enjoys the beneficial aspects of the language runtime at large, but delegates small, critical functions to other languages, makes sense. That keeps the C, C++, or Rust stuff contained to boundaries that are ponderable and doesn't let those language platforms dictate the overall architecture of the program.
If gRPC overhead is critical to your system, you've probably already lost the plot on performance in your overall architecture.
You make a fair point about smart pointers, and median "modern C++" practices with STL data structures are unimpressive performance-wise compared to tuned custom data structures, but I can't imagine that idiomatic Java with GC overhead on top is any better.
The languages that get a lot of airtime on HN are the ones the young people will just use by default.
Hotspot is the current choice for high performance programs, but is Rust lower performance in some way or are the only downsides related to its younger age?
It’s perhaps useful look at what languages brand new projects are being started with rather than just looking at what languages large established companies like Netflix are choosing.
Rust is not inherently slower but then again neither are C and C++, but in practice all of those tend to be less efficient than realistic Java systems. Rust is displacing C in contexts where Rust's less than amazing performance are not noticeable in contrast to C's also-not-amazing level of performance. And I also think there is a cognitive bias under which a developer will reach for Rust to supplant a legacy C program, because that developer reflexively dislikes managed language runtimes.
Depends where you are, in startup world definitely yes. Elsewhere, not so much.
Companies couldn't care less about the underlying platform or language, they want reliability, stability and tons of easy to find people who can work with it from Day1. Java delivers all that, and will keep delivering for upcoming decades. Big businesses and big money love this (or hate the least out of IT stacks).
The fact of the matter is that you read through a lot of these start up blogs on how they scaled X technology to some amazing number like 1000 users a day or whatever. But your average Java Spring app on Postgres is doing some far heavier workloads.
Java's not gone anywhere, but it's been years since I've interviewed anyone who has made it their language of choice. Developer sentiment for it isn't exactly great.
A decade ago, a good ~80% of applicants chose to use it or C#.
I personally don't have any issues with working with it, but nobody's learning it outside of work.
On the other hand, it is quite easy to learn, so there's that going for it.
