Deep Dive into Java

⚡ Enterprise Computing Foundation: Created in 1995 by James Gosling at Sun Microsystems under the slogan “Write Once, Run Anywhere” (WORA), Java is one of the most resilient, high-throughput, and widely adopted software platforms in computing history. From the early days of Oak and J2SE to the architectural rebirth of Jakarta EE, modern Java (Java 17, 21, and beyond) combines 30 years of enterprise maturity with cutting-edge innovations like Virtual Threads (Project Loom) and GraalVM Native Images.

---

1. The Naming & Architectural Eras: From Oak to Modern Java

Understanding Java requires navigating three decades of major rebranding and architectural restructuring:

+---------------------------------------------------------------------------------------------------+
|                                  THE EVOLUTIONARY ERAS OF JAVA                                    |
+---------------------------------------------------------------------------------------------------+
  [1991 - 1995]  ──> Project Oak (Green Team: Gosling, Naughton, Sheridan for set-top boxes)
  [1996 - 1997]  ──> JDK 1.0 & 1.1 (Applets, AWT, early bytecode interpreter)
  [1998 - 2004]  ──> "Java 2" Era (Split into J2SE, J2EE, J2ME; HotSpot JIT introduced)
  [2004 - 2009]  ──> Java 5 & 6 (Renamed Java SE / Java EE; Generics, Concurrency utils, Annotations)
  [2010]         ──> Oracle acquires Sun Microsystems
  [2014 - 2017]  ──> Java 8 & 9 (Lambdas, Streams API, JPMS Project Jigsaw modularization)
  [2018 - 2020]  ──> 6-Month Release Cadence; Oracle donates Java EE to Eclipse ──> Jakarta EE
  [2021 - 2026+] ──> Modern Cloud-Native Era (Java 17/21/25 LTS, Project Loom, Panama, GraalVM)
+---------------------------------------------------------------------------------------------------+

The Three Classic Editions

In 1998, with the release of Java 2 (JDK 1.2), Sun Microsystems divided the ecosystem into three distinct target profiles:

1. J2SE (Java 2 Standard Edition): Core desktop and workstation runtime containing java.lang, java.util, java.io, networking, and basic GUI toolkits.
2. J2EE (Java 2 Enterprise Edition): Multi-tier, distributed enterprise computing specifications (Servlets, JSP, EJB, JMS, JTA).
3. J2ME (Java 2 Micro Edition): Memory-constrained mobile devices, set-top boxes, and early embedded hardware.

Note: In 2006 with version 5.0, Sun dropped the “2” and simplified the branding to Java SE, Java EE, and Java ME.

---

2. The Enterprise Saga: From J2EE to Java EE to Jakarta EE

The evolution of enterprise Java is one of the most consequential stories in modern software engineering:

[1999: J2EE 1.2] ──> Heavyweight XML-configured EJBs, RMI, Application Servers (WebLogic, WebSphere)
        │
        ├──> [2003: The Spring Revolution] (Rod Johnson's "Expert One-on-One J2EE Design" ──> POJOs & IoC)
        │
[2006: Java EE 5] ──> Overhaul: Annotation-driven EJBs, JPA replaces complex Entity Beans
        │
[2017: Eclipse Transfer] ──> Oracle transfers Java EE rights to the open-source Eclipse Foundation
        │
[2019: The javax.* Dispute] ──> Oracle retains "Java" trademark; namespace forced to migrate to "jakarta.*"
        │
[2020: Jakarta EE 9+] ──> The Big Bang Migration: javax.servlet.* ──> jakarta.servlet.*
        │
[2023+: Modern Era] ──> Spring Boot 3, Quarkus, Helidon, Micronaut 100% on Jakarta EE & Cloud Native

Phase 1: Heavyweight J2EE & The Spring Rebellion (1999–2004)

Early J2EE was notoriously complex. Enterprise JavaBeans (EJB 1.x and 2.x) required dozens of interfaces, deployment descriptors, home/remote stubs, and slow redeployments on monolithic application servers.

In 2002, Rod Johnson published Expert One-on-One J2EE Design and Development and released the Spring Framework, introducing Inversion of Control (IoC), Dependency Injection (DI), and lightweight Plain Old Java Objects (POJOs). Spring proved that enterprise applications did not require complex distributed EJB containers.

Phase 2: Java EE Modernization (2006–2013)

Reacting to Spring’s success, Java EE 5 and 6 reinvented enterprise standards:

• JPA (Java Persistence API): Replaced cumbersome Entity Beans with standardized ORM annotations (inspired by Hibernate).
• CDI (Contexts and Dependency Injection): Standardized typesafe dependency injection.
• JAX-RS: Standardized declarative RESTful API development.

Phase 3: The Transition to Jakarta EE & The javax.* Namespace Shift (2017–Present)

In 2017, Oracle transferred stewardship of Java EE to the Eclipse Foundation to foster faster community-driven open-source innovation. However, because Oracle retained the intellectual property rights to the javax trademark, existing package names could no longer be modified.

This led to the “Big Bang” namespace migration:

• Jakarta EE 8: Binary-identical to Java EE 8 using javax.*.
• Jakarta EE 9 & 10+: All APIs migrated from javax.* to jakarta.* (e.g. javax.servlet.* became jakarta.servlet.*, javax.persistence.* became jakarta.persistence.*).
• Spring Boot 3.0+ & Modern Frameworks: Dropped legacy javax.* dependencies and fully embraced Jakarta EE 10.

---

3. HotSpot JVM Architecture & Memory Subsystems

The Java Virtual Machine (JVM) is a sophisticated runtime execution engine designed to dynamically optimize bytecode into high-speed native CPU instructions.

+---------------------------------------------------------------------------------------------------+
|                                      HOTSPOT JVM ARCHITECTURE                                     |
+---------------------------------------------------------------------------------------------------+
  [Class Loading Subsystem] (Bootstrap ClassLoader ──> Platform ClassLoader ──> App ClassLoader)
                                            │
                                            v
  [JVM Runtime Data Areas]
  ├── Heap Memory (Objects & Arrays)
  │   ├── Young Generation (Eden Space ──> Survivor 0 [S0] ──> Survivor 1 [S1])
  │   └── Old / Tenured Generation (Long-lived objects)
  ├── Non-Heap Memory
  │   ├── Metaspace (Class metadata, native memory; replaced PermGen in Java 8)
  │   ├── Code Cache (JIT compiled machine code)
  │   └── Thread Stacks (Stack frames, primitive locals, object references [default 1 MB])
                                            │
                                            v
  [Execution Engine]
  ├── Bytecode Interpreter
  ├── Tiered JIT Compilers:
  │   ├── C1 (Client Compiler): Fast compilation with basic profiling
  │   └── C2 (Server Compiler): Heavy speculative optimization (Inlining, Escape Analysis, Vectorization)
  └── Low-Latency Garbage Collectors (G1 GC, ZGC [sub-ms STW], Shenandoah, Parallel)
+---------------------------------------------------------------------------------------------------+

---

4. Modern Java Engineering: Virtual Threads (Project Loom)

Before Java 21, Java threads mapped 1:1 to heavy Operating System kernel threads (~1 MB stack per thread). A server could rarely scale beyond a few thousand concurrent connections without resorting to complex reactive code (Reactive Streams / WebFlux).

Enter Virtual Threads (Java 21 LTS)

Virtual Threads are lightweight user-mode threads managed entirely by the JVM runtime. You can spawn millions of concurrent virtual threads with trivial memory overhead (~few hundred bytes initial stack):

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.List;
import java.util.concurrent.Executors;

public class VirtualThreadDemo {
    public static void main(String[] args) throws Exception {
        // Create an Executor that spawns a new Virtual Thread per task
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            var client = HttpClient.newHttpClient();
            var urls = List.of(
                "https://api.github.com/repos/astral-sh/uv",
                "https://api.github.com/repos/oven-sh/bun",
                "https://api.github.com/repos/golang/go"
            );

            for (String url : urls) {
                executor.submit(() -> {
                    var request = HttpRequest.newBuilder().uri(URI.create(url)).build();
                    var response = client.send(request, HttpResponse.BodyHandlers.ofString());
                    System.out.printf("[%s] Status: %d (Running on %s)%n", 
                        url, response.statusCode(), Thread.currentThread());
                    return response.body();
                });
            }
        } // Automatically awaits completion of all virtual threads
    }
}

