Is Java Dead in 2026? Why Java Is Still So Popular, and What Comes Next

Every couple of years someone announces that Java is dead. Then they deploy their new service to a cloud running on Java, pay for it through a bank running on Java, and complain about it in a Slack thread.

Java turned 30 in 2025 and is still one of the most used languages in the world. Here is why, what our developers think of it and what comes next.

From a TV remote to the world's back office: a short history of Java

Java was not born to run banks. It was born to run gadgets.

In June 1991, James Gosling, Mike Sheridan and Patrick Naughton started a small project at Sun Microsystems, known internally as the Green Project (Computer History Museum). The plan was a language for consumer devices: set-top boxes, home appliances, interactive TV. The first version was called Oak, and on 2 September 1992 the team demonstrated it running on Star7, a handheld controller with a touch screen and a cartoon-style interface. It was, in effect, a very ambitious TV remote.

The TV industry was not ready. The internet was.

Renamed Java, the language was introduced at the SunWorld conference on 23 May 1995 (dev.java), with a promise every Java developer has heard a thousand times: write once, run anywhere. Java compiled to bytecode, and a Java Virtual Machine ran that bytecode on whatever hardware it found. Browsers ran applets, which most of us remember as the gray box that asked for a plugin update. Servers, it turned out, were where Java really belonged.

The rest of the story reads like a corporate thriller with a happy ending:

• the late 1990s and 2000s: Java 2 Enterprise Edition puts Java into the back office of banks, insurers and telcos, along with its famously verbose XML;
• November 2006: Sun begins releasing Java under the GPL, the start of OpenJDK (FSF);
• January 2010: Oracle completes its acquisition of Sun, and Java with it (phys.org);
• March 2014: Java 8 brings lambdas and streams, and becomes the version a large part of the world still runs;
• 2018: Java 10 starts the six-month release cadence, and the language begins to change faster than it had in a decade;
• September 2025: Java 25 ships in the year of Java's 30th birthday, which the release numbering makes look suspiciously planned.

Not bad for a remote control.

Why Java is still one of the most popular programming languages

Java does not have an easy life. Python developers make fun of its boilerplate. C programmers laugh at its class names. C++ developers hold it against Java that you cannot shoot yourself in the foot with manual memory management.

So is Java dead in 2026? Not by a long shot.

• It is 4th in the TIOBE index for September 2026, behind Python, C and C++ (TIOBE).
• 29.4% of developers in the Stack Overflow Developer Survey 2025 used Java in the past year (Stack Overflow).
• Java 21 is now the version developers use most, at 40%, ahead of Java 17 at 39% (JetBrains State of Java 2025). The ecosystem is moving forward, not standing still.

Why does it hold on? Above all, Java is a remarkably well-balanced language. It is fast enough for almost anything, easy enough to hire for, secure enough for banks and backed by an ecosystem that has an answer for most problems: Spring for web applications, Kafka for event streams, Hazelcast for in-memory data, and thousands of libraries in between. It also runs the planning software for missions to Mars at NASA (Maestro), which is a decent reference to have.

Underneath sits the idea that made Java famous. Code compiles to bytecode, the JVM runs it anywhere, and the JIT compiler turns the hot parts into machine code tuned to the actual workload. It is also a strongly typed, object-oriented language with C-style syntax, garbage collection and reflection, which is a very boring description of a combination that large companies find extremely comforting.

In short, Java's popularity rests on two things: an enormous community and ecosystem, and a mix of features that enterprises value more than novelty. Our Java applications examples show where it runs today, from banks and exchanges to Netflix and Minecraft.

Embracing modernity: what is new in Java, and what is coming

For years, Java's reputation was that it changed slowly, because the organizations running it upgrade slowly. The language itself stopped being slow a while ago.

How Java's release cadence changed

Until 2017, a new Java version arrived every few years, packed with features and waited for like a solar eclipse. Java 9 was the last release on that schedule. From Java 10 in March 2018, a new feature release ships every six months, in March and September, like clockwork.

In 2021 Mark Reinhold, chief architect of the Java Platform Group at Oracle, proposed shortening the time between long-term support releases from three years to two (Moving Java Forward Even Faster). It happened: Java 17, 21 and 25 are LTS releases, and Java 29 is next, planned for September 2027. Features that are not ready ship as previews, get feedback across several releases and become final only when they are right.

Highlights from Java 21 to Java 27

Virtual threads (JEP 444, Java 21) let a server handle a thread per request again, with plain blocking code, for services that spend most of their time waiting on databases and other services. Pattern matching for switch and record patterns (JEP 441, JEP 440) make data-oriented code much shorter:

sealed interface Shape permits Circle, Square {}
record Circle(double radius) implements Shape {}
record Square(double side) implements Shape {}

