Understanding Java JEPs: The Engine Behind JDK Evolution

Java is a constantly evolving platform, with a new version released every six months. Each release brings updates to the Java Development Kit (JDK), introducing new features, enhancing existing ones, and occasionally removing outdated components. The JDK, the core toolkit for Java development, provides the libraries and tools necessary to build Java applications.

With every JDK update, you’ll hear about the JEPs included. But what exactly is a JEP?

JEP: Decoding the JDK Enhancement Proposal

A JEP, or JDK Enhancement Proposal, is fundamentally a document used to propose and define a significant new feature or change for the JDK. Think of it as the blueprint and discussion forum for evolving Java.

It’s a dynamic document that evolves throughout its lifecycle. Sections are added, modified, or removed as the proposal matures and gathers feedback.

A JEP is typically required under specific circumstances:

• For any significant modification to the JDK.
• If implementing a change is expected to take more than two weeks of development effort.
• When a change addresses a strong demand from the developer community.

However, many smaller changes and bug fixes that don’t meet these criteria are still integrated into the JDK. These are usually detailed in the release notes accompanying each new Java version.

Proposing a JEP involves drafting it based on an official template and submitting it via email to the OpenJDK community. This document becomes the starting point for discussions within the community and marks the beginning of the development process for that potential feature.

OpenJDK: The Community Powering Java

The OpenJDK community is the collaborative hub where developers work together on the open-source implementation of the Java Platform, Standard Edition (Java SE). Established in 2006 when parts of Java’s source code were released under the GPLv2 license, it forms the backbone of modern Java development.

The community comprises developers holding various roles and responsibilities.

Who’s Who in OpenJDK?

• Participant: By subscribing to an OpenJDK mailing list, anyone becomes a Participant. This initial role allows individuals to join discussions and follow developments.
• Contributor: To actively contribute code or propose significant changes, one must sign the Oracle Contributor Agreement (OCA). This legal document grants Oracle rights to the contributed code. Signing the OCA elevates a Participant to a Contributor, enabling them to submit code patches, propose new projects, and take on roles within specific groups or projects.
• OpenJDK Member: Seasoned Contributors who have made significant contributions can be nominated (and subsequently voted in by existing Members) to become OpenJDK Members. Members gain additional privileges, such as proposing new groups, leading groups, and voting on key community matters (like new projects or electing board members).
• OpenJDK Lead: This role is appointed directly by Oracle. The OpenJDK Lead directs major community efforts, particularly the JDK release process, and serves on the Governing Board.

Groups: Focusing Expertise

The community organizes itself into Groups based on specific areas of interest or expertise (e.g., Compiler Group, Security Group, Web Group). A Group might focus on creating, enhancing, or maintaining a particular part of the JDK codebase, or address related areas like documentation.

Groups can choose to sponsor a Project, indicating they believe the project is valuable and that members of the Group will likely contribute to its development. Each Group has a Leader who has the authority to sponsor projects, acts as the primary contact, and reports on the Group’s activities quarterly.

Projects: Delivering Features

A Project represents a collaborative effort aimed at producing specific deliverables – code, documentation, or other related materials. A Project can encompass one or more features, or even the entire JDK itself.

Any Contributor can propose a new Project. If it gains support from at least one Group Lead (whose Group becomes a sponsor) and is approved by the OpenJDK Members, the Project is officially created.

A Project can be sponsored by multiple Groups. If a Project loses all its sponsors, it is dissolved, though its materials are archived for potential future reactivation.

Projects also have specific roles:

• Author: A Contributor granted permission to create changesets (patches) for the project’s codebase, but without direct push access to the repository.
• Committer: An Author who has earned the privilege to push changes directly to the repository. Committers can also nominate new Committers.
• Reviewer: An experienced Committer authorized to approve code changes. Reviewers can nominate or revoke other Reviewers.
• Project Lead: A Committer responsible for leading and coordinating the Project’s activities. They have technical authority, can manage non-Committer Authors, request code modifications, serve as the primary contact point, publish quarterly reports, and are considered a Reviewer by default. Project Leads are appointed by the sponsoring Group Leads. At project creation, the Lead appoints the initial Authors, Committers, and Reviewers.

The Governing Board: Steering the Community

The Governing Board oversees the structure and operations of the OpenJDK community. It consists of five members:

• The Chair (appointed by Oracle).
• The Vice Chair (appointed by IBM).
• The OpenJDK Lead (appointed by Oracle).
• Two At-Large Members (elected annually by OpenJDK Members).

The Board manages the community according to established bylaws, resolves procedural disputes, but holds no direct authority over technical decisions.

The Lifecycle of a JEP

Understanding the OpenJDK structure makes the JEP lifecycle clear. A JEP progresses through several states, driven by different roles within the community:

1. Draft: The initial state. The JEP template is filled out and submitted, receiving a tracking ID in the JDK Bug System (JBS). It’s circulated for initial feedback on feasibility and value. (Driven by the Author)
2. Submitted: The JEP is formally proposed for community review and consideration for inclusion in the roadmap. (Driven by the Author)
3. Candidate: The JEP is accepted onto the roadmap and receives an official JEP number. The focus shifts to detailed engineering planning. (Driven by the sponsoring Group Lead)
4. Proposed to Target: A credible engineering plan exists, and a specific JDK release is identified as the target for delivery. (Driven by the Project Lead)
5. Targeted: The engineering plan is validated by the relevant Project Committers and Reviewers. Development work is actively underway. (Driven by the Project Lead)
6. Integrated: The core development and unit testing for the feature are complete and merged into the main codebase. (Driven by the Project Lead)
7. Complete/Delivered: Feature is fully integrated, and broader testing (functional, performance, compliance) is finalized. For procedural/infrastructure JEPs (those defining processes or tools, typically numbered below 100), they often move directly from Candidate to Delivered as they don’t involve feature code development. (Driven by the Project Lead)

A JEP can also be:

• Rejected: If the OpenJDK Lead deems it unfeasible or inappropriate.
• Withdrawn: If the Author decides it needs substantial rework or is no longer relevant.

Interested in Contributing?

Getting involved with OpenJDK starts simply: subscribe to the mailing lists for topics that interest you. Contribution isn’t just about writing code for new features or patches.

Engaging in mailing list discussions (offering functional suggestions, participating in technical debates), testing new features and providing detailed feedback, reporting bugs found in the wild (and ideally, providing steps to reproduce them) are all highly valuable forms of contribution.

If you wish to contribute code, signing the OCA (or checking if your employer has) is the first step. Before proposing code changes, it’s crucial to discuss your ideas with the community to validate their utility and technical approach. This also helps in finding a sponsor (an existing Contributor) who can guide you through the process, including navigating the JBS, code reviews, and testing requirements.

Even if you choose not to contribute directly, following JDK Enhancement Proposals provides valuable insights into the future direction of Java and helps in understanding the features landing in new JDK releases. The discussions on the mailing lists can also significantly deepen your understanding of the JDK’s inner workings.

At Innovative Software Technology, we understand that navigating the evolving landscape of Java and its JDK updates can be challenging. Staying current with JEPs and understanding their implications is crucial for leveraging the latest performance improvements, security enhancements, and features in your enterprise applications. Our team of expert Java developers stays abreast of these changes, allowing us to provide cutting-edge Java development services. Whether you need to migrate legacy systems, build robust new applications leveraging the latest JDK features, or optimize existing Java solutions, Innovative Software Technology offers tailored expertise. We help you harness the power of Java’s continuous evolution, ensuring your software remains efficient, secure, and future-proof. Partner with us for custom software development and expert enterprise Java solutions that drive your business forward.