Our website uses cookies to enhance your browsing experience.
From inception to conquering the Red Planet. This article explores Java's history: from its first steps and legal battles with Microsoft to essential tools every Java developer relies on. And yes—you'll discover why oak trees, coffee, and an island play starring roles.
Sun Microsystems launched the Java programming language project. Engineers James Gosling, Mike Sheridan, and Patrick Naughton spearheaded the development. Their core mission was to create a universal language capable of running on diverse electronic devices—from bank cards and kitchen appliances to TV remotes.
One major hurdle stood out: manufacturers used controllers with different processors and architectures. This made creating a single codebase for all devices impossible. To overcome this, the team prioritized avoiding rigid ties to specific hardware or operating systems.
What was their ingenious solution? Instead of compiling source code directly into machine code for a specific processor, Java adopted an intermediate representation called bytecode. This bytecode ran inside the Java Virtual Machine (JVM), enabling platform independence. As a result, any device with a compatible JVM could execute the same bytecode.
Initially, Gosling named the language Oak—inspired by an oak tree outside their office. But during the official launch preparation, they discovered Oak Technologies already held the trademark.
The language rebranded as Java, evoking Indonesian coffee from Java Island. In one version, coffee symbolized everyday tech (like coffee makers) that Java initially targeted for programming.
After seven years of development, Java 1.0 debuted in 1996. This marked Java's emergence as a platform-independent, flexible, and versatile programming tool.
Starting with Windows 98, Microsoft bundled its own Java Virtual Machine (MSJVM) into the OS and Internet Explorer (starting from the third version). But MSJVM deviated from Sun's specification, dropping key components like remote method invocation (RMI) and Java native interface (JNI). What's more, Microsoft added Windows-only features, incompatible with the original specification, like Java and DCOM integration tools.
These changes sabotaged Java's cross-platform basic principle. This prompted serious complaints from Sun Microsystems, resulting in lawsuits against Microsoft. During the proceedings, the court found Sun Microsystems to be correct, which led to the termination of Microsoft's stand-alone support for the JVM. Under the terms of the agreement, Microsoft supported its virtual machine until 2007, followed by the permanent project shut down.
JDK 1.2 introduced such sweeping changes that Sun rebranded the platform to Java 2 Platform Standard Edition (J2SE 1.2). This marked a new stage of the Java ecosystem development.
The strictfp keyword starts off the list of key innovations. This modifier restricts calculations with floating point numbers. It ensures consistent floating-point calculations across platforms, regardless of hardware implementation and operating system differences. This feature is essential for Java, striving for complete platform-independence.
J2SE 1.2 also introduced a new library for creating graphical interfaces, Swing. Built atop Abstract Windows Toolkit (AWT), Swing surpassed AWT in functionality and provided an expanded set of custom components such as buttons, lists, tables, and panels. Swing's components were lightweight, which added to the value. This meant that they didn't depend directly on native OS windowing elements, making the interfaces more portable and customizable.
In addition to Swing, this Java version added Collections Framework, a fundamental framework for working with different types of data collections. Before this, Java only had basic structures such as arrays, vectors, and hash tables. Without a uniform interface, each structure had to be handled differently. The Vector class, for example, was inconvenient to extend because most of its methods were declared as final. The collection framework allowed to unify different data structures under uniform interfaces, making it more versatile and convenient to work with them.
The Java Virtual Machine (JVM) has taken another major technological step—included just-in-time (JIT) compilation. The firstly used Sun JIT compiler boosted performance by compiling bytecode to machine code at runtime, speeding up execution compared to interpretation.
Additionally, full Unicode support added in J2SE 1.2 enabled developers to work with texts in various languages. This paved the way for making Java a universal language for developing global and multilingual applications.
JetBrains released IntelliJ IDEA, an integrated development environment designed around the Java language. At that time, IntelliJ IDEA stood out among its competitors due to advanced features not previously available in other products. In particular, IntelliJ IDEA revolutionized Java IDEs with advanced code navigation and refactoring tools that simplified and accelerated the development process.
Eight years later, in 2009, JetBrains made a strategic decision to open the IntelliJ IDEA source code and release it under the free Apache 2.0 license. The product was split into two versions. The first, Community Edition, included all components distributed as an open-source solution. The second, Ultimate Edition, remained proprietary and provided additional tools designed for professional development.
Opening the source code boosted the development of other IntelliJ IDEA-based solutions. Its most well-known offshoot is Android Studio: Google's official development environment for Android apps, created jointly with JetBrains. In 2020, the Chinese company Huawei created its own IntelliJ IDEA-based IDE, DevEco Studio, intended for developing apps for the HarmonyOS.
IntelliJ IDEA rapidly gained traction with professionals. As early as 2010, InfoWorld ranked this IDE as a top Java tool, giving it the highest rating compared to other solutions on the market.
JetBrains stands as a leading creator of professional developer tools today. It creates IDEs for Java and other programming languages, including Python, JavaScript, C++, Go, and others.
In November 2001, Eclipse emerged as another IDE for Java. Eclipse was heavily influenced by the VisualAge IDE, created by IBM and based on the SmallTalk language. VisualAge had a reputation as a powerful yet complex and monolithic system. So, when developing Eclipse, the creators redesigned its architecture: the new IDE was designed as a modular and extensible platform with plugin support, which became one of its key advantages.
The launch of Eclipse marked a significant step towards open-source software. That same November 2001, a dedicated consortium—the Eclipse Consortium—was formed. Its task was to coordinate efforts for the platform's development. Major IT companies joined this consortium, including Borland, IBM, Merant, QNX Software Systems, Rational Software, Red Hat, SuSE, TogetherSoft, and WebGain. The board of directors managed the consortium and made key decisions about the platform's future. Membership grew rapidly, and by 2003, it already included over 80 organizations.
For many years, Eclipse remained the most popular IDE for Java development due to its open-source nature, flexibility, vast number of plugins, and robust community support. However, in 2016, IntelliJ IDEA ultimately took over the leadership.
In October 2002, Rod Johnson published the book "Expert One-on-One J2EE Design and Development", offering a critical assessment of Java EE—the primary standard for building enterprise Java applications at that time. The author highlighted its excessive complexity, bulkiness, high cost, and the difficulties developers faced when using the platform. As an alternative, Rod suggested a simpler, more flexible approach based on plain Java classes and the dependency injection mechanism. This approach quickly garnered community's attention by addressing many inherent issues of Java EE.
As early as 2003, Johnson, alongside Jürgen Höller and Yann Caroff, began developing a new open-source framework named Spring. That same June, the first public version—Spring 0.9—was released under the Apache 2.0 license, followed by the Spring 1.0 release in 2004. Thanks to its simplicity, easy configuration, use of IoC and AOP principles, and its support for POJOs (whereas Java EE relied on EJB components with limitations), Spring rapidly gained popularity as a Java EE alternative.
Unlike Java EE, which required heavyweight containers and strict adherence to standards, Spring offered a more modular, configurable, and intuitive development approach. Spring Boot further simplified initial setup and app deployment, making Spring especially attractive to developers prioritizing development speed and flexibility. Despite potentially less performant and less standardized than Java EE, Spring has won widespread adoption due to its adaptability, open-source code, and active community development. It emerged as a direct response to Java EE's shortcomings and remains one of the most in-demand Java frameworks today.
In 2002, Microsoft introduced a new programming language for the .NET platform: Visual J#. Despite its similarities, this language wasn't a full implementation of Java, but only mimicked its syntax and structure. Unlike genuine Java, Visual J# didn't require installing the Sun JDK and generated executable code for the .NET Framework runtime environment, also known as the Common Language Infrastructure (CLI), rather than for the Java Virtual Machine (JRE).
The primary goal behind Visual J#'s creation was to facilitate the migration of developers from Java to the .NET platform. However, the idea failed to gain widespread acceptance and support. The language didn't become popular among developers, and as a result, it was removed from the Visual Studio 2008 development environment.
The new Java 5.0 was released on September 30, 2004. This version marked a change in the official version numbering scheme. As you may have noticed, it was called Java 5.0, not Java 1.5, as all previous versions had been numbered.
This update introduced enumerations (enum). Their implementation was based on similar functionality in C++. However, Java's enums offered several additional capabilities. An enum in Java is a full-fledged class, meaning it can have methods (including private and abstract ones), fields, and a constructor. Java enums can also implement interfaces and have built-in methods.
Annotations appeared, allowing developers to add meta data to the program text. This metadata does not directly affect the program execution, but it provides information about the code and how it is executed. Alongside annotations, this version also added tools for working with them.
Generics! The version 5.0 introduced means for generic programming! From this point on, Java allowed the creation of classes and methods with fields and parameters of arbitrary object types. This new mechanism was also used to implement new versions of the standard library collections.
Javadoc comments also emerged, enabling automatic generation of documentation based on their content.
Autoboxing/unboxing appeared—the automatic conversion between primitive types and their corresponding wrapper types. This helped shorten code by eliminating the need for explicit type conversions in the most obvious cases.
Additionally, the new version introduced:
forEach loops;Java's journey to space applications began in 1995 when experts at NASA's Jet Propulsion Laboratory (JPL) became interested in using the language for their own projects. The primary goal was to create software for commanding and controlling the Mars Sojourner rover—the first mobile robotic vehicle on Mars.
Java's creator, James Gosling, personally visited the NASA lab in Pasadena and took a great interest in the proceedings. He didn't just observe the processes; over time, he became so deeply involved in the team's work and joined their advisory board. In an interview with Reuters, he admitted, "I'm a geek anyway, so it sucks me in,"—emphasizing that the technical complexity and scale of the tasks completely captivated him.
The NASA lab's work with Java ultimately resulted in the creation of specialized software that allowed controlling the Spirit rover (MER-A) almost as intuitively as if the engineers were playing a racing simulator. This demonstrated Java's capabilities in real-time systems and in conditions where reliability is critically important.
In 2009, researchers Jan Vitek, Martin Děcký, and Marco Zulianello published a paper titled "Real-time Java in Space: Potential Benefits and Open Challenges". In it, they thoroughly examined the advantages of using Java in space projects. They noted several strong points of the language, including its widespread adoption, which makes development easier; an active community, support for object-oriented principles, type safety, and the possibility of spatial thread separation. This last advantage is especially important in systems with critical fault-tolerance requirements.
Today, NASA actively uses Java in a number of its programs, some of which are open source.
Note: We've recently posted an article about how NASA made a mistake in the planetary source code. You can read it here.
Apache Maven is a framework for automating project builds based on describing their structure in POM (Project Object Model) files using XML. It is delivered by the Apache Software Foundation community and is part of the Jakarta Project—a project for developing and supporting open-source software in Java.
Maven provides declarative builds: project specification files contain project description, not individual execution commands. Both built-in and external plugins handle the processing of files described in the specification.
The Maven development began back in 2002, initially as a sub-project of Apache Turbine—a servlet-based framework that allowed experienced Java developers to quickly create web applications.
However, by 2003, Maven was qualified as a top-level project. In 2004, the first version, Maven 1.0 emerged. Yet, due to the rush to release versions, various problems arose, ranging from excessive configuration to performance issues.
So, in 2005, the parallel development of Apache Maven 2.x began, and Apache 2.0 was released on October 19 of that year.
But wait, there's more. In 2008, the development of Apache Maven 3.0 started. To create this version, developers needed to rewrite the architecture of Maven 2, as the old one was monolithic and difficult to extend. The authors improved the dependency management system, added support for multi-threaded builds, and introduced stricter validation of POM files. Furthermore, they replaced outdated internal mechanisms (such as Plexus) with more reliable and flexible solutions to enhance stability and extensibility.
So, it is Apache Maven version 3.0—that very Maven we know and love.
In 2008, the first version of the Gradle 0.1 build automation tool came out. The project was launched as open source and developed under the direction of Hans Dockter, who later became the founder and CEO of Gradle Inc. Adam Murdoch, one of the first developers to make key contributions to the system architecture, worked on Gradle alongside him.
Gradle emerged as a modern alternative to Apache Ant and Apache Maven. It adopted their core concepts but delivered greater flexibility. Unlike Maven, which relied on bulky XML files to describe builds, Gradle enabled users to define build logic using Groovy—and later Kotlin—making scripts more readable, dynamic, and concise.
One of Gradle's technical breakthroughs was applying a Directed Acyclic Graph (DAG) to calculate the task order. This architecture enabled Gradle to precisely define task dependencies, efficiently optimize builds, and eliminate repetitive actions. This has become especially relevant for large projects with many modules and dependencies.
The story behind the tool name is quite interesting. Hans Dockter originally chose the name "Cradle". However, he thought it sounded too bland and unoriginal. He later prefixed "G" from Groovy that was actively used in the project.
Sun Microsystems' 2009 revenue dropped 17.5% year-over-year. The company laid off 1,300 employees, targeting 6,000 total layoffs.
Rumors surfaced about Sun's sale—first to Hewlett-Packard, then IBM.
On April 20, Oracle officially announced its acquisition agreement. Oracle cited Java as the primary motivation, calling it "...the most important software Oracle has ever acquired." TechRepublic noted Oracle aimed to become "Apple for developers," offering everything from software to hardware.
The $7.4 billion deal closed on January 27, 2010.
Java SE 8.0 (Octopus) launched on March 19, 2014.
Lambda expressions revolutionized coding by enabling concise inline behavior at the point of invocation. They streamlined handling collections and data flows, which resulted in shorter and more efficient code.
The Stream API, a powerful tool for declarative data processing, came along with it. It enabled working with collections as streams using filtering, sorting, grouping, and other operations. It also simplified parallel data processing via parallelStream().
Java 8 also introduced default methods in interfaces (default). This solved a long-standing problem: the incapability to add new methods to interfaces without breaking backward compatibility. Interfaces could now include implementation, which made them more flexible and extensible.
A significant improvement also arrived for date and time handling. The new java.time package, inspired by the popular Joda-Time library, replaced the outdated and cumbersome Date and Calendar classes. It offered developers a safe, predictable, and convenient API for working with temporal values.
Another major innovation was the Optional class—a container designed to safely represent the possible absence of a value. Optional helps eliminate null checks, minimizes the risk of a NullPointerException, and encourages cleaner programming practices.
Finally, Java 8 formalized the concept of functional interfaces. These are interfaces annotated via@FunctionalInterface and containing exactly one abstract method. This became the foundation for lambdas and enabled creating generic, flexible constructs with minimal boilerplate code. Standard interfaces like Predicate, Function, Consumer, and others were added alongside this and are now widely used in everyday development.
Overall, Java 8 marked a turning point. The language became more expressive, modern, and user-friendly for writing readable and safe code. These changes laid the groundwork for all subsequent versions.
Moreover, Java 8.0 remains quite popular and is still used in projects today. Why? Migration between versions presents challenges, but there's another catch. Oracle, Java's new owner, changed the Oracle JDK licensing terms in 2019. This sparked a serious discussion within the community: "Is Java no longer free?" Even though the Oracle-supported OpenJDK version still existed.
Java 11, which focuses on performance, developer convenience, and security, was released on September 25, 2018. It introduced significant improvements to the platform and language syntax.
One notable innovation was the experimental Epsilon garbage collector. Its key feature was the complete absence of a memory freeing mechanism: it only allocated memory, never returning it back. This made it a useful tool not only for testing application and JVM performance but also for load testing where eliminating garbage collection's influence is crucial and long-term program execution isn't required.
At the same time, Java 11 introduced another new garbage collector: ZGC. Designed with a focus on scalability and minimal pauses, ZGC leveraged technologies like concurrent object relocation, multi-mapping memory, compressed pointers, and adaptive thread scheduling. This enabled ZGC to achieve latency under one millisecond, which is critical for high-responsive applications. ZGC became stable and production-ready with the release of Java 15.
At the syntax level, Java 11 added the capability to use the var keyword in lambda parameters. This made the coding style more consistent with local variables, where var had been available since Java 10, improving code readability and uniformity.
Another important change was the new HTTP client becoming a standard platform component. It fully supported the HTTP/2 protocol and replaced the outdated HttpURLConnection. This client first appeared experimentally in Java 9 and now permanently replaced older solutions.
Additionally, Java 11 gained support for Unicode 10.0 and the TLS 1.3 encryption protocol, enhancing compatibility and security for modern applications.
In summary, Java 11 strengthened the platform performance, testing, networking capabilities, and security, continuing the modernization of the language and infrastructure.
Version 7.00 of PVS-Studio static code analyzer introduced Java projects analysis. This first version already included 66 diagnostic rules.
The Java analyzer was built on the core logic of the C++ analyzer, packaged as a separate library and used alongside the Java parser. Thus, the first Java analyzer version incorporated 10 years of static analyzer development experience.
New plugins also became available to users, making the analyzer much more convenient:
By 2024, analyzing Java projects became possible also with the PVS-Studio plugin for Visual Studio Code. That same year, the analyzer gained a taint analysis mechanism, enabling a stronger focus on diagnostic rules related to Java code security.
Note: You can try PVS-Studio static code analyzer on your project using a trial license.
The new LTS version of Java, the 17th overall, was released on September 14, 2021, introducing many language innovations.
One of the most noticeable syntactic changes was sealed classes and interfaces. This construct allows restricting the list of classes that can inheritor implement a given type. This approach strengthens control over application architecture, makes inheritance models more predictable, and improves code safety and maintainability.
Support for the new switch syntax was also expanded, making it more expressive. Now switch could use not just values, but also object types. This simplified implementing type-dependent logic and brought Java closer to pattern matching capabilities.
An important step towards Java interacting with native code was the experimental Foreign Function & Memory API. This API provided a safe and efficient way to call native libraries and work with memory outside the JVM's managed environment, paving the way for tighter integration with system resources and high-performance libraries.
Useful additions also appeared in the standard library. For example, the HexFormat class in java.util offered convenient handling of hexadecimal representations, useful for processing binary data. The java.time package gained the InstantSource interface and enabled mocking the current time. This made it easier to write tests for time-dependent components.
Finally, Java 17 continued improving cross-platform performance, notably by introducing the new Apple Metal graphics pipeline for 2D graphics on macOS. This increased rendering efficiency and improved compatibility with modern graphics standards.
As a result, Java 17 solidified the platform's foundation, making it safer, more manageable, and modern, without introducing overwhelming changes. This release marked the logical culmination of several major development initiatives that began in previous versions.
The next LTS version of Java was released on September 19, 2023. Java 21 continued evolving the language and platform, emphasizing scalability, expressiveness, and safety. This version stabilized and officially incorporated features that were previously experimental, significantly expanding developer capabilities.
One headline event was the introduction of virtual threads—lightweight execution threads that greatly simplify creating scalable concurrent applications. They enable efficient handling of thousands of parallel tasks without overloading system resources, which is vital for server and cloud applications.
Java syntax became simpler and more expressive. String templates and text blocks made working with strings easier. Unnamed variables and patterns allowed convenient value extraction from complex objects. The ability to write programs without specifying a class name (top-level statements) simplified script and utility creation.
The standard collections library gained new SequencedCollection, SequencedSet, and SequencedMap interfaces that ensure element order preservation. This is particularly important when data sequence impacts application logic.
From a security perspective, Java 21 introduced the Key Encapsulation Mechanism (KEM) API—a modern cryptographic tool designed for the secure transmission of symmetric keys. This is a crucial update for implementing secure protocols and network interactions.
Furthermore, the language continued removing legacy elements, simplifying platform support, and reducing technical debt.
Java 25—the next LTS version—is expected in September 2025, continuing the development of the language and virtual machine.
Project Valhalla is under development—a major OpenJDK initiative aimed at modernizing Java's object model.
In Java's current model, all objects are stored on a heap. Accessing the heap is typically slower than accessing primitive types or structures placed directly on a stack or in contiguous memory. Furthermore, many heap objects increase garbage collector load.
Project Valhalla introduces value objects. These objects are compared by content, not reference, and stored like primitives directly in memory, without extra wrapping.
Such changes will accelerate memory operations, reduce garbage collector load, and improve collection performance.
Despite being under development, some planned Valhalla changes already appeared in previous Java versions (JEP 181, JEP 309, JEP 334, JEP 390, JEP 371).
Project Loom is also in development. Its goal is to simplify and enhance Java concurrency, making it more scalable, efficient, and intuitive.
Java's current threading model relies on platform threads managed by the operating system. These threads are resource-intensive and difficult to scale: creating tens or hundreds of thousands is costly and inefficient.
A significant part of Project Loom is already implemented: virtual threads became stable part of the platform (mentioned in the Java 21 section), but an equally substantial part remains unfinished.
Structured concurrency is under development—an approach where all child threads start and finish within a specific code block. This simplifies thread lifetime management and makes code safer and more predictable.
Scoped values are also still being developed—an alternative to ThreadLocal that safely passes values into virtual threads without leak or conflict risks, useful for context-sensitive tasks.
Here our journey through Java's history comes to an end. It's been an exciting adventure: we've explored various technical innovations and technologies, as well as the context surrounding the language and its development.
Please note that the selection of events in this article reflects the author's perspective and might differ from what you'd expect in such a note. If you think we left something out, feel free to share it in the comments below!
If you're interested in the history of other programming languages, check out our series of articles on the topic:
See you!
0
0
0
Your message has been sent. We will email you at
If you do not see the email in your inbox, please check if it is filtered to one of the following folders:
16
0
0