💡 Why Loom Changes Everything: When a virtual thread executes blocking I/O (like database queries or HTTP calls), the JVM automatically unmounts it from the underlying carrier OS thread, allowing the carrier thread to execute other work. Developers write clean, synchronous, imperative code with massive reactive-level throughput.

---

5. Modern Language Features (Java 17 to Java 25)

5.1 Records & Pattern Matching

// Immutable data carrier with automatic constructor, getters, equals, and hashCode
public record User(String username, String role, boolean active) {}

public class SecurityService {
    public static String evaluateAccess(Object entity) {
        return switch (entity) {
            case User(var name, "ADMIN", true) -> "Full administrative access granted for: " + name;
            case User(var name, "MEMBER", true) -> "Standard member access for: " + name;
            case User(var name, _, false)       -> "Access denied: Account inactive for: " + name;
            case null                           -> "Unauthenticated request";
            default                             -> "Unknown entity type";
        };
    }
}

5.2 Sealed Classes (Domain Modeling)

// Sealed interface permits only an explicit set of subtypes
public sealed interface PaymentStatus permits Pending, Completed, Failed {}

public record Pending(String transactionId) implements PaymentStatus {}
public record Completed(String transactionId, long timestamp) implements PaymentStatus {}
public record Failed(String transactionId, String reason) implements PaymentStatus {}

---

6. Enterprise Framework Ecosystem Comparison

Dimension	Classic J2EE / EJB	Spring Boot 3.x	Quarkus (Red Hat)	Micronaut
Configuration	Heavyweight XML	Annotation-driven + AutoConfig	Build-time augmented	Ahead-Of-Time (AOT) compiler
Namespace Standard	javax.*	jakarta.* (EE 10)	jakarta.* (EE 10)	jakarta.* (EE 10)
Startup Time	Slow (Minutes)	Moderate (Seconds)	⚡ Sub-second (JVM) / 10ms (Native)	⚡ Sub-second
GraalVM Native Image	❌ No	✅ Full AOT support	✅ Built-in first class	✅ Built-in first class
Virtual Threads	❌ No	✅ Supported (spring.threads.virtual.enabled=true)	✅ Supported (@RunOnVirtualThread)	✅ Supported
Primary Domain	Legacy Banking Monoliths	Enterprise Microservices	Serverless, Kubernetes, Microservices	Cloud-native Microservices

---

7. Summary & Quick Reference

# 📦 CLI Environment (via SDKMAN!)
sdk list java                  # Browse Temurin, Corretto, GraalVM distributions
sdk install java 21.0.4-tem    # Install latest Java 21 LTS
sdk default java 21.0.4-tem    # Set global workstation default

# 🚀 Compilation & Single-File Execution
java Application.java          # Single-file source-code execution without manual javac
javac --release 21 Main.java   # Compile to bytecode targeting specific Java version
java -XX:+UseZGC Main          # Execute with sub-millisecond Z Garbage Collector

Java’s ability to continuously reinvent its internal architecture while maintaining backward compatibility makes it an enduring titan of high-throughput software engineering.