History of Java

Explore the complete history of Java, from the Green Project and Oak language to modern Java releases, OpenJDK, Oracle stewardship, the release model, LTS versions, and the evolution of the Java ecosystem.

Introduction

The history of Java begins before the modern World Wide Web became a major part of everyday life. Java was not originally created for websites, enterprise applications, Android development, cloud computing, or microservices.

The language began as part of an experimental project at Sun Microsystems. The original team wanted to create software for intelligent consumer electronic devices that could contain different processors and hardware architectures.

This requirement created one of the central ideas behind Java: software should not be permanently tied to one particular type of hardware.

The project produced a programming language called Oak. As the Internet and World Wide Web rapidly expanded, the team discovered that the same portability and security ideas designed for consumer devices were also extremely useful for networked software.

Oak was eventually renamed Java, publicly introduced in 1995, and developed into one of the most important programming languages and software platforms in computing history.

What You Will Learn

What programming was like before Java.
Why the Green Project was created.
Who worked on the original Java project.
The role of James Gosling.
Why the original language was called Oak.
The original purpose of Oak.
What the Green operating system was.
What the Star7 device was.
The origin of the Duke mascot.
Why the project changed direction.
How the rise of the Internet affected Java.
What the WebRunner browser was.
Why Oak was renamed Java.
When Java was publicly announced.
What Java 1.0 introduced.
How Write Once, Run Anywhere became a major Java idea.
Why Java applets became popular.
How the early Java architecture worked.
The major Java version milestones.
How Java evolved from JDK 1.0 to modern releases.
Why Java 5 was a major language update.
Why Java 8 was one of the most important releases.
Why Java 9 changed the platform architecture.
How the six-month release cycle works.
What LTS releases are.
How Java naming changed over time.
How Java moved from Sun Microsystems to Oracle.
What OpenJDK is.
What the Java Community Process does.
How Java development practices evolved.
How Java applications evolved.
Why browser applets disappeared.
How Java moved from monolithic systems to microservices.
How Java adapted to cloud computing.
Why Java has remained relevant for decades.

Before Java

Before Java, software portability was a major challenge. Programs were commonly compiled directly into native machine instructions for a particular processor and operating system.

A program built for one type of machine often needed to be modified and recompiled before it could run on another type of machine.

Traditional Software Problem

SOURCE CODE

    │
    ├────────────────┬────────────────┐
    ▼                ▼                ▼

Windows          UNIX            Macintosh
Compiler         Compiler         Compiler

    │                │                │
    ▼                ▼                ▼

Windows          UNIX            Macintosh
Executable       Executable       Executable


ONE PROGRAM IDEA

        │
        ▼

MULTIPLE PLATFORM-SPECIFIC BUILDS

This problem became especially important when software needed to run on consumer electronic devices. Different devices could use different processors, memory configurations, and operating environments.

The Portability Problem

Different devices used different processors.
Different systems used different operating environments.
Native programs were tied to particular platforms.
Rewriting software for every device was expensive.
Consumer electronics could change hardware frequently.
Developers needed a more portable software model.

The Green Project

In 1991, Sun Microsystems started an internal research project commonly known as the Green Project.

The project explored the future of digital consumer devices and interactive electronic systems. The team investigated how software could work across different types of intelligent devices.

The Green Project

1991

SUN MICROSYSTEMS

        │
        ▼

THE GREEN PROJECT

        │
        ▼

RESEARCH GOAL

Create software for future
consumer electronic devices

        │
        ▼

MAJOR CHALLENGE

Different devices could use
different hardware

        │
        ▼

REQUIRED SOLUTION

Portable Software

The team needed a programming environment that could support portability, reliability, security, networking, and different hardware architectures.

The Green Team

The engineers working on the project became known as the Green Team. James Gosling is the person most strongly associated with the creation of the Java programming language.

James Gosling

The principal designer of the language that became Java.

Patrick Naughton

An important member of the original Green Project team.

Mike Sheridan

A key contributor to the original project and its direction.

The Green Team

GREEN PROJECT

        │
        ├── James Gosling
        │
        ├── Patrick Naughton
        │
        ├── Mike Sheridan
        │
        └── Other Engineers

        │
        ▼

RESEARCH

        │
        ▼

OAK LANGUAGE

        │
        ▼

JAVA

James Gosling

James Gosling is widely recognized as the principal creator and designer of Java. He developed the language that was initially called Oak and later renamed Java.

The language was influenced by existing programming languages, especially C and C++, but it was designed to remove or simplify several features that could make software difficult to maintain or unsafe.

Design Direction

Use familiar C-like syntax.
Support object-oriented programming.
Avoid direct pointer arithmetic.
Provide automatic memory management.
Support portability.
Support networked environments.
Improve reliability.
Create a controlled runtime environment.

The Birth of Oak

The programming language developed during the Green Project was originally named Oak.

Oak was designed to provide a simpler and more portable alternative for software running on different types of electronic devices.

Language Evolution

1991

GREEN PROJECT

    │
    ▼

NEW LANGUAGE REQUIRED

    │
    ▼

OAK

    │
    ▼

Portable
Object-Oriented
Secure
Reliable
Network-Aware

    │
    ▼

Later Renamed

    │
    ▼