double area(Shape shape) {
    return switch (shape) {
        case Circle(double r) -> Math.PI * r * r;
        case Square(double s) -> s * s;
    };
}

Java 22 finalized the Foreign Function and Memory API (JEP 454), a safe replacement for JNI and for poking at off-heap memory. Java 25 finalized scoped values (JEP 506), a cleaner way to share request context than ThreadLocal, and compact source files (JEP 512). The latter finally answers the oldest joke about Java, the five-line Hello World:

void main() {
    IO.println("Hello, World!");
}

Senior developers will not write many programs like that. Students and people trying Java for the first time will, and a language needs a steady supply of both.

Under the hood, the runtime kept getting faster without anyone touching their code: compact object headers, faster garbage collectors and an ahead-of-time cache for startup. Our article on how Java enables high performance covers those in detail.

What happened to string templates?

If you read about Java 21 a few years ago, you may remember string templates, Java's answer to string interpolation with the slightly odd STR."Hello \{name}" syntax. They previewed twice, and then the third preview was withdrawn in 2024 (JEP 465) so the design could be reconsidered.

That is the preview process working as intended: a feature that is not right does not ship, even if it was announced. For a language that has to stay compatible for decades, that is a feature too.

What is coming next

JDK 28, due in March 2027, already has its first features lined up (OpenJDK):

• Value objects in preview (JEP 401), the first visible result of Project Valhalla: classes without identity, which the JVM can store and pass around like primitives.
• Structured concurrency, proposed to become final after seven previews (JEP 543).
• Ahead-of-time code compilation (JEP 544), which stores compiled native code from a training run so an application starts fast and warm.
• A simple JSON API in incubation (JEP 540), and generational mode by default for the Shenandoah collector (JEP 535).

Value objects are the one Java developers have waited for the longest. In the JEP's own example, two records with the same values become simply equal:

value record Point(int x, int y) {}

Point p = new Point(17, 3);
boolean same = new Point(17, 3) == p;   // true: value objects have no identity

Structured concurrency, meanwhile, treats a group of concurrent tasks as one unit of work, so that errors and cancellation behave the way you would expect:

Response handle() throws ExecutionException, InterruptedException {
    try (var scope = StructuredTaskScope.open()) {
        Subtask<String> user = scope.fork(() -> findUser());
        Subtask<Integer> order = scope.fork(() -> fetchOrder());

        scope.join();   // join subtasks, propagating exceptions

        return new Response(user.get(), order.get());
    }
}

Why is Java so popular today? Senior developers' insights

So we know why companies choose Java. But do developers actually enjoy working with it? What drives them up the wall?

We asked some of our most experienced senior developers for their honest opinions about the language they have spent many thousands of hours with. Here is the short version, then the long one.

What makes Java great?

Great versatility

Java is a bit of a jack of all trades. It will not break performance records against hand-tuned C++, and Python has the larger toolbox for data science and AI experiments. But overall it is remarkably well balanced: powerful enough for most projects, easy enough to work with, and backed by libraries and frameworks that make a developer's job much easier.

Active developer community

A large share of what makes Java productive comes from its community: libraries, frameworks and tools that solve common problems so nobody has to reinvent them, from Spring to Kafka to Hazelcast. That means more reuse, less code to maintain and more time for the problems that are specific to your business.

Stability and a multitude of solutions developed by the community, much of it open source, is one of the key things I like about Java. These solutions provide a great sense of security and ensure that a situation when, for example, a component will stop working because the author of a library has stopped working on it, won't happen.

Artbob, Senior Java Developer, Stratoflow

Platform independence and the JIT compiler

Code written in Java runs on any platform with a JVM, and the just-in-time compiler turns the hot parts of the bytecode into optimized machine code while the application runs, using what it learns about the actual workload.

The great concept of bytecode makes it so you don't have to worry about the architecture of the computers you are coding for, and at the same time, the performance is the same or sometimes even better than languages compiled for a given platform, thanks to JIT.

Wojciech Gdela, Senior Java Developer, Stratoflow

Solid foundations

Java and the JVM have been in production for three decades. The teething problems were solved long ago, and the platform behaves predictably under load, which is exactly what you want from something that runs a ledger.

By this point, there is virtually no risk of unexpected problems arising due to something no one can explain. By now almost all bugs are due to errors in our software or libraries, and not the language or environment itself.

Artbob, Senior Java Developer, Stratoflow

The JVM has also become home to other languages, such as Kotlin and Scala, so teams can use a more specialized language for one part of a system while keeping a core written in Java years ago. FastPost, the accounting platform we developed for Legerity, processes a billion transactions in under an hour on the JVM (case study).

Encouraging developers to write cleaner code

