Java is dead: Long live Java!

In a fast-paced tech landscape where languages rise and fall across hype cycles, Java breaks the pattern as it reaches a remarkable milestone: its 30th anniversary. Java remains an uncontested leader in enterprise adoption and developer popularity. The large workforce reflects the language’s high popularity ranking, year after year, as demonstrated in a roundup of recent research by Itransition, the Top 14 most in-demand programming languages. 

Used at scale across industry sectors, Java’s future is promising, especially as it now also serves as a foundation for AI Innovation. I reached out to several different tech leaders to better understand the reasons behind the long-lasting enterprise success of Java. My goal was also to present expert recommendations regarding compliance and trust in AI-driven innovation, performance, stability and more lessons that make this language, born in the ’90s, the choice of winning enterprises. 

The hearts and minds of the community 

The drive behind this article deserves special mention, echoes an inspiring community event and brings exclusive insights from the authors and event speakers. The quotes featured throughout this article were shared during sessions at the Java 30Y Celebration Week, a free, global, virtual event and community celebration held June 16-20, 2025. 

Organized by SouJava, with community support from Aletyx and Jakarta EE (the Java Enterprise specifications on Java and part of Eclipse Foundation), the event showcases the power of shared dedication of community developers, Java Champions and thought leaders: More than 30 hours of freely available content reached tens of thousands of developers interested in hearing from an impressive line up of 25+ international speakers. 

“Java is not just a technology. Java is a community that builds the future of technology.” —Bruno Souza, founder of SouJava, Java Champion and global advocate for developer careers since 1995 

Sessions ranged from in-depth explanations and live demonstrations of the latest and greatest features on the Java space, including such topics as: 

• Evolution and lessons of the 30 years of Java 
• Performance, observability and scalability 
• GraalVM 
• Java certification 
• Jakarta Data and the latest release of Jakarta EE 
• Domain-driven design 
• …and much more. 

Additionally, the event featured remarkable sessions on Java-based intelligent solutions, including the application of GenAI, Symbolic AI, Hybrid AI architecture and retrieval augmented generation (RAG) using popular runtimes such as Quarkus, Spring Boot and Payara, and AI tools such as Langchain4J and MCP. Developers also learned in-depth details about vector databases such as Redis and Weaviate, and the best ways to use them to adopt AI in Java-based services. To learn more, peruse the full list of event details and sessions. 

Java is dead…or so they said 

Three years after its first release, a strong declaration about Java shook the tech space. It was August 1998 when Linus Torvalds, the creator of Linux, stated, “Java is dead” during an interview with SunWorld. This prediction proved spectacularly wrong, but not for obvious reasons. 

Not expecting the upcoming market shift, Torvalds buried Java based on its ability to thrive through the so-called “desktop wars.” However, a paradigm shift occurred, paving the way to Java’s success: From desktop to server-client model and, later, to the cloud computing model we know today. 

In the years that followed, many have predicted Java’s death. Yet, just like Torvalds, all missed the mark, as reflected on the words of Barry Burd, Java Champion, professor of computer science at Drew University, author of multiple books including “Java For Dummies” and co-lead of Garden State JUG and New York JavaSIG, said: “I’ve seen Java outlive predictions, outlive trends and outlast every obituary written about it.” 

“Java grew with me. It wasn’t just a phase of my life — it was my career.” Burd continues to share his view on the resilience of the technology: “I still write Java code. And I love the fact that the code I wrote 10 or 15 years ago still runs. That’s not nostalgia. That’s engineering.” 

Java opened space for enterprises to create stable, portable applications with high scalability. Additionally, maintainability is highly valued, as it’s a fundamental characteristic of long-lived software solutions. “The reason why Java survived all these years is that it’s used to solve real-world problems. That’s why enterprises trust it.”, says Bruno Souza. 

Jakarta EE: The enterprise foundation for Java innovation 

What makes the evolution of enterprise Java unique is how the innovation happens. Any discussion of the use of Java in enterprise software is inevitably going to include Jakarta EE, the cornerstone platform that drives the ecosystem and nurtures enterprise adoption. 