JAVA

Why the Name Oak?

The name Oak is commonly associated with an oak tree visible near James Gosling’s working environment. The name represented the original identity of the language before it became Java.

However, the name Oak could not remain the final product name because of trademark-related issues.

The Original Goal

Oak was not originally created as a language for traditional desktop computers or websites. The Green Project focused on intelligent consumer electronics.

Interactive Television

The team explored software for future interactive television systems.

Consumer Devices

The language needed to work across different electronic devices.

Controllers

Software could control and interact with multiple digital devices.

Networked Systems

Devices were expected to communicate through networks.

Original Java Vision

NOT ORIGINALLY

Websites
Enterprise Backends
Android Apps
Cloud Services


ORIGINALLY

Consumer Electronics
Interactive Devices
Networked Devices
Hardware-Independent Software

The Green Operating System

The Green Project involved more than a programming language. The team also worked on a software environment for intelligent consumer devices.

The project demonstrated a broader vision in which devices could communicate and users could interact with digital systems through a graphical interface.

The Star7 Device

One of the most famous demonstrations produced by the Green Project was the Star7, often written as *7.

The Star7 was a handheld prototype designed to demonstrate how users might interact with intelligent networked consumer devices.

Star7 Concept

STAR7 PROTOTYPE

        │
        ├── Handheld Device
        ├── Graphical Interface
        ├── Network Interaction
        ├── Device Control
        └── Animated Assistant

        │
        ▼

DEMONSTRATED

The Future of Interactive
Consumer Electronics

Duke Mascot

The Star7 interface included an animated character called Duke. Duke later became the well-known mascot of Java.

Duke Evolution

GREEN PROJECT

    │
    ▼

STAR7 DEVICE

    │
    ▼

ANIMATED CHARACTER

    │
    ▼

DUKE

    │
    ▼

JAVA MASCOT

Why Oak Changed Direction

The original consumer electronics market did not develop exactly as the Green Team expected. The technology was promising, but the intended commercial opportunities were limited.

At the same time, another major technological revolution was beginning: the rapid growth of the Internet and the World Wide Web.

The Original Market Was Not Ready

Interactive consumer electronics were still developing.
Commercial opportunities were uncertain.
The original project needed a new direction.
The Internet was growing rapidly.
The Web created a new portability problem.
Oak was well suited to networked environments.

The Rise of the Internet

During the early 1990s, the World Wide Web began expanding rapidly. Users accessed the Web from different computers and operating systems.

This created a problem similar to the one Oak had been designed to solve: how could the same software run across different types of machines?

A New Opportunity

ORIGINAL PROBLEM

Different Consumer Devices

        │
        ▼

Need Portable Software


NEW WEB PROBLEM

Different Computers
Different Operating Systems

        │
        ▼

Need Portable Software


OAK

Already Designed Around Portability

The team realized that a portable language with a controlled runtime environment could be useful for delivering interactive software across the Internet.

The WebRunner Browser

The team developed a web browser called WebRunner to demonstrate how Oak programs could be delivered through web pages and executed on different computers.

WebRunner was later associated with the name HotJava.

WebRunner Concept

WEB SERVER

    │
    ▼

WEB PAGE

    │
    ▼

OAK PROGRAM

    │
    ▼

WEBRUNNER BROWSER

    │
    ▼

PROGRAM EXECUTES

    │
    ▼

INTERACTIVE WEB CONTENT

Important Historical Shift

Oak began as a language for consumer devices.
The project changed direction toward the Web.
The Web needed portable interactive software.
Oak already had portability and security-oriented design goals.
The browser demonstration helped show the potential of the technology.

Oak Becomes Java

The name Oak could not be used as the final commercial name because of trademark-related concerns. The team therefore needed a new name.

Name Evolution

1991

OAK

    │
    ▼

Trademark Problem

    │
    ▼

New Name Required

    │
    ▼

1995

JAVA

Why the Name Java?

The exact naming process has been described through various stories, but the name Java is strongly associated with coffee. Java is also the name of an Indonesian island historically associated with coffee production.

The coffee association became part of Java’s identity, which is why the language is commonly represented using a coffee cup symbol.

Java Identity

OAK

    │
    ▼

New Name Needed

    │
    ▼

JAVA

    │
    ├── Coffee Association
    ├── Coffee Cup Symbol
    └── Global Technology Brand

Java Announced in 1995

Java was publicly introduced in 1995. Its arrival matched the rapid expansion of the World Wide Web.

The idea of downloading small programs through web pages and running them on different systems attracted significant attention.

1995

1995

WORLD WIDE WEB

Rapid Growth

        +

JAVA

Portable Programs

        +

WEB BROWSERS

Interactive Content

        │
        ▼

MAJOR INDUSTRY ATTENTION

Java 1.0

The first major public Java development kit, JDK 1.0, arrived in 1996. It established the core language, runtime model, and standard libraries that allowed developers to build and run Java applications.

Java Language

Developers could write applications using the new Java programming language.

JVM

Bytecode could execute through the Java Virtual Machine.

Standard APIs

Developers received libraries for building applications.

Applets

Small Java programs could run inside supported web browsers.

Write Once, Run Anywhere

