Cloud Parts

Java

A statically typed, object-oriented language that compiles to portable bytecode for the Java Virtual Machine, with a new release every six months.

What it is
Programming languages (run on a virtual machine),Object-oriented programming
Type
Open source
Made by
Oracle / OpenJDK
License
GPL 2.0 with the Classpath Exception (OpenJDK)
Facts checked
8 October 2026
Website Source code

What it is

The javac compiler turns Java source into class files: bytecode and a binary format defined by the Java Virtual Machine Specification, not machine code for one CPU. Any JVM can load the same class files, which is where the old “write once, run anywhere” promise comes from. Memory is managed for you: objects are created with new, there is no pointer arithmetic, and a garbage collector frees what is no longer reachable.

OpenJDK, the open-source reference implementation, ships a feature release every six months, in March and September, on a fixed schedule. Vendors pick some releases for long-term support: Oracle’s LTS releases are 8, 11, 17, 21 and 25, and it plans a new one every two years (Java 29 in September 2027). JDK 27 shipped on September 15, 2026.

Since JDK 21 (September 2023) Java has virtual threads (JEP 444): lightweight threads managed by the JDK rather than the operating system. Thousands or millions of them can exist at once, so plain blocking code written one thread per request scales like asynchronous code, without callbacks.

Why teams pick it

  • Compiled class files run unchanged on any JVM, on any operating system and CPU the JVM supports
  • Garbage collection and no pointer arithmetic rule out whole classes of memory bugs common in C and C++
  • A predictable cadence: a feature release every March and September, plus long-term support releases for teams that upgrade less often
  • Virtual threads let simple thread-per-request servers scale to many concurrent requests without rewriting them as async code

Watch out for

  • A non-LTS release gets only two updates before the next one ships, so you either upgrade every six months or stay on an LTS
  • Virtual threads add scale, not speed: CPU-bound work runs no faster, and blocking while pinned to a carrier thread can still limit throughput
  • Generic type arguments are erased during compilation, so code can’t ask at runtime whether a List holds Strings or Integers

Alternatives

What all run on a virtual machine have in common →
C#Open sourceMicrosoft’s statically typed, object-oriented language for .NET, which made `async` and `await` mainstream and gains a new version every November.ClojureOpen sourceA dynamic Lisp hosted on the JVM, built around immutable persistent data structures and interactive development at the REPL.ElixirOpen sourceA dynamic, functional language on the Erlang virtual machine, created by José Valim: Erlang’s processes, supervisors and hot code loading, with modern tooling, macros and gradual types being added to the compiler.ErlangOpen sourceA dynamically typed functional language from Ericsson, built for systems that must never stop: lightweight processes that share nothing, supervisors that restart what fails, and code that can be upgraded while it runs.F#Open sourceA functional-first language from the ML family that runs on .NET, with type inference, immutable data by default and computation expressions.ScalaOpen sourceA statically typed language that fuses object-oriented and functional programming, compiles to JVM bytecode and calls Java libraries directly.

How it fits with other technologies

Ten thousand blocking tasks, each on its own virtual thread · java

import java.time.Duration;
import java.util.concurrent.Executors;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        long start = System.nanoTime();
        // One virtual thread per task (Java 21+): 10,000 threads are cheap.
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            IntStream.range(0, 10_000).forEach(i ->
                executor.submit(() -> {
                    Thread.sleep(Duration.ofSeconds(1));   // blocks only this virtual thread
                    return i;
                }));
        }   // close() waits for every task to finish
        long ms = (System.nanoTime() - start) / 1_000_000;
        System.out.println("done in " + ms + " ms");   // about a second, not 10,000 seconds
    }
}

See it in a real stack

No architecture uses Java yet. Drop it into the playground and wire it up yourself.Open playground →
Where it came from1991–2023

In June 1991 James Gosling, Mike Sheridan and Patrick Naughton at Sun Microsystems started a research project to build software for network devices and embedded systems. The goal was a small, reliable, portable platform. They began in C++, but its problems grew until the team decided a new language was the better answer. It was first called Oak, after a tree outside Gosling’s office, and was renamed Java.

Sun released Java in May 1995, and Java 1.0 followed in 1996. Its pitch fit the early web: programs compiled once to bytecode would run on any machine with a Java runtime, at a time when software had to be built separately for Windows, Macintosh and many flavors of Unix. Sun released the JVM and class libraries as free software under the GPL from November 2006 to May 2007, and Oracle took over stewardship when it bought Sun in 2009–10.

Big releases used to arrive years apart, held up by their largest feature. In 2017 Mark Reinhold, chief architect of the Java platform, proposed shipping whatever is ready every six months instead. That model started with JDK 10 in March 2018.

Why it’s built this way

Look like C++, minus its complexity
Keeping C++’s syntax and object-oriented feel let C and C++ programmers move over quickly, while dropping features such as pointer arithmetic and manual memory management removed common sources of bugs.
Compile to bytecode for a virtual machine
Software had to run on a mix of hardware and operating systems across a network. Machine-independent bytecode, run by an interpreter and runtime on each platform, meant one build could ship everywhere.
Automatic garbage collection
A collector running in the background frees memory the program no longer uses, which the designers saw as removing entire classes of errors that troubled C and C++ programmers.
Time-based releases every six months
Feature-driven releases slipped while waiting for the biggest feature. A fixed train ships smaller releases on time, and long-term support releases serve teams that can’t upgrade that often.

Timeline

  1. 1991

    Gosling, Sheridan and Naughton start the project at Sun as Oak

  2. 1995

    Sun releases Java in May

  3. 2006

    Sun starts releasing the JVM and libraries under the GPL (finished in May 2007)

  4. 2010

    Oracle completes its acquisition of Sun and becomes Java’s steward

  5. 2018

    JDK 10 is the first release on the six-month train

  6. 2023

    JDK 21 makes virtual threads final

Sources9 · facts checked 8 October 2026

Improve this page on GitHub