Why? The JVM is awesome. Or are you just trying to be an edgelord with that hot take?

Maybe he means in browser Java Applets. But they are pretty much dead anyways.

They aren't supported in Java 9.

Yes they are. They're deprecated, but not gone.

Not that it much matters, since Chrome doesn't support the NPAPI plugin, and FireFox is expected to drop support early in the new year, leaving Applets an essentially IE only thing.

Hopefully Java WebStart doesn't go anytime soon, I still rely on that for OOB management on my servers without needing to boot Windows and use IE + the .Net consoles.

Java Webstart is the official way for applet alternatives, according to the Java blog.

And in Java, anything deprecated is never really removed.

Not paying attention to the JEPs?

http://openjdk.java.net/jeps/277

There was a session at Java ONE about a set of API that will be gone in Java 10 after this gets introduced in Java 9.

Good. It was one thing we always disabled in our deployment of JRE. One less vulnerable entry point for those who needed it on their workstations.

The JVM is great, Java, not so much. At least we have Clojure, Scala, Groovy and Kotlin.

Those languages complement Java on the JVM to varying degrees. Kotlin and Scala were built to progressively replace Java in a codebase. Clojure was built for the JVM as its first target architecture. Apache Groovy was originally to script Java code, e.g. tests and glue code. (Although Groovy was later repurposed as a Java replacement in Groovy 2, not many people use it for that.)

Agree with your assessment of Groovy. It made the JVM easy to use for simple scripting and served a really good purpose as glue language between big monolithic JVM software systems.

I haven't used it for awhile now, but I used to work on a serious Groovy code base. It's out of it's league now. Once Kotlin's scripting story gets rolling it should eat the rest of Groovy's lunch.

It is unnecessarily resource hungry.

There was an article the other day on HN about Golang compiler and work on its GC. (Garbage Collection)

As the article goes on, it becomes clear that a modern GC managed system is no simple thing. As you start to add all the choices and tuning you end up re-inventing the JVM runtime.

Any program of sufficient complexity eventually ends up having GC.

Java may be too resource hungry for trivial programs. For large programs Java is an industrial strength runtime platform. Or I should say the JVM is. You don't have to use the Java language. You can use a number of languages that compile to JVM bytecode.

How so?

Well you can certainly hope but the problem is a lot of backend systems and software is written in Java. This software cost a lot and also make a lot of money for companies. End users/ consumers do not interact with this software so there is even less motivation to replace that.

Java (or the JVM) is the Cobol of the 21st century. There is such a large amount of software written for it, representing such a large economic investment, that it won't be replaced anytime soon. That is the reason Cobol is _still_ around. It's why Java will be around for a long time.

Exactly my thoughts. Replacement, if any, would be in form of older institutions/companies themselves get replaced by new generation e-commerce/financial services/banks etc.

We need a billionaire to buy it, shut it down, and then sue everyone in to the ground who tries to fork it.

I would say Java is more comparable to C++. Language-wise the syntax of the two is similar, they came from around the same generation of languages, and they both have a prolific community and ginormous codebases. Also similar to C++, there are MANY different implementations and flavors, even entire languages built on the Java VM. By this measure no languages come close to C++ and Java.

While some new languages have prettier syntax and interesting constructs, Java remains a viable platform despite it's warts. I would guess more production code today (even new) is still written in Java or c++ than anything else.

Java gets a lot of flak around here but its really not so bad when you use modern versions (JDK 8) with modern libraries (Apache Commons or Guava). Even Eclipse is surprisingly good now, defying my expectations years ago that it would remain buggy and hard to use forever. I learned Java in the last year and it's now my favorite language besides c#.

Eclipse (and other modern IDEs) is the killer feature that most other languages don't have. (With the notable exception of C# and Visual Studio as the counterparts to Java / Eclipse.)

A large code base written in a language that does not have tooling to do automatic refactoring cannot be maintained for as long a time. Gets scrapped sooner and rewritten. Especially in dynamic languages. A dynamic language may be much faster to prototype and get your initial code base written. But just try maintaining it for ten years. Twenty. Etc.

What replacement do you have in your mind?

why?

The eradication of your "toy" languages will happen far sooner than Java.