Transitioned from Oracle to the Eclipse Foundation, Java EE, now called Jakarta EE, is a platform governed by Eclipse Foundation. Its stewardship and open governance allow the platform to progress without vendor lock-in. Standing on the shoulders of giants, Jakarta EE is collaboratively shaped by a large community of users, core contributors and vendors. 

We asked Tanja Obradovic, Jakarta EE program manager at Eclipse Foundation, for insights tech leaders should know about how the platform balances innovation with enterprise stability. He offered the following six key strategies and their respective impacts: 

1. Code-first approach. Shifting to “code-first,” Jakarta EE prioritizes hands-on coding and proof-of-concept implementations. This allows for quicker validation of ideas, real-world feedback and reduced risk before formal standardization. For example, Jakarta Data’s design was informed by the proven Spring Data JPA. 
2. Open governance and community-driven evolution. Under the Eclipse Foundation, a vendor-neutral model fosters collaboration and leverages broad community input for new features. Transparent processes ensure consensus and stable development. 
3. Standardized APIs and modular profiles. A strong core of standardized APIs ensures portability and long-term viability. Modular profiles (Full, Web, Core) allow enterprises to adopt only necessary components, facilitating innovation in lighter, more agile architectures (e.g., Core for microservices) without compromising the core platform’s stability. New specifications (like Jakarta Data) and enhancements align with modern trends. 
4. Strategic release cadence and versioning. A predictable two-year release cycle helps planning, balancing updates with stability. Clear version compatibility policies and a deprecation process minimize disruption, giving time for adaptation. 
5. Alignment with Java SE LTS. Jakarta EE releases often align with Java SE Long-Term Support versions (e.g., Jakarta EE 11 with Java 17/21), leveraging the underlying Java platform’s stability for critical systems. 
6. Emphasis on compatibility and certification: Rigorous Test Compatibility Kits (TCKs) ensure consistent behavior across diverse vendor implementations, guaranteeing application portability and reliability. Multiple certified implementations reduce vendor lock-in and enhance platform stability. 

Looking ahead and on the topic of artificial intelligence, Jakarta EE is also exploring strategic ways to support AI innovation in enterprise systems. Rather than building AI engines directly into the platform, the focus is on enabling standards for integrating external AI services and improving developer productivity with AI-powered tooling. As Obradovic explains, “Jakarta EE is exploring how to strategically integrate AI into the enterprise Java ecosystem by focusing on standardization for AI service integration, rather than building AI models directly.” This includes support for modern architectures such as RAG, use of vector databases and leveraging specifications like Jakarta Data. 

In addition to the strategies adopted by Java, Michael Redlich, Java Champion, InfoQ Java editor and developer advocate at Payara with more than 25 years of community involvement, shared that “Java’s longevity isn’t magic. It is governance, compatibility and a culture of backward support. One of the amazing things about Java is that even J2EE applications, written in the early 2000s, are still running today with very little change.” 

At the event, Redlich showed the upcoming features of Jakarta EE 11, released days after the celebration, and Jakarta EE 12, covering better cloud integration, simplified APIs and better support for language features. 

Pragmatism permeates the Java space, and experts’ perception is that it’s more than just a language; it’s an approach to enterprise technology that balances community-driven innovation with commercial support and stability. 

Community-driven innovation at scale 

With a workforce of millions of developers around the world, the industry’s adoption scale increases without barriers. To be fair, the word “workforce” isn’t enough, as Java developers actively engage with communities. Found on almost every continent, and hosting meet-ups regularly, the Java User Groups (JUGs) are volunteer organizations enabling developers to connect, share knowledge, learn and collaborate with others. 

Personal and professional growth acceleration coming from community involvement reaches all levels, from beginners to experts: 

“I had never been to a Java user group at the time, and I found out about the New York Java SIG and went to one of their meetings. And I was astounded — astounded — at how much I did not know. It was like, why have I not gone to these before? It was a revelation. It was like, I’ve got to keep going to these. I’ve been missing so much by not being a part of the community,” reflects Burd. 

This community model creates a feedback loop between enterprises using Java and developers evolving it. Unlike vendor-driven platforms, where roadmaps reflect product strategies, Java’s evolution reflects actual enterprise needs. 

AI beyond LLMs: Enterprise compliance in intelligent Java solutions 

