← Table of Contents

Java / 2 of 6 / 22 views

History and Evolution of Java

From Oak to Modern Java: The History and Evolution of Java

Java was not originally created for websites, Android phones, or enterprise servers. It began as an experiment for consumer electronics—and then evolved into one of the longest-lived software platforms in modern computing.

Java has existed for more than three decades. During that time, the technology industry changed dramatically:

desktop computers became mainstream;
the World Wide Web appeared;
mobile devices transformed everyday life;
cloud computing changed how applications are deployed;
software development became increasingly open and collaborative.

Many programming languages rose and disappeared during the same period. Java survived because it continued to evolve without completely abandoning the programs and developers that already depended on it.

This article follows that journey, from the early Green Project and a language called Oak, through Java's first public release, the rise and decline of browser applets, the creation of OpenJDK, and the modern six-month release model.

Previous: Getting Started with Java: A Language That's Still Relevant Today

Current: History and Evolution of Java

Next: Core Features of Java

Learning Goals

After completing this article, you should be able to:

explain why the Green Project was created;
describe how Oak became Java;
understand why the growth of the web changed Java's direction;
identify the most important stages in Java's development;
explain how OpenJDK changed Java development;
distinguish Java's old release model from its modern six-month cycle;
understand why LTS releases matter;
explain how Java balances evolution with compatibility.

1. The Problem That Started Java

To understand Java's history, we first need to return to the early 1990s.

At that time, consumer-electronic devices were becoming more advanced. Companies were imagining interactive televisions, set-top boxes, handheld controllers, and other smart devices.

The problem was that these devices could use different processors and operating systems.

Software written for one device might not work on another.

A development team could therefore face a situation like this:

Application for Device A
        │
        ├── must be rewritten for Device B
        ├── must be rewritten again for Device C
        └── must be maintained separately on every platform

This was expensive, slow, and difficult to maintain.

Sun Microsystems formed a small research team to investigate a better approach. The effort became known as the Green Project.

The team's goal was not simply to invent another programming language. It wanted to create a software environment that could operate across different types of consumer hardware.

That requirement would later become one of Java's defining ideas:

Software should not be permanently tied to one type of machine.

2. The Green Project

The Green Project began at Sun Microsystems in 1991.

The core team included:

James Gosling;
Patrick Naughton;
Mike Sheridan.

James Gosling became the person most strongly associated with the language's design and is often described as the father of Java.

The team worked somewhat independently from Sun's normal product groups. It explored how future electronic devices might communicate, display information, and run interactive software.

One of the project's experimental devices was a handheld controller associated with a prototype environment called Star7.

The device itself did not become a mass-market product, but the research exposed an important problem:

Future devices would be diverse,
but developers needed a consistent way
to build software for them.

Existing languages did not completely satisfy the team's goals.

C and C++ offered power and performance, but software written with them could depend heavily on:

processor architecture;
operating-system details;
memory layout;
compiler behavior;
platform-specific libraries.

The Green team wanted something safer and more portable.

3. Before Java, There Was Oak

The programming language created inside the Green Project was originally called Oak.

According to the early Java Language Specification, Oak was designed for embedded consumer-electronic applications before the project moved toward the internet. This origin is documented in the preface to the first edition of the Java Language Specification.

Why Create a New Language?

The team initially explored using C++, but it found that the language carried complexity that was not ideal for its target environment.

Oak was designed with several practical goals:

simpler than C++;
portable across different hardware;
safer for software downloaded or installed on devices;
able to manage memory automatically;
suitable for network-connected systems;
resistant to common low-level programming errors.

The language borrowed familiar syntax from C and C++, but it deliberately avoided several of their more dangerous or complicated features.

For example, ordinary Oak programs would not rely on direct pointer arithmetic or manual memory release in the same way as C and C++ programs.

Why the Name “Oak”?

The name Oak is commonly associated with an oak tree visible near James Gosling's office.

The name was simple and memorable, but it could not remain the language's permanent name because it was already being used as a trademark.

A new name would soon be needed.

4. The Original Market Did Not Work Out

The Green Project was technically interesting, but its original consumer-electronics business opportunity did not develop as expected.

The team had built ideas for interactive devices and television systems, but the market was not ready to adopt them at the scale Sun had hoped for.

This could have ended the project.

Instead, another major technological change created a new opportunity.

