World inTimelines

Timeline of Java

Java from Sun's Green Project in 1991 to Java 27 in 2026: portable bytecode, enterprise software, open-source development, Android, language changes, and lightweight concurrency.

Category
Engineering & Technology
Tag
computing
Events
19 events 1991 – 2026
Generated
by gpt-6

  1. Sun starts the Green Project

    James Gosling, Mike Sheridan, and Patrick Naughton began Sun Microsystems' Green Project to investigate software for consumer electronics. Gosling developed Oak, a language designed to run across different devices, which later became Java.

    https://en.wikipedia.org/wiki/Oak_(programming_language)

  2. Sun publicly introduces Java

    Sun Microsystems announced Java at its SunWorld conference on May 23. Demonstrations of programs running inside the HotJava browser connected portable bytecode and the Java virtual machine to the rapidly expanding World Wide Web.

    https://en.wikipedia.org/wiki/Java_(programming_language)

  3. Java's first development kit ships

    Sun Microsystems released version 1.0 of the Java Development Kit. The compiler, runtime, and libraries gave developers a supported platform for building applications and browser applets, with automatic memory management and machine-independent bytecode.

    https://en.wikipedia.org/wiki/Java_Development_Kit

  4. Java standardizes access to relational databases

    Java 1.1 included Java Database Connectivity, a standard interface for database drivers. Applications could use a common programming model to send queries and retrieve results from different database systems, strengthening Java's role in business software.

    https://en.wikipedia.org/wiki/Java_Database_Connectivity

  5. Java 2 expands desktop and library support

    Sun Microsystems released Java 1.2 under the Java 2 branding. The release incorporated Swing for graphical interfaces and the Collections Framework for reusable data structures, substantially expanding the standard platform's application-building tools.

    https://en.wikipedia.org/wiki/Java_version_history

  6. Sun releases an enterprise Java platform

    Sun Microsystems introduced Java 2 Platform, Enterprise Edition, bringing server-side specifications into a coordinated platform. Common services for web applications, transactions, and enterprise components allowed competing application servers to implement the same programming contracts.

    https://en.wikipedia.org/wiki/Jakarta_EE

  7. HotSpot joins the standard Java runtime

    Java 1.3 incorporated the HotSpot virtual machine, which had first appeared as a separate release. Adaptive compilation optimized frequently executed code while the program ran, helping address the performance limitations associated with interpreting bytecode.

    https://en.wikipedia.org/wiki/HotSpot

  8. Eclipse opens an extensible development environment

    IBM and partner companies launched Eclipse as an open-source development platform. Its Java tools combined editing, compilation, debugging, and refactoring, while a plug-in architecture let vendors and developers extend the environment.

    https://en.wikipedia.org/wiki/Eclipse_(software)

  9. Java adds generics and annotations

    Java 5 introduced generics, annotations, enumerations, and an enhanced loop syntax. Generics let libraries express the types of their elements without repeated casts, while annotations supplied structured metadata for frameworks and development tools.

    https://en.wikipedia.org/wiki/Generics_in_Java

  10. Sun begins opening Java's implementation

    Sun Microsystems released the Java compiler and HotSpot virtual machine under the GNU General Public License and launched the OpenJDK community. Most remaining platform code followed in 2007, establishing a shared open-source basis for Java implementations.

    https://en.wikipedia.org/wiki/OpenJDK

  11. Android gives Java a new mobile audience

    Android 1.0 and its development tools shipped, using Java as the principal language for third-party applications. Android converted compiled Java classes into its own Dalvik executable format, creating a large mobile ecosystem with a runtime distinct from desktop Java.

    https://en.wikipedia.org/wiki/Android_software_development

  12. Oracle acquires Java's corporate steward

    Oracle completed its acquisition of Sun Microsystems, taking responsibility for Sun's Java products and much of the platform's engineering. Java development continued through the OpenJDK community and the Java Community Process under new corporate stewardship.

    https://en.wikipedia.org/wiki/Acquisition_of_Sun_Microsystems_by_Oracle_Corporation

  13. Java embraces lambdas and streams

    Java 8 added lambda expressions, method references, and a Streams library for processing collections. Default methods let interfaces evolve with implementations, helping existing libraries adopt a more functional programming style without replacing Java's object model.

    https://en.wikipedia.org/wiki/Java_(programming_language)

  14. Java introduces modules and faster releases

    Java 9 delivered the module system developed through Project Jigsaw, making dependencies and exported packages explicit. Oracle also announced a move to releases every six months, separating the delivery of smaller improvements from long waits for major features.

    https://en.wikipedia.org/wiki/Java_Platform_Module_System

  15. Enterprise Java adopts the Jakarta name

    The Eclipse Foundation established Jakarta Enterprise Edition as the name and governance framework for enterprise Java technologies being transferred by Oracle. The change moved further development of the server-side platform toward a foundation-led specification process.

    https://en.wikipedia.org/wiki/Jakarta_EE

  16. Java finalizes records and pattern matching

    Java 16 finalized records and pattern matching for instanceof after preview releases. Records reduced the code needed for data-carrying classes, while type patterns combined a type test and variable binding in a single construct.

    https://en.wikipedia.org/wiki/Java_version_history

  17. Java makes virtual threads a standard feature

    Java 21 finalized virtual threads after previews in earlier releases. The runtime could schedule many lightweight Java threads over a smaller pool of operating-system threads, letting server programs handle blocking operations without allocating a dedicated native thread for every task.

    https://en.wikipedia.org/wiki/Virtual_thread

  18. Java simplifies small programs and constructors

    Java 25 finalized compact source files, instance main methods, and more flexible constructor bodies. The release reduced the declarations needed for small programs and allowed suitable statements before a constructor's call to its superclass.

    https://en.wikipedia.org/wiki/Java_(programming_language)

  19. Java adds hybrid quantum-resistant key exchange

    Java 27 added hybrid key exchange for Transport Layer Security 1.3, combining a traditional algorithm with one designed to resist quantum attacks. The release brought quantum-resistant negotiation into Java's standard secure networking implementation.

    https://en.wikipedia.org/wiki/Java_version_history