Java’s approach to AI implementation offers compelling advantages for enterprise deployments, particularly around compliance and trust. 

Alex Porcelli, co-founder of Aletyx, seasoned architect and open-source leader behind Drools, jBPM and Kogito, shared an approach for architecting intelligent solutions that maintains the trust and confidence highly sought by CIOs. The architecture discussed gains traction among financial services firms, and it allows the creation of AI solutions using a hybrid architecture pattern. Rather than relying solely on large language models (LLMs) and statistical AI, the answer relies on combining these AI branches with symbolic reasoning. 

In his presentation, he demonstrated how to bring trust to GenAI solutions, using the industry’s trusted Java technology, Drools. The result: AI systems that can both innovate and explain their decisions to regulators. 

“Hybrid architectures, LLMs plus rules, are not just academic. They’re what regulated industries need to move forward with GenAI,” said Porcelli. He continued by reinforcing Java’s role in explainability: “Symbolic AI is not a relic, it’s the backbone of explainability, and Java is the best ecosystem to implement it.” 

Executives share concerns with AI hallucination and see the usage of guardrails as a way to overcome this challenge. In regard to trust and governance challenges, in “Kiwis embrace AI at work, but trust and governance pose challenges,” Cowan Pettigrew, KPMG New Zealand chief digital officer, said that “Having guardrails in place allows our people to give AI tools a go safe in the knowledge that our data is protected.” 

Such inability to deliver predictability impacts compliance consistency and holds back AI innovation. The answer for an enterprise-grade trust when delivering on this goal is to rely on guardrails and ensure AI will not hallucinate when making decisions that can affect real people and businesses. 

“Java is too slow and heavy”: Debunking myths of modern Java 

Significant cost reduction with cloud and infrastructure resources has become a matter of choice for Java applications. In her session, Alina Yurenko, developer advocate for GraalVM at Oracle and an expert in native image performance, demonstrated significant performance and resource consumption optimization to a point where it could represent the ability to run 5-10x more application instances on the same infrastructure. Before delving into additional performance insights, it’s crucial to have in mind the core piece associated with Java’s ability to run fast and at scale across multiple types of infrastructures: the Java Virtual Machine (JVM). Created to offer the ability to “write once, run everywhere,” the JVM also serves as a security layer and has evolved and been enhanced to optimize code execution. 

On a high level, there are two key mechanisms Java architects consider when making decisions around JVMs concerning application performance: just-in-time (JIT) compiler versus ahead-of-time (AOT) compilation. The decision is made based on the application’s purpose and desired metrics such as build time, start-up and warm-up time, peak performance, garbage collection, throughput, latency and others. 

With JIT, peak performance is achieved with ongoing optimizations made during runtime using sophisticated mechanisms of enhancement based on usage patterns. In contrast, the AOT compiler is based on anticipating code compilation to earlier stages. Reducing start-up time and runtime overhead, pre-compilation at build time optionally offers the ability to create applications to natively execute on a specific environment (e.g., executable on Windows, Linux, etc). 

In summary, the evolution of the JVM unlocked flexibility for enterprise architects to shape solutions that deliver on their business expectations, with both JIT and AOT mechanisms having different trade-offs and applications. JIT is a commonly used mechanism of JVMs such as OpenJDK, Amazon Corretto and Oracle JDK. In parallel, Oracle GraalVM emerges as a game-changer that brings enterprise-ready AOT compilation to Java, allowing architects to choose the right approach for each use case: JIT for maximum throughput in long-running services, or AOT for rapid scaling and cost-efficient deployments. 

In a production demonstration, Yurenko proved these benefits are real and achievable today. She demonstrates the results of using GraalVM with a standard Spring Boot application, with a native image achieving startup times of 143 milliseconds (vs 2.5 seconds with JIT), CPU usage of just 1-2% and memory consumption around 140MB. Technology leaders can see this as a representation of the ability to run 5-10x more application instances on the same infrastructure, eliminate cold starts in serverless deployments and significantly reduce cloud costs — all while keeping your existing Java expertise and ecosystem. 