The World Wide Web was beginning to grow.

Browsers were becoming a new way for people to access information, and the internet connected computers that used different hardware and operating systems.

Suddenly, the Green Project's portability goal became relevant to a much larger problem.

Original problem:
Different electronic devices need the same software.

New internet problem:
Different computers need to run downloaded software.
```

The technology had not failed.

Its most useful market had simply not appeared yet.

5. Java Meets the World Wide Web

In the early web, most pages were static.

A user could open a page and read text or view images, but web pages had limited interactive behavior compared with modern websites.

The Green team recognized that its portable language could allow small programs to be downloaded from a web server and executed on a user's computer.

These programs became known as Java applets.

Why Applets Were Exciting

An applet could theoretically run inside a compatible browser on different operating systems.

That matched Java's portability vision:

One applet
   │
   ├── Windows browser
   ├── Unix browser
   └── another system with compatible Java support

Sun also developed HotJava, an early browser written using Java technology. HotJava helped demonstrate that Java could support interactive internet applications.

The web gave the language a compelling story:

Write a program once and make it available to users on many platforms.

This idea became closely associated with the phrase:

Write Once, Run Anywhere

The phrase simplified a complex technical concept, but it clearly communicated Java's main promise.

6. From Oak to Java

Before the language could be introduced publicly, Oak needed a new name.

The team considered several alternatives. Eventually, the name Java was selected.

Java was officially introduced in 1995.

The name was short, distinctive, and easy to remember. It was not an acronym, even though people later invented humorous expansions for it.

By this point, Java was no longer being presented mainly as a language for consumer electronics.

It was becoming:

a programming language;
a runtime platform;
a set of standard libraries;
a solution for network-connected applications.

This distinction is important.

Java's success did not come only from its syntax. It came from the combination of the language, runtime environment, libraries, development tools, and growing developer community.

7. JDK 1.0: Java's First Major Public Foundation

The first official Java Development Kit, JDK 1.0, was released in January 1996.

This gave developers the tools and standard libraries needed to create Java applications.

Early Java gained attention because it offered several ideas that were especially valuable at the time:

platform-independent bytecode;
automatic memory management;
built-in networking support;
multithreading;
a security model for downloaded code;
a familiar syntax for C and C++ developers.

Java was still young. Its tools, performance, and libraries were far less mature than they are today.

However, the direction was clear:

Java was not only a language specification.

It was becoming an entire application platform.
```

8. The Rise—and Later Decline—of Java Applets

Applets played an important role in making Java famous.

They were used for:

animations;
educational demonstrations;
browser games;
interactive charts;
online tools;
early rich internet applications.

For developers in the 1990s, running the same interactive program in different browsers and operating systems was a powerful idea.

However, applets also faced serious problems.

Problems with Applets

Applet-based applications depended on browser plugins and a compatible Java installation.

This created issues such as:

slow startup;
inconsistent browser support;
security concerns;
plugin installation requirements;
differences between Java versions;
poor integration with browser user interfaces.

Meanwhile, web technologies improved.

JavaScript became more capable, browsers added new APIs, and HTML and CSS evolved. Interactive web applications no longer needed a separate Java browser plugin.

Modern browsers eventually removed support for traditional plugin architectures.

Java applets became obsolete, and the Java browser plugin was removed from modern Java distributions.

Did the End of Applets Mean Java Failed?

No.

Applets were one application model built on Java. They were not the entire platform.

While applets declined, Java was becoming increasingly important elsewhere:

server-side applications;
enterprise systems;
web backends;
financial software;
developer tools;
mobile applications;
distributed services.

Java survived the disappearance of the technology that first made it famous.

That is one of the most important lessons in Java's history.

9. Java 2 and the Expansion of the Platform

In 1998, Sun released J2SE 1.2, commonly associated with the Java 2 era.

The Java platform was organized into editions aimed at different environments:

J2SE — Java 2 Platform, Standard Edition;
J2EE — Java 2 Platform, Enterprise Edition;
J2ME — Java 2 Platform, Micro Edition.

These names were later simplified to:

Java SE;
Java EE;
Java ME.

Why the Editions Mattered

Java was no longer focused on one category of application.

Different parts of the platform served different needs.

Java SE
└── Core language and standard desktop/server APIs

Java EE
└── Large enterprise and server applications