Java became strongly associated with the principle Write Once, Run Anywhere. The goal was to compile Java source code into portable bytecode that could run on different platforms through compatible JVM implementations.

Java Portability

JAVA SOURCE CODE

        │
        ▼

COMPILE

        │
        ▼

BYTECODE

        │
        ├──────────────┬──────────────┐
        ▼              ▼              ▼

Windows JVM       UNIX JVM        Mac JVM

        │              │              │
        ▼              ▼              ▼

    RUNS             RUNS           RUNS

Java Applets

Java applets were small Java programs designed to run inside compatible web browsers or applet viewers.

During the early Web era, applets demonstrated that web pages could contain interactive programs rather than only static text and images.

Applet Execution

WEB PAGE

    │
    ▼

Contains Java Applet

    │
    ▼

Browser Downloads Bytecode

    │
    ▼

Java Runtime

    │
    ▼

Applet Executes

    │
    ▼

Interactive Content

Historical Technology

Applets were important in early Java history.
They helped demonstrate Java portability.
Modern browsers no longer support the old Java applet model.
Applets are not used for modern web development.
Java continued to grow far beyond browser applets.

Early Java Architecture

Early Java Model

DEVELOPER

    │
    ▼

.java SOURCE FILE

    │
    ▼

JAVA COMPILER

    │
    ▼

.class BYTECODE

    │
    ├───────────────┬───────────────┐
    ▼               ▼               ▼

Application      Applet         Network Code

    │               │               │
    ▼               ▼               ▼

JAVA VIRTUAL MACHINE

    │
    ▼

OPERATING SYSTEM

    │
    ▼

HARDWARE

Java Version Timeline

Java has evolved through many releases. Some versions introduced major language changes, while others focused on runtime improvements, libraries, performance, security, developer productivity, and platform architecture.

Major Java Timeline

1991  Green Project Begins
  │
1991  Oak Language
  │
1995  Oak Renamed Java
  │
1995  Java Publicly Introduced
  │
1996  JDK 1.0
  │
1997  JDK 1.1
  │
1998  Java 2 / J2SE 1.2
  │
2000  J2SE 1.3
  │
2002  J2SE 1.4
  │
2004  Java 5
  │
2006  Java 6
  │
2007  OpenJDK Development Expands
  │
2010  Oracle Acquires Sun Microsystems
  │
2011  Java 7
  │
2014  Java 8
  │
2017  Java 9
  │
2018  Java 10
  │
2018  Java 11
  │
2019  Java 12 and Java 13
  │
2020  Java 14 and Java 15
  │
2021  Java 16 and Java 17
  │
2022  Java 18 and Java 19
  │
2023  Java 20 and Java 21
  │
      Modern Java Continues

JDK 1.0

JDK 1.0, released in 1996, represented the first major public Java development platform.

Established the Java language.
Provided the Java Virtual Machine execution model.
Included standard libraries.
Supported Java applications.
Supported applets.
Established the source-code-to-bytecode workflow.
Introduced developers to portable Java programs.

JDK 1.1

JDK 1.1 improved the language platform and added important APIs that helped Java move beyond its earliest form.

Inner Classes

Classes could be declared within other classes and scopes.

Event Model

A new event-handling model improved graphical application development.

JDBC

Java Database Connectivity provided a standard approach to relational database access.

Reflection

Programs gained stronger runtime inspection capabilities.

Java 2 and J2SE 1.2

The release of J2SE 1.2 in 1998 represented a major expansion of the Java platform and introduced the Java 2 branding.

The Collections Framework.
Swing graphical user interface components.
Major standard library expansion.
Improved platform organization.
The Java 2 branding.
A stronger foundation for large applications.

Java 2 Platform Families

JAVA 2

├── J2SE
│   └── Standard Edition
│
├── J2EE
│   └── Enterprise Edition
│
└── J2ME
    └── Micro Edition

J2SE 1.3

J2SE 1.3 continued improving Java performance and platform capabilities. The HotSpot virtual machine technology became an important part of mainstream Java execution.

HotSpot JVM

Observes program execution.
Identifies frequently executed code.
Applies runtime optimizations.
Uses Just-In-Time compilation techniques.
Helped improve Java performance significantly.

J2SE 1.4

J2SE 1.4 expanded the standard platform with important APIs and language support improvements.

The assert keyword.
Regular expressions.
Improved networking APIs.
New I/O capabilities.
Logging APIs.
XML processing improvements.
Security enhancements.

Java 5

Java 5, released in 2004, was one of the most important language updates in Java history. It introduced several features that permanently changed how developers write Java code.

Generics

Allowed stronger type safety for collections and reusable classes.

Enhanced for Loop

Simplified iteration over arrays and collections.

Annotations

Added metadata directly to program elements.

Enums

Provided a structured way to represent fixed sets of constants.

Varargs

Allowed methods to accept a variable number of arguments.

Autoboxing

Simplified conversion between primitives and wrapper objects.

Java 5 Style

List<String> languages =
    new ArrayList<String>();

languages.add("Java");
languages.add("C++");

for (String language : languages) {
    System.out.println(language);
}

Why Java 5 Was Important

Java code became more expressive.
Collections became safer with generics.
Annotations became essential to modern frameworks.
Enhanced loops reduced repetitive code.
Enums improved constant modeling.
Many modern Java development patterns began here.