Java applications can now start in milliseconds and consume memory comparable to Go or Rust applications, as Yurenko states: “Native image was very often compared to Go and Rust in terms of memory consumption and startup. And we’re doing pretty well. And every single release gets better and better and better.” She moved on to share a positive trend on performance improvements: “With every release, with every new Java version, we see a huge improvement in performance. The numbers from Java 24 and 25 are very, very encouraging.” 

The claims that “Java is slow” or “Java is too heavy for the cloud” are therefore debunked. Cloud-native microservices became mainstream. Aligned with Oracle GraalVM, and alongside the popular Spring Boot, the revolutionary Red Hat Quarkus profoundly enhanced developers’ experience with groundbreaking hot-reload features for Java code and developer tools for productivity. 

Eric Deandrea, Java Champion, Red Hat developer advocate and author of “Quarkus for Spring Developers,” also highlighted the simplicity of building AI-powered applications with Quarkus: “If you never played with the Quarkus extension, it’s really simple to define an AI service.” He further emphasizes that Quarkus accelerates and simplifies development while relying on the open-source framework: “This is specific to Quarkus, but it’s using just upstream Langchain4J.” 

These insights from Deandrea reinforce how Quarkus not only delivers on performance promises but also significantly enhances the developer experience, making it easier than ever to build modern, cloud-native Java applications with cutting-edge features like AI integration and reactive programming. 

Key takeaways for technology leaders 

As enterprises continue to navigate Java’s evolving landscape, one thing is clear: three decades later, Java is indispensable for the world of enterprise software development and will continue to shape enterprise innovation for the years to come. 

Three strategic considerations for technology executives emerged from the community event: 

1. Java’s focus on strategically integrating AI into enterprise solutions through standards, reusable core capabilities and enterprise architectural design 

• Optimized approaches to RAG adoption rely on both the code and database layers and take the user experience with GenAI to the next level. 
• The combination of Symbolic AI with GenAI unlocks guardrails for a safe Agentic AI adoption; Architectural definitions for AI, can combine different branches of AI into a hybrid intelligence that unlocks innovation without the concern CIOs share regarding trust in AI decision making. For regulated industries, this hybrid approach offers a path to AI adoption without compromising compliance. 

2. Remarkable improvements are observed in terms of Java’s performance, cloud fit and data management 

• GraalVM and virtual threads eliminate many traditional Java limitations, making it viable for use cases previously dominated by systems languages or newer platforms. It enables native executable Java services, with incredible start-up times, to run on multiple platforms and smoothly run within a serverless architecture and the popular low-cost approach of scale-down-to-zero, which reduces consumption of cloud resources for services not being used, while readily offering it when necessary, while upscaling and downscaling to match increasing user traffic. 
• Faster development cycles, with reduced risk of errors on the implementation of business requirements, are made possible through the adoption of different elements, each solving a different problem: best practices, specifications and open standards. With a correct implementation of Domain-driven design practices, teams can work closely together, with effective communication that allows delivering faster and more accurate solutions to the business problems. In this same idea, open standards such as decision model and notation give business users the power to use business-friendly language to author advanced, complex decisions and rules, that at the same time, are naturally handled by the technical teams as it works with technologies they are used to working with. 
• The complexity of the choice between the way data will be stored was greatly simplified by the recently released Jakarta Data, as it creates an abstraction layer for the different paradigms of SQL and NoSQL, allowing for greater decoupling between the data and other layers of an application. Bringing known syntax and semantics, it has reduced impact for adoption and a low learning curve, while greatly enhancing the code quality, long-term maintenance and increasing flexibility on the choice between different solutions and vendors. 

3. Enterprise-grade technology is an innate characteristic of Java 

• Java’s community governance model provides unusual stability for long-term planning. Unlike platforms subject to vendor priorities or startup pivots, Java’s direction reflects collective enterprise needs. This predictability matters when making decade-long technology commitments. 

The question for technology leaders isn’t whether Java can handle future requirements. The evidence suggests it will adapt as it always has. The question is whether other platforms can match Java’s unique combination of innovation, stability and enterprise-grade maturity. 

That’s a bet many technology leaders continue to make, 30 years later. 

The views expressed in this article are personal and do not represent the authors’ employers. 

This article is published as part of the Foundry Expert Contributor Network.
Want to join?