Java ME
└── Resource-constrained mobile and embedded devices
```

Java EE later moved to the Eclipse Foundation and is now developed as Jakarta EE.

The Java 2 era also brought major library and platform improvements, including the Collections Framework, Swing user-interface toolkit, and stronger enterprise capabilities.

This period helped transform Java from an interesting web technology into a serious general-purpose development platform.

10. Java Becomes an Enterprise Standard

During the late 1990s and early 2000s, Java adoption grew rapidly in enterprise software.

Large organizations needed systems that could:

run for long periods;
support many concurrent users;
communicate over networks;
connect to databases;
process business transactions;
remain maintainable for years.

Java's managed runtime and extensive libraries made it attractive for these systems.

Frameworks and application servers grew around the platform.

Over time, technologies such as the following became major parts of the Java ecosystem:

servlets;
JavaServer Pages;
Enterprise JavaBeans;
JDBC;
messaging APIs;
dependency-injection frameworks;
object-relational mapping tools.

Some early enterprise Java technologies became known for complexity. This created demand for simpler approaches, contributing to the rise of frameworks such as Spring.

Java's ecosystem did not evolve in a straight line. Ideas were tried, criticized, simplified, and sometimes replaced.

That process is part of the reason the platform matured.

11. Java 5: A Major Language Upgrade

Released in 2004, Java 5 was one of the most important language releases in Java's history.

The Java Language Specification described it as the largest set of language changes introduced up to that point. The change is described in the preface to the third edition of the Java Language Specification.

Java 5 introduced features such as:

generics;
annotations;
enumerations;
enhanced for loops;
autoboxing and unboxing;
variable-length arguments;
static imports.

These features made Java code more expressive and safer.

For example, generics allowed developers to specify the type of data stored in a collection.

Before generics, code frequently required manual casting:

List names = new ArrayList();
names.add("Pilkupil");

String name = (String) names.get(0);
```

With generics:

List<String> names = new ArrayList<>();
names.add("Pilkupil");

String name = names.get(0);
```

This change may appear small, but it improved compile-time type safety across the Java ecosystem.

Java 5 demonstrated that Java could evolve significantly while preserving much of its familiar design.

12. Java 6 and Java 7: Strengthening the Platform

Java 6, released in 2006, focused heavily on platform quality, performance, web services, tooling, and library improvements.

Java 7 followed in 2011.

Java 7 introduced useful language and API changes, including:

the diamond operator;
strings in switch;
try-with-resources;
multi-catch exception handling;
the NIO.2 file-system API;
the Fork/Join framework.

These releases were not only about adding syntax.

They improved how developers handled:

files;
concurrency;
resources;
exceptions;
performance;
large applications.

By this point, Java had already become deeply established in enterprise development.

13. OpenJDK: Java Becomes an Open Development Community

A major change occurred in 2006.

Sun began releasing significant portions of the JDK source code under the GNU General Public License version 2.

The OpenJDK community was created in November 2006 when initial portions of the JDK source were published under the GPLv2 license. More background is available in the OpenJDK Developers' Guide.

Why OpenJDK Matters

OpenJDK made Java's reference implementation an open-source project where organizations and individual developers could collaborate.

The JDK was no longer developed only behind closed corporate doors.

Today, OpenJDK provides the collaborative home for work on:

the Java language;
the standard libraries;
the Java Virtual Machine;
garbage collectors;
command-line tools;
platform ports;
performance improvements;
future JDK projects.

Java vendors can produce their own JDK distributions based on OpenJDK.

Examples include distributions from:

Oracle;
Eclipse Adoptium;
Amazon;
Microsoft;
Azul;
Red Hat;
BellSoft;
other vendors and communities.

These distributions may differ in support, packaging, certification, update policy, and included tooling, but they share the same broader Java SE foundation.

Java is both a standard and an ecosystem—not a single downloadable file from only one company.

14. From Sun Microsystems to Oracle

Oracle announced its plan to acquire Sun Microsystems in 2009, and the acquisition was completed in 2010.

As a result, Oracle became the main steward of Java.

The transition created concern in parts of the Java community. Developers wondered how Java's governance, licensing, and open-source development would change.

Java continued through a combination of:

Oracle stewardship;
OpenJDK development;
the Java Community Process;
contributions from other companies;
contributions from independent developers.

The platform did not become frozen after the acquisition.

Major releases continued, including Java 7, 8, 9, 11, 17, 21, 25, and many non-LTS releases between them.

The history also shows that Java development is larger than any one organization. Oracle plays a central role, but the modern JDK is built through a broad ecosystem of contributors and vendors.

15. Java 8: The Functional Programming Turning Point

Released in March 2014, Java 8 became one of the most widely adopted versions of Java.

It introduced several major capabilities:

lambda expressions;
method references;
the Stream API;
default methods in interfaces;
the modern Date and Time API;
Optional;
significant runtime and library improvements.

Oracle's Java 8 documentation describes lambda expressions as a way to represent a unit of behavior and pass it to other code. See Oracle's Java SE 8 language enhancements.

Before Java 8, processing a collection often required verbose loops or anonymous classes.

Java 8 enabled code like this:

List<String> topics = List.of("Java", "Kotlin", "Android");

topics.stream()
.filter(topic -> topic.startsWith("J"))
.forEach(System.out::println);
```