Java 6

Java 6 focused heavily on platform maturity, performance, tooling, web services, monitoring, and runtime improvements.

Runtime performance improvements.
Compiler improvements.
Monitoring and management improvements.
Web service support.
Scripting integration.
Desktop application improvements.

OpenJDK

OpenJDK became the open-source reference implementation of the Java Platform, Standard Edition.

Its development model allowed a broader community of companies and developers to participate in the evolution of the Java platform.

OpenJDK Ecosystem

OPENJDK

    │
    ├── Open Source Development
    ├── Java Platform Implementation
    ├── Community Contributions
    ├── Company Contributions
    └── Foundation for JDK Distributions

    │
    ▼

MULTIPLE JDK DISTRIBUTIONS

Oracle Acquires Sun

Oracle completed its acquisition of Sun Microsystems in 2010. As a result, stewardship of Java moved from Sun Microsystems to Oracle.

Ownership Transition

1991 - 2010

SUN MICROSYSTEMS

        │
        ▼

Creates and Develops Java

        │
        ▼

2010

ORACLE ACQUIRES SUN

        │
        ▼

ORACLE ERA

Java continued to evolve through Oracle stewardship, OpenJDK development, community participation, standards processes, and contributions from many organizations.

Java 7

Java 7 introduced language improvements and important APIs designed to make common programming tasks easier and safer.

Try-with-Resources

Simplified automatic closing of resources.

Multi-Catch

Allowed one catch block to handle multiple exception types.

Diamond Operator

Reduced repeated generic type declarations.

NIO.2

Added a modern file-system and path API.

Diamond Operator

List<String> languages =
    new ArrayList<>();

Java 8

Java 8, released in 2014, was one of the most influential releases in Java history. It introduced functional programming capabilities that significantly changed modern Java development.

λ Lambda Expressions

Allowed behavior to be expressed more concisely.

Stream API

Provided a declarative approach to processing collections of data.

Functional Interfaces

Created the foundation for lambda-based APIs.

Date and Time API

Introduced the modern java.time API.

Default Methods

Allowed interfaces to provide method implementations.

Optional

Provided a container for values that may or may not be present.

Before Lambda Expressions

List<String> names =
    Arrays.asList(
        "Amit",
        "Neha",
        "Rahul"
    );

for (String name : names) {
    System.out.println(name);
}

Using Lambda Expression

names.forEach(
    name ->
        System.out.println(name)
);

Using Method Reference

names.forEach(
    System.out::println
);

Why Java 8 Was a Major Turning Point

Introduced lambda expressions.
Introduced the Stream API.
Made functional-style programming practical in Java.
Modernized date and time handling.
Influenced modern framework and library design.
Remained widely used for many years.

Java 9

Java 9 introduced the Java Platform Module System, one of the largest structural changes to the Java platform.

Before Modules

LARGE APPLICATION

    │
    ├── Many JAR Files
    ├── Complex Dependencies
    ├── Weak Boundaries
    └── Large Runtime

Module System

APPLICATION

├── Module A
│   └── Explicit Dependencies
│
├── Module B
│   └── Explicit Dependencies
│
└── Module C
    └── Explicit Dependencies

Java Platform Module System.
JShell interactive programming tool.
Platform modularization.
API improvements.
Runtime organization improvements.

Six-Month Release Cycle

After Java 9, Java moved to a faster release model. New feature releases began arriving approximately every six months.

Modern Release Model

OLD MODEL

Major Release

    │
    ▼

Wait Several Years

    │
    ▼

Next Major Release


MODERN MODEL

March Release

    │
    ▼

Approximately 6 Months

    │
    ▼

September Release

    │
    ▼

Approximately 6 Months

    │
    ▼

Next March Release

Why the Release Model Changed

Features can reach developers faster.
Releases are smaller and more predictable.
Developers can test new features earlier.
The platform can evolve continuously.
Organizations can choose between rapid upgrades and longer-term support strategies.

Java 10

Java 10 introduced local variable type inference using the var keyword.

Traditional Local Variable

String language = "Java";

ArrayList<String> names =
    new ArrayList<>();

Local Variable Type Inference

var language = "Java";

var names =
    new ArrayList<String>();

var Does Not Make Java Dynamically Typed

Java remains statically typed.
The compiler determines the variable type.
The type does not change dynamically.
var is limited to supported local-variable contexts.

Java 11

Java 11 became an important long-term support release and introduced useful APIs and platform improvements.

Long-term support significance.
Standard HTTP Client API.
Useful String methods.
Files utility improvements.
Ability to run a single-file source program directly.
Runtime and garbage collector improvements.

Java 11 String Methods

String value = "   ";

System.out.println(
    value.isBlank()
);

String text =
    "Java\nPython\nC++";

text.lines().forEach(
    System.out::println
);

Java 12 to Java 16

Java 12 through Java 16 continued the rapid release model and introduced or finalized several features that made modern Java more expressive.

Switch Expressions

Allowed switch to produce values with a more concise syntax.

Text Blocks

Simplified multiline strings.

Records

Reduced boilerplate for simple data-carrier classes.

Pattern Matching

Reduced repetitive type checking and casting.

