↓Skip to main content

The Java Universe - Exploring how Java Evolves

·4 mins
DataVisualization JavaEvolution ScrollyTelling JavaUniverse
Stars of the Java Universe on the sky

Java isn’t just a programming language — it’s a living ecosystem that keeps evolving. But have you ever wondered how new features actually get into Java?

This post is a summary of my demo in the “Out of the Box Developer” podcast.

Why Understanding Java Evolution Matters #

If you’re working with Java, you will sooner or later hear terms like JDK, JEP, or JSR.

I didn’t know exactly what all these acronyms meant for a long time. Also, how you would explain the connection between these terms. Even further, how to make Java’s evolution visible. Which in the end helps you understand why these terms are very important for the Java ecosystem.

Understanding this process also helps you to stay updated with new features or avoid using outdated features.

So let’s simplify it.

How Java Actually Evolves #

Java doesn’t evolve randomly. There’s a structured, community-driven process behind it.

Key Concepts You Should Know #

  • JDK (Java Development Kit) A full Java release (like JDK 21, JDK 25)

  • JEP (Java Enhancement Proposal) A proposal for a new feature or improvement

  • JSR (Java Specification Request) Defines a Java specification that a version or release implements.

Every new Java version is not just a release. It is always connected to a specification, the platform JSR. With this connection, you know exactly what is inside.

The Big Shift: Faster Java Releases #

Before Java 10, versions were released less frequently. Now, there’s a 6-month release cycle.

Why does this matter?

Before, you had to wait until features have fully been implemented. Now, features can be previewed, tested, and improved based on community feedback before they’re getting final.

What changed: #

  • Faster innovation
  • Smaller, incremental updates
  • More experimental features

But this also means…

…not everything is final and can even be massively changed or even removed in later releases.

Understanding JEP Types #

Not all features are final. Some are stable, others are experimental.

1. Final Features #

  • Fully implemented
  • Safe for production

2. Preview Features #

  • Almost ready
  • Need feedback

3. Incubator Features #

  • Early-stage experiments
  • Can change or disappear

Here’s a key warning:

Igor: “If you want to use preview features, be aware. They can be discontinued, removed, or have breaking changes.”

So ask yourself: Should I really use this in production?

Features Take Time (Sometimes Years) #

One of the most surprising insights is that features don’t always fit into the 6-month cycle.

A feature can take longer than six months. It can span several JDK versions until it is finished.

Example: Vector API

  • Started years ago
  • Still in incubator stage

Bruno: “If something takes longer than six months, that’s fine. It will show up when it’s ready.”

This is actually a strength, not a weakness.

The Power of Community Feedback #

Java evolves with help from developers like you.

If something is a preview feature, they are waiting for feedback from the community.

You can:

  • Test preview features
  • Report issues
  • Share feedback

Even small contributions matter.

A New Way to See Java: The “JUniverse” Visualization #

I shared my idea of visualizing Java as a galaxy.

How it works: #

  • JDK versions = stars
  • JEPs = smaller stars around them
  • Connections = feature evolution across versions

Bruno: “Java is like a universe. It’s hard to visualize the things we use. This helps us see it.”

What you can learn from this: #

  • How features evolve over time
  • Which JDK has the most changes
  • How long features stay experimental
  • Relationships between features

Yugo: “I never realized how many things are implemented every year. It’s a huge effort from the community.”

Why Java Is So Stable (And Still Innovative) #

Java balances two things very well:

  • Stability
  • Innovation

Bruno: “Once something is added to Java, it’s almost impossible to remove. That’s why they take time to get it right.”

That’s why:

  • Old code still works
  • New features are carefully tested

Practical Advice for Developers #

Here’s how you can use this knowledge in your daily work:

Do This #

  • Follow LTS versions (like JDK 21, 25)
  • Experiment with preview features (in side projects)
  • Read JEP summaries before using features

Be Careful With #

  • Incubator APIs in production
  • Assuming features will stay unchanged
  • Ignoring release notes

Final Thoughts #

Java isn’t just evolving — it’s evolving carefully.

Thanks to its structured process, strong community, and feedback loops, it continues to improve without breaking what already works.

And tools like visualizations help us finally see that evolution clearly.

Bruno: “You’re making hidden information visible. That helps us understand and improve.”

What About You? #

How do you keep up with new Java features? Do you try preview features, or stick to LTS releases?

If you are interested in this topic more deeply, the “Out of the Box Developer” episode has even more insights from Thiago, Igor, Yugo and Bruno (who has the deepest knowledge on this process). To be found also on my channel.

But the best thing is to try it out yourself and play around, explore the Java Universe yourself.