Java did not become a purely functional language, but Java 8 allowed object-oriented and functional styles to work together.

Java 8's long support life and broad ecosystem compatibility made it extremely popular. Many systems remained on Java 8 for years after newer versions were released.

16. Java 9 and the Beginning of Faster Evolution

Java 9 was released in September 2017.

Its best-known change was the Java Platform Module System, developed through Project Jigsaw.

The module system allowed the JDK and applications to express stronger boundaries and dependencies between groups of packages.

Java 9 also introduced:

JShell;
custom runtime image support through jlink;
collection factory methods;
many API and JVM improvements.

JShell provided a Read-Eval-Print Loop, allowing developers to experiment with Java statements and expressions without first creating a complete class. See Oracle's overview of JDK 9 changes.

For example:

jshell> int price = 25
price ==> 25

jshell> price * 4
$2 ==> 100
```

However, Java 9's importance was not limited to modules or JShell.

It also marked the transition toward a new release philosophy.

17. From Slow Major Releases to a Six-Month Cycle

Historically, major Java releases could take several years.

That approach created a problem: a large feature that was not ready could delay many unrelated features.

Starting with the Java 9 era, the JDK moved to a strict, time-based release model.

The OpenJDK JDK Project now ships a feature release every six months. The current model is documented by the OpenJDK JDK Project.

New versions normally arrive in:

March;
September.

Old Model

Collect many features
        │
        ▼
Wait until nearly everything is ready
        │
        ▼
Release after a long and uncertain period

Modern Model

Fixed release date
        │
        ├── Ready features enter the release
        └── Unfinished features wait for a later release

This model allows Java to evolve more steadily.

A feature that misses one release does not need to wait several years for another opportunity.

18. Preview and Incubator Features

A faster release cycle introduced another challenge.

How could Java test major new ideas without permanently committing to an incomplete design?

The platform increasingly uses several feature stages.

Preview Feature

A preview feature is fully specified and implemented, but not yet permanent.

Developers can try it and provide feedback.

A preview feature may:

change in a later release;
be previewed again;
become permanent;
be withdrawn.

Incubator Module

An incubator module contains an experimental API or tool that is not yet part of the permanent Java SE standard.

Experimental Feature

An experimental feature is typically lower-level and may involve JVM or runtime behavior still being evaluated.

This gradual process helped features such as switch expressions, records, pattern matching, and virtual threads mature through real-world feedback.

Modern Java evolution is often incremental: introduce, test, improve, and only then finalize.

19. The Meaning of LTS

The six-month release cycle does not mean every organization must migrate twice a year.

Many vendors designate selected Java versions as Long-Term Support, or LTS, releases.

Oracle currently identifies these versions as LTS releases, according to the Oracle Java SE Support Roadmap:

Java 8
Java 11
Java 17
Java 21
Java 25

Oracle currently plans future LTS releases approximately every two years.

Why Organizations Use LTS Releases

An LTS release provides a longer support and maintenance window.

This is useful for systems that require:

long testing periods;
formal security reviews;
vendor certification;
stable dependency support;
predictable maintenance planning;
minimal production disruption.

A team may therefore follow this pattern:

Java 17 LTS
     │
     ├── continue receiving updates
     ├── test applications on newer versions
     └── migrate later to Java 21 or Java 25 LTS

LTS is mainly a vendor support designation. It does not mean non-LTS Java versions are incomplete or low quality.

Non-LTS releases are still full feature releases. They simply have shorter update lifetimes under a vendor's support policy.

20. Major Milestones in Java's Evolution

The following timeline highlights selected releases rather than every Java version.

1991 — Green Project begins: Research starts into portable software for consumer electronics.
Early 1990s — Oak is created: The language that later becomes Java takes shape.
1995 — Java is introduced publicly: The project shifts toward internet applications.
1996 — JDK 1.0: Developers receive the first official Java development kit.
1998 — J2SE 1.2 / Java 2: The platform expands and is organized into editions.
2004 — Java 5: Generics, annotations, enums, enhanced loops, and other major language changes arrive.
2006 — Java 6 and OpenJDK: The platform improves while open-source JDK development begins.
2010 — Oracle acquires Sun: Oracle becomes Java's main steward.
2011 — Java 7: Try-with-resources, NIO.2, Fork/Join, and language improvements are introduced.
2014 — Java 8: Lambdas, streams, the modern date/time API, and major ecosystem adoption follow.
2017 — Java 9: The module system, JShell, and the modern release era begin.
2018 — Java 11 LTS: The first LTS release under the six-month model arrives.
2021 — Java 17 LTS: Sealed classes and a mature set of post-Java-11 improvements are delivered.
2023 — Java 21 LTS: Virtual threads, record patterns, and pattern matching for switch become major highlights.
2025 — Java 25 LTS: This becomes the latest LTS release as of July 2026.
2026 — Java 26: This becomes the latest generally available feature release as of July 2026.
September 2026 — Java 27 planned: The next feature release is scheduled, but remains under development at the time of writing.

This timeline shows that Java did not evolve through one enormous redesign.

Instead, it grew through many stages:

Embedded experiment
        ↓
Web and applets
        ↓
General-purpose platform
        ↓
Enterprise ecosystem
        ↓
Open-source development
        ↓
Faster, incremental evolution

21. Modern Java: Java 17, 21, 25, and 26

Modern Java looks different from the Java many developers learned years ago.

Recent releases have introduced or finalized capabilities such as:

records;
sealed classes;
switch expressions;
pattern matching;
text blocks;
virtual threads;
improved garbage collectors;
better runtime diagnostics;
stronger cryptographic APIs;
custom runtime packaging;
continued startup and performance improvements.

Java 21

JDK 21 reached General Availability on September 19, 2023. See the official JDK 21 release page.

Important features included:

virtual threads;
record patterns;
pattern matching for switch;
sequenced collections;
generational ZGC.

Virtual threads were especially significant for applications that handle large numbers of concurrent tasks.

Java 25

JDK 25 reached General Availability on September 16, 2025 and is an LTS release from most vendors. See the official JDK 25 release page.

It continued Java's evolution with language, runtime, security, monitoring, and performance improvements.

As of July 2026, Java 25 is the latest LTS release.

Java 26

JDK 26 reached General Availability on March 17, 2026. See the official JDK 26 release page.

It is the latest generally available Java feature release as of July 2026, but it is not an LTS release under Oracle's roadmap.

Java 27

JDK 27 is scheduled for General Availability on September 15, 2026. See the official JDK 27 development page.

Because that date is still in the future at the time of this article's review, its feature set and schedule should be checked again when the release becomes final.

22. How Java Changes Without Breaking Everything

Java has a reputation for backward compatibility.

That does not mean every old Java program will run forever without modification.

Libraries can be removed, security policies can change, unsupported internal APIs can disappear, and third-party dependencies can stop working.

However, Java tries to avoid unnecessary breaking changes.

This is especially important because many Java systems:

support critical business operations;
contain millions of lines of code;
depend on large library ecosystems;
remain in production for many years.

Java therefore evolves carefully.

The Compatibility Trade-Off

Move too slowly
└── the language risks becoming outdated

Move too quickly
└── existing applications and developers are left behind
```