Switch Expression

String type = switch (day) {
    case 1, 7 -> "Weekend";
    default -> "Weekday";
};

Text Block

String html = """
    <html>
        <body>
            <h1>Hello Java</h1>
        </body>
    </html>
    """;

Record

record Student(
    int id,
    String name
) { }

Java 17

Java 17 became another major long-term support release and consolidated many improvements introduced during the faster release cycle.

Sealed Classes

Allowed developers to control which classes may extend or implement a type.

Records

Modern data-carrier classes became part of the established language toolkit.

Pattern Matching

Reduced repetitive instanceof checks and casts.

LTS Release

Became an important migration target for organizations.

Pattern Matching for instanceof

if (value instanceof String text) {
    System.out.println(
        text.toUpperCase()
    );
}

Java 18 to Java 20

Java 18 through Java 20 continued introducing platform improvements and previewing major features that would become important in later releases.

UTF-8 became the default charset.
Simple web server tooling was added.
Pattern matching continued evolving.
Record patterns were developed.
Virtual threads continued through preview stages.
Structured concurrency was explored.
The Foreign Function and Memory API continued evolving.

Java 21

Java 21 became a major long-term support release and introduced important features for modern application development.

Virtual Threads

Enabled lightweight concurrency for applications that handle large numbers of tasks.

Record Patterns

Improved data decomposition and pattern matching.

Pattern Matching for switch

Made switch more powerful for type-based logic.

LTS Release

Provided another major long-term migration target.

Virtual Thread

Thread.startVirtualThread(
    () -> {
        System.out.println(
            "Running in a virtual thread"
        );
    }
);

Modern Java

Modern Java is significantly different from early Java. The language and platform now include features for functional-style programming, modular applications, concise data classes, pattern matching, lightweight concurrency, modern garbage collectors, cloud workloads, and large distributed systems.

Java Evolution

EARLY JAVA

├── Applets
├── Desktop Applications
├── Basic Server Applications
└── Early Enterprise Systems

        │
        ▼

MODERN JAVA

├── Enterprise Platforms
├── REST APIs
├── Microservices
├── Cloud Applications
├── Distributed Systems
├── Data Processing
├── High-Concurrency Services
└── Modern Backend Systems

LTS Versions

LTS means Long-Term Support. LTS releases are especially important to organizations that prefer longer maintenance windows and less frequent major migrations.

Important LTS Releases

JAVA 8

Major Long-Lived Release

        │
        ▼

JAVA 11

LTS

        │
        ▼

JAVA 17

LTS

        │
        ▼

JAVA 21

LTS

        │
        ▼

Future LTS Releases

Feature Release vs LTS Release

Feature releases arrive regularly.
LTS releases receive longer support from applicable vendors and distributions.
Many companies standardize production systems on LTS versions.
Developers should still understand features introduced between LTS releases.
Support terms depend on the JDK vendor and distribution.

Java Naming Evolution

Java version names have changed over time. Understanding the naming history helps when reading older books, documentation, and project requirements.

Java Naming History

EARLY NAMING

JDK 1.0
JDK 1.1


JAVA 2 ERA

J2SE 1.2
J2SE 1.3
J2SE 1.4


TRANSITION

J2SE 5.0
Java SE 6


MODERN NAMING

Java 7
Java 8
Java 9
Java 10
Java 11
...
Java 21
...

Java 5 and JDK 1.5

Java 5 is also associated with version number 1.5.
Older tools may display 1.5-style version numbers.
Modern Java releases are normally referred to by their major number.
Version naming can look confusing when working with older systems.

Java Ownership Timeline

Java Stewardship

1991

SUN MICROSYSTEMS

Green Project

        │
        ▼

Oak

        │
        ▼

Java

        │
        ▼

1995 - 2010

Sun Microsystems Era

        │
        ▼

2010

Oracle Acquires Sun

        │
        ▼

Oracle Stewardship

        +

OpenJDK Community

        +

Java Community Process

        +

Global Ecosystem

Sun Microsystems Era

Sun Microsystems created Java and guided its development during its formative years.

The Green Project.
Creation of Oak.
Renaming Oak to Java.
Public introduction of Java.
The first JDK releases.
Growth of Java applets.
Development of enterprise Java.
Creation of Java platform editions.
Major language evolution.
Movement toward OpenJDK.

Oracle Era

After acquiring Sun Microsystems, Oracle became a major steward of Java. The platform continued evolving through new releases, OpenJDK development, standards processes, and contributions from the wider ecosystem.

Java 7 and later releases.
Major Java 8 language changes.
The Java module system.
The six-month release cycle.
Regular LTS releases.
Project-based development of major features.
Continued OpenJDK evolution.
Modern language and runtime improvements.

Role of OpenJDK

OpenJDK is central to modern Java development. It provides an open-source implementation and development community around the Java Platform, Standard Edition.

Modern Java Development

JAVA PLATFORM EVOLUTION

        │
        ├── OpenJDK Projects
        ├── Oracle Engineers
        ├── Other Companies
        ├── Independent Developers
        ├── Research
        └── Community Feedback

        │
        ▼

NEW JAVA FEATURES

        │
        ▼

JDK RELEASES

Java Community Process