Java nudges programmers toward readable code. Some call it pedantic. The move away from one-letter names and cryptic abbreviations, and the way memory management stays out of sight, let a codebase focus on the business logic, which in enterprise software is the part that matters most.

I like Java for making it easier and sometimes even forcing programmers to make the code they write readable and well laid out, making it easier for their colleagues to understand the entire code base.

Wojciech Gdela, Senior Java Developer, Stratoflow

It keeps getting better, without breaking your code

The newest reason to like Java is how it ages. Most languages make you choose between stability and progress. Java, lately, delivers both: a new release every six months, and code written for Java 8 that still runs on Java 27, apart from removed APIs and JDK internals.

For a team that means improvements arriving almost for free. Virtual threads made blocking code scale, records and pattern matching shortened everyday code, and each upgrade brings a faster garbage collector, a smaller memory footprint or quicker startup, usually without touching a line of business logic. Few platforms let a ten-year-old codebase get faster just by moving to the next release.

What do developers find most annoying about Java?

Of course, not everything about Java is loved. Here are the three things that bother our senior developers the most, and, since the interviews, how much modern Java has done about each.

Boilerplate code

No surprise at number one. Java's emphasis on explicitness and strong typing produces a lot of repetitive code: getters, setters, equals and hashCode, long type declarations, ceremony around exceptions and resources.

In a lot of situations, simple things require writing a lot of code. There are also long class names which often make things hard to read and understand. That's the two main things I dislike about Java.

Martyna Szczepańska, Senior Java Developer, Stratoflow

Here, modern Java has genuinely listened. Records replace whole classes of data-carrying boilerplate, var removes repeated type names, text blocks end string concatenation for SQL and JSON, and compact source files shrink the smallest programs. The long class names are, admittedly, still a cultural choice.

Dependency hell

Another senior developer pointed to dependencies, a problem JavaScript developers know only too well. Transitive dependencies, version conflicts and libraries that change behavior between versions can make a large codebase hard to reason about. When one library needs an urgent security update, it can drag half the project along with it.

I would say that the so-called dependency hell is one of the most annoying aspects of Java. In more complex projects, there can be so many dependencies on external libraries that they sometimes affect each other, which can lead to unexpected and undesirable outcomes that devs might not even be aware of.

Artbob, Senior Java Developer, Stratoflow

No language feature fixes this one. Bills of materials, regular small updates and dependency scanning in the build keep it manageable; leaving dependencies untouched for five years makes it much worse.

Complicated generics

Generics let you write type-safe code that works with different types, and simple generics are fine. The corner cases are another matter: wildcards such as ? extends and ? super, and generics nested inside generics, can confuse even seasoned Java developers.

Simple generics are alright, but some of the corner cases are really quite hard to grasp. It's hard to figure out things like how there's a generic in a generic and how it's passed to a generic method that would also like to allow subclasses of that generic.

Wojciech Gdela, Senior Java Developer, Stratoflow

This one is mostly unchanged. Generics are as powerful, and as tricky, as they were.

Will Java remain popular?

How many times have we read that Java is about to share the fate of COBOL and fade into obscurity? One of our developers has been hearing it for a while:

I first heard questions about Java's demise even before 2010, when Clojure appeared. Since then, every now and then a new language comes along that is supposed to "completely transform the IT market," and yet these promises never materialize.

Artbob, Senior Java Developer, Stratoflow

The difference between Java and COBOL is that Java kept moving. Its systems are not museum pieces: Java runs many of the systems that cannot fail, from core banking, payments and insurance to airline and hotel search, logistics and the back ends of consumer platforms with hundreds of millions of users. And every six months the platform under those systems gets faster, safer and more pleasant to write. A language with the oldest installed base and one of the fastest release cadences is not on its way out.

The real gap is between Java and the Java people actually run. In JetBrains' 2025 survey, 31% of Java developers still work with Java 8 regularly (State of Java 2025), a release from 2014. The JDK itself can still be patched: Temurin 8 gets updates until at least 2030. The frameworks on top of it cannot, at least not for free: Spring Framework 5.3 left open-source support in August 2024.

That is why the next big wave in the Java world is not a new language. It is Java modernization: moving systems from Java 8 and 11 to a current LTS, with Spring and the rest of the stack upgraded along the way. It is usually far less work than people fear. We moved an online wine merchant's store and back office from Java 17 to Java 25 in about four weeks, without a feature freeze (case study), and our guide to legacy software systems covers what to watch out for on the way.

So, like it or not, Java will be with us for a long time. Perhaps the best summary of every rumor about its imminent death comes from Mark Twain:

The report of my death was an exaggeration.

Mark Twain

If your Java systems are a few releases behind, our application modernization team maps the versions and dependencies first, gives you a written ballpark, then upgrades the system in tested steps while your team keeps shipping.