Java attempts to balance both sides through:

deprecation before removal;
preview features;
long support windows;
compatibility testing;
migration tools;
gradual language changes;
stable bytecode and runtime behavior where practical.

This process can make Java appear conservative compared with younger languages.

But that conservatism is also one reason organizations trust Java for long-lived systems.

23. Common Misconceptions About Java's History

Misconception 1: “Java was invented for websites”

Java was originally developed for embedded consumer-electronic applications.

The web became Java's major opportunity later.

Misconception 2: “Java became irrelevant when applets disappeared”

Applets disappeared, but server-side Java, enterprise Java, Android-related Java development, and the JVM ecosystem continued to grow.

Applets were only one chapter in Java's history.

Misconception 3: “Oracle created Java”

Java was created at Sun Microsystems.

Oracle became Java's steward after acquiring Sun in 2010.

Misconception 4: “OpenJDK is an unofficial copy of Java”

OpenJDK is the open-source project that produces reference implementations of the Java SE Platform.

Many commercial and community JDK distributions are based on OpenJDK.

Misconception 5: “Every new Java version is an LTS release”

Java feature releases arrive every six months.

Only selected versions receive an LTS designation from vendors.

Misconception 6: “A higher Java version is always the best production choice”

The newest version provides the latest features, but production teams must also consider:

framework compatibility;
library support;
deployment environments;
vendor support;
testing capacity;
organizational upgrade policy.

The newest version and the best version for a particular project are not always the same.

24. What Java's History Teaches Developers

Java's history contains several broader lessons about software development.

Lesson 1: A Technology Can Find a Different Market

Java's original consumer-electronics opportunity did not succeed as planned.

The same portability ideas later became valuable for the web and enterprise systems.

Lesson 2: A Popular Feature Is Not the Entire Platform

Applets made Java famous, but Java outlived them.

A strong platform should not depend permanently on one product category.

Lesson 3: Compatibility Has Real Value

New syntax is exciting, but organizations also need old applications to continue working.

Java's careful evolution helped protect long-term investment.

Lesson 4: Open Development Strengthens an Ecosystem

OpenJDK allowed multiple companies and individual contributors to participate in Java's future.

This reduced Java's dependence on a single implementation or vendor distribution.

Lesson 5: Evolution Does Not Require Reinvention

Modern Java is clearly different from Java 1.0, but developers can still recognize the same language.

Java usually adds capabilities gradually instead of repeatedly redesigning its foundations.

25. Knowledge Check

Try answering these questions before opening the suggested answers.

What was the Green Project trying to solve?
What was Java originally called?
Why did the rise of the web create an opportunity for Java?
What were Java applets?
Why did applets eventually disappear?
What changed when OpenJDK was created?
Which company originally developed Java?
Which company became Java's main steward in 2010?
What major change arrived with Java 8?
What release model began around the Java 9 era?
What does LTS mean?
What are the latest feature and LTS releases as of July 2026?

26. Key Takeaways

1991
Green Project begins at Sun Microsystems
        │
        ▼
Oak is created for consumer electronics
        │
        ▼
The project shifts toward the growing web
        │
        ▼
Oak is renamed Java and introduced in 1995
        │
        ▼
Applets make Java famous
        │
        ▼
Java expands into enterprise and server development
        │
        ▼
OpenJDK makes JDK development openly collaborative
        │
        ▼
Oracle acquires Sun in 2010
        │
        ▼
Java 8 modernizes the language
        │
        ▼
Java 9 begins the six-month release era
        │
        ▼
Modern Java evolves through regular and LTS releases

The most important points to remember are:

Java began as part of the Green Project.
The language was originally called Oak.
Java was not initially designed for the web.
The growth of the internet gave Java its first major opportunity.
Applets helped popularize Java but later became obsolete.
Java survived because it expanded into many other types of software.
OpenJDK transformed Java into a broadly collaborative open-source platform.
Oracle became Java's main steward after acquiring Sun Microsystems.
Java now follows a six-month feature-release schedule.
Java 25 is the latest LTS release as of July 2026.
Java 26 is the latest generally available feature release as of July 2026.
Java's long life comes partly from balancing innovation with compatibility.

What's Next?

Now that we understand where Java came from, the next article will examine the characteristics that allowed it to survive:

What Makes Java Different? Understanding Its Core Features

We will explore:

simplicity;
object-oriented design;
platform independence;
portability;
robustness;
security;
multithreading;
automatic memory management;
JIT compilation;
backward compatibility;
Java's mature ecosystem.

Official Sources and Further Reading

← Previous Getting Started with Java: A Language That's Still Relevant Today Next → Java Core Features