The Java Community Process, commonly called the JCP, provides a formal process for developing and revising Java technology specifications.

Specification Process

IDEA OR REQUIREMENT

        │
        ▼

JAVA SPECIFICATION REQUEST

        │
        ▼

EXPERT DISCUSSION

        │
        ▼

SPECIFICATION DEVELOPMENT

        │
        ▼

REVIEW

        │
        ▼

JAVA TECHNOLOGY EVOLUTION

JSR

JSR stands for Java Specification Request.
JSRs define proposed specifications and changes.
The JCP has played an important role in Java standardization.
Not every OpenJDK language or runtime development activity is simply described by the JCP alone.
Modern Java evolution also involves OpenJDK projects and enhancement proposals.

Java Community

Java became successful not only because of the language itself but also because of its enormous global ecosystem.

Developers

Millions of developers have built applications and contributed knowledge.

Companies

Technology companies contribute tools, libraries, frameworks, and JDK development.

Educators

Universities, instructors, and authors have taught Java for decades.

Open Source

Thousands of open-source Java projects expanded the ecosystem.

Tool Vendors

Powerful IDEs, build tools, monitoring systems, and development platforms emerged.

User Groups

Java communities and user groups support developers around the world.

Evolution of Java Development

Java Development Evolution

EARLY JAVA DEVELOPMENT

Text Editor
    +
javac
    +
java Command

        │
        ▼

DESKTOP IDE ERA

Advanced Editors
Debuggers
Refactoring
Project Management

        │
        ▼

BUILD TOOL ERA

Ant
Maven
Gradle

        │
        ▼

FRAMEWORK ERA

Enterprise Frameworks
Spring
ORM Tools

        │
        ▼

MODERN ERA

Cloud
Containers
Microservices
CI/CD
Observability
DevOps

Evolution of Java Applications

Application Evolution

1990s

Applets
Desktop Applications
Early Servers

        │
        ▼

2000s

Enterprise Applications
Application Servers
Large Web Systems

        │
        ▼

2010s

REST APIs
Spring Boot
Microservices
Cloud Platforms

        │
        ▼

2020s

Cloud-Native Systems
Containers
Serverless Workloads
High-Concurrency Services
Modern Distributed Systems

Java Applets Rise and Fall

Applets played a major role in making Java famous, but they eventually disappeared from modern web development.

Applet Lifecycle

1990s

RISE

Interactive Web Content

        │
        ▼

WIDESPREAD USE

Games
Animations
Tools
Education

        │
        ▼

PROBLEMS

Browser Plugins
Security Concerns
Compatibility
Performance
Better Web Standards

        │
        ▼

DECLINE

        │
        ▼

MODERN BROWSERS

No Traditional Java Applet Support

Java Did Not Disappear with Applets

Applets were only one Java application model.
Server-side Java continued growing.
Enterprise Java became extremely important.
Java became a major backend language.
Java remains important for cloud and distributed systems.

From Monoliths to Microservices

Java applications evolved with software architecture. Large applications were traditionally deployed as single systems or large enterprise packages. Modern systems increasingly use independently deployable services.

Architecture Evolution

TRADITIONAL MONOLITH

One Large Application

├── Users
├── Products
├── Orders
└── Payments


        │
        ▼

MODERN MICROSERVICES

User Service
Product Service
Order Service
Payment Service

        │
        ▼

Independent Deployment
Independent Scaling
Network Communication

Java in the Cloud Era

Java adapted to cloud computing through improvements in frameworks, runtimes, deployment models, startup performance, memory efficiency, observability, and container support.

Cloud Services

Java applications run on major cloud platforms.

Containers

Java applications are commonly packaged and deployed using containers.

Microservices

Java frameworks support independently deployable services.

Scalability

Java powers systems that handle large workloads.

Observability

Modern tools monitor application health and performance.

Modern Runtimes

Java runtimes continue improving startup, memory, and throughput characteristics.

Why Java Survived

Many programming languages become popular for a short period and then decline. Java has remained important for decades because it continued evolving while preserving a strong degree of compatibility and ecosystem stability.

Continuous Evolution

The language and platform continue receiving new features.

Backward Compatibility

Long-lived applications can often migrate gradually.

Enterprise Adoption

Large organizations depend on Java systems.

Huge Ecosystem

Libraries and frameworks exist for nearly every major application requirement.

JVM Performance

The JVM has evolved into a highly optimized runtime.

Large Community

A global developer community continues supporting the platform.

Cloud Adaptation

Java evolved from traditional servers to modern cloud environments.

Strong Tooling

Java has mature IDEs, build tools, testing tools, and monitoring platforms.

Important Historical Milestones

Java History at a Glance

1991
Green Project Begins

    │
    ▼

Oak Language Created

    │
    ▼

Star7 Demonstration

    │
    ▼

Internet Opportunity Discovered

    │
    ▼

WebRunner / HotJava

    │
    ▼

1995
Oak Renamed Java

    │
    ▼

Java Publicly Introduced

    │
    ▼

1996
JDK 1.0

    │
    ▼

1998
Java 2

    │
    ▼

2004
Java 5

    │
    ▼

2006
Java 6

    │
    ▼

OpenJDK Era Expands

    │
    ▼

2010
Oracle Acquires Sun

    │
    ▼

2014
Java 8

    │
    ▼

2017
Java 9

    │
    ▼

Six-Month Release Cycle

    │
    ▼

2018
Java 11 LTS

    │
    ▼

2021
Java 17 LTS

    │
    ▼

2023
Java 21 LTS

    │
    ▼

MODERN JAVA CONTINUES EVOLVING

Common Historical Misconceptions

Avoid These Misconceptions

Java was not originally created for websites.
Java was not originally created for Android.
Java was not originally created for enterprise applications.
Java was not originally called Java.
The original language name was Oak.
JavaScript is not a version of Java.
Java did not become irrelevant when browser applets disappeared.
Applets were only one part of the Java ecosystem.
Oracle did not originally create Java.
Java was created at Sun Microsystems.
OpenJDK is not simply a third-party clone of Java.
Java 5 is historically associated with the 1.5 version number.
Java 8 was not the final important Java release.
Modern Java continues to evolve.
LTS does not mean that only LTS versions contain new features.
The six-month release cycle does not mean every organization must upgrade every six months.
Java remains statically typed even after the introduction of var.
The JVM has changed significantly since early Java.
Modern Java is not limited to large monolithic enterprise applications.

Frequently Asked Questions

When did the Java project begin?

The project that eventually produced Java began at Sun Microsystems in 1991.

What was the Green Project?

The Green Project was a Sun Microsystems research project exploring software for future intelligent consumer electronic devices.

Who created Java?

James Gosling is widely recognized as the principal creator and designer of Java, working with the original Green Project team at Sun Microsystems.

Who were important members of the original Green Team?

James Gosling, Patrick Naughton, and Mike Sheridan were important members associated with the original project.

What was Java originally called?

The language was originally called Oak.

Why was it called Oak?

The name is commonly associated with an oak tree near James Gosling’s working environment.

Why was Oak renamed?

The Oak name could not remain the final commercial name because of trademark-related concerns.

Why was the name Java chosen?

The name Java is strongly associated with coffee and became the new identity of the language.

Was Java originally created for the Web?

No. It was originally created for intelligent consumer electronic devices.

Why did Java move toward the Web?

The Web created a need for portable software that could work across different computers and operating systems.

What was Star7?

Star7 was a handheld prototype created by the Green Project to demonstrate interaction with intelligent networked devices.

Who is Duke?

Duke is the Java mascot and originated as an animated character associated with the Green Project demonstrations.

What was WebRunner?

WebRunner was an early browser created to demonstrate interactive programs written using the technology that became Java.

When was Java publicly introduced?

Java was publicly introduced in 1995.

When was JDK 1.0 released?

JDK 1.0 was released in 1996.

What made Java popular in the early Web era?

Portability, the JVM model, and Java applets attracted major attention.

What were Java applets?

Applets were small Java programs designed to run inside compatible web browsers or applet viewers.

Are Java applets still used?

Traditional Java applets are obsolete and are not supported by modern web browsers.

Did Java disappear when applets disappeared?

No. Java became extremely important for backend, enterprise, cloud, and distributed applications.

What was Java 2?

Java 2 was a major platform branding and expansion beginning with J2SE 1.2.

Why was Java 5 important?

Java 5 introduced generics, annotations, enums, enhanced for loops, varargs, and autoboxing.

Why was Java 8 important?

Java 8 introduced lambda expressions, streams, functional interfaces, the modern date and time API, and other major features.

Why was Java 9 important?

Java 9 introduced the Java Platform Module System and JShell.

What is the six-month Java release cycle?

It is the modern model in which new Java feature releases arrive approximately every six months.

What does LTS mean?

LTS means Long-Term Support.

Why are LTS versions important?

Many organizations prefer LTS releases because applicable vendors provide longer support windows.

Who originally owned Java?

Java was created and developed at Sun Microsystems.

When did Oracle acquire Sun Microsystems?

Oracle completed its acquisition of Sun Microsystems in 2010.

What is OpenJDK?

OpenJDK is the open-source reference implementation and development community for the Java Platform, Standard Edition.

What is the JCP?

The Java Community Process is a formal process for developing and revising Java technology specifications.

What is a JSR?

JSR stands for Java Specification Request.

Why has Java survived for so long?

Java has continued evolving while maintaining a large ecosystem, strong tooling, enterprise adoption, JVM performance, community support, and compatibility.

Is modern Java the same as Java from the 1990s?

The core identity remains recognizable, but the language, runtime, libraries, tooling, deployment models, and application architectures have evolved significantly.

Key Takeaways

The project that created Java began in 1991.
Java originated at Sun Microsystems.
The original research effort was called the Green Project.
The original team became known as the Green Team.
James Gosling is widely recognized as the principal creator of Java.
Patrick Naughton and Mike Sheridan were important members of the original project.
The language was originally called Oak.
Oak was created for intelligent consumer electronic devices.
Portability was important because devices could use different hardware.
The Green Project produced the Star7 prototype.
Duke originated from the Green Project and became the Java mascot.
The original consumer electronics opportunity was limited.
The rise of the Internet gave the technology a new direction.
The Web had a major portability problem.
Oak was well suited to networked environments.
WebRunner demonstrated interactive web programs.
Oak was renamed because the original name could not remain the commercial product name.
The language was renamed Java.
Java was publicly introduced in 1995.
JDK 1.0 arrived in 1996.
Write Once, Run Anywhere became a central Java principle.
Applets helped make Java famous.
Modern browsers no longer support traditional Java applets.
Java continued growing after applets declined.
JDK 1.1 expanded important APIs.
Java 2 introduced major platform expansion.
Java 5 introduced generics and annotations.
Java 6 improved platform maturity.
OpenJDK became central to modern Java development.
Oracle acquired Sun Microsystems in 2010.
Java stewardship moved into the Oracle era.
Java 7 introduced useful language and API improvements.
Java 8 introduced lambda expressions and streams.
Java 9 introduced the module system.
Java moved to an approximately six-month release cycle.
Java 10 introduced local variable type inference.
Java remains statically typed when var is used.
Java 11 became an important LTS release.
Java 12 through Java 16 introduced major modern language features.
Java 17 became another important LTS release.
Java 21 introduced important modern concurrency and pattern-matching features.
Modern Java is significantly more capable than early Java.
LTS means Long-Term Support.
Support policies depend on the JDK vendor and distribution.
Java version naming has changed over time.
Java 5 is historically associated with version 1.5.
OpenJDK is central to the Java ecosystem.
The Java Community Process supports specification development.
JSR means Java Specification Request.
Java development evolved from simple command-line tools to modern cloud platforms.
Java applications evolved from applets and desktop programs to enterprise systems and microservices.
Java adapted to cloud computing.
Java survived because it continued evolving.
Java has a large global community.
Java remains important decades after its creation.

Summary

Java began in 1991 as part of the Green Project at Sun Microsystems. The project explored software for intelligent consumer electronic devices that could use different processors and hardware architectures.

James Gosling and the Green Team developed a programming language originally called Oak. The language focused on portability, reliability, security, object-oriented programming, and networked environments.

The Green Project produced demonstrations such as the Star7 device, which included the animated character Duke. Duke later became the Java mascot.

When the original consumer electronics opportunity did not develop as expected, the team recognized that the rapidly growing World Wide Web presented a new problem that Oak was well designed to solve: running software across different computers and operating systems.

The team created WebRunner to demonstrate interactive programs delivered through the Web. Oak was later renamed Java, and the language was publicly introduced in 1995.

JDK 1.0 arrived in 1996. Java became famous for its Write Once, Run Anywhere principle and for applets that could deliver interactive content through supported web browsers.

Although applets eventually disappeared from modern web development, Java expanded into desktop applications, enterprise systems, web backends, financial platforms, distributed applications, cloud services, and microservices.

The language continued evolving through major releases. Java 5 introduced generics and annotations. Java 8 introduced lambda expressions and streams. Java 9 introduced the module system. Later releases added records, pattern matching, sealed classes, virtual threads, and many other modern capabilities.

Java moved from Sun Microsystems to Oracle after Oracle acquired Sun in 2010. Modern Java development also depends heavily on OpenJDK, community participation, standards processes, and contributions from many organizations.

Java now follows a rapid release model, while long-term support releases provide important stability points for organizations. The language has remained relevant because it continuously evolves while maintaining a mature ecosystem, strong tooling, high-performance runtime, large community, and extensive industry adoption.

Lesson 2 Completed

You understand what programming was like before Java.
You understand why the Green Project was created.
You know the important members of the Green Team.
You understand the role of James Gosling.
You know that Java was originally called Oak.
You understand why the name Oak was used.
You understand the original goal of the language.
You understand the Green Project vision.
You know what the Star7 device was.
You know the origin of Duke.
You understand why the project changed direction.
You understand how the rise of the Internet affected Java.
You know what WebRunner was.
You understand why Oak became Java.
You understand the association between Java and coffee.
You know that Java was publicly introduced in 1995.
You understand the importance of JDK 1.0.
You understand the historical importance of Write Once, Run Anywhere.
You understand the role of Java applets.
You understand the early Java architecture.
You know the major Java version milestones.
You understand the importance of JDK 1.1.
You understand the Java 2 era.
You understand the importance of Java 5.
You understand the role of Java 6.
You understand the importance of OpenJDK.
You understand the transition from Sun Microsystems to Oracle.
You understand the importance of Java 7.
You understand why Java 8 was a major turning point.
You understand the importance of Java 9.
You understand the six-month release cycle.
You understand local variable type inference in Java 10.
You understand the importance of Java 11.
You understand the evolution from Java 12 through Java 16.
You understand the importance of Java 17.
You understand the continued evolution from Java 18 through Java 20.
You understand the importance of Java 21.
You understand what modern Java represents.
You understand LTS releases.
You understand how Java naming evolved.
You understand the Java ownership timeline.
You understand the Sun Microsystems era.
You understand the Oracle era.
You understand the role of OpenJDK.
You understand the Java Community Process.
You understand the importance of the Java community.
You understand how Java development evolved.
You understand how Java applications evolved.
You understand why applets disappeared.
You understand how Java moved from monoliths to microservices.
You understand how Java adapted to cloud computing.
You understand why Java has survived for decades.
You are ready to learn JDK, JRE, and JVM.

Next Lesson →