How Java adapts to present circumstances and reacts to developer and business needs is almost uncanny and makes you perceive it as an intelligent being.
Jokes aside, Java owes its rapid transformation to the immense community around it, where anyone, individual or enterprise, can pitch in to improve the platform. And this stream of contributions, big and small, is conveniently collected, sifted, and guided by the established framework — the Java Community Process (JCP).
This year, the JCP turns 25: a great occasion to look behind the scenes of Java’s evolution!
Table of Contents
About the JCP program
The Java Community Process (JCP) program was established in 1998 to provide a solid framework for developing the Java platform. And after 25 years, it still goes strong and delivers excellent results. What lies beneath its success?
- Community involvement — anyone can join the JCP and participate in developing or reviewing Java specifications regardless of their status and regalia, thus making the process open and inclusive.
- Transparency — every new feature goes through several public reviews before making it to the standards, and all development stages are well documented and accessible to anyone.
- Responding to business demands and far-running trends — the JCP guides Java evolution in line with the tendencies in the IT industry and the emerging needs of developers and organizations worldwide relying on the Java platform.
- Separating the wheat from the chaff — the JCP helps to decide what is worth working on. For instance, the proposed feature has to be helpful for many developers, and the contributed code has to be of high quality and meet the standards.
- Standardization — the meticulous process of JSR development, assessment, and testing provides intercompatibility of Java technologies across platforms and implementations.
Key concepts
The JCP program operates with specific concepts, so let’s dig into some key terms to grasp the JCP essence better.
To become a JCP member with full capabilities, you must sign a one-year Java Specification Participation Agreement (JSPA) with Oracle, which gives you the right to work on JSRs.
↓
Java Specification Request (JSR) is a proposal to develop a new or update an existing Java specification.
↓
JSRs are submitted by the program members to the PMO, Program Management Office at Oracle that administers the JCP and leads the JCP Executive Committee, having a non-voting Chair there. PMO reviews the proposed JSR and then, in case there are no issues or missing data, the JSR is posed for a JSR Review.
↓
The JCP Executive Committee (JCP EC) is a group of major stakeholders and Java community members guiding the Java evolution. The JCP EC reviews and approves the submitted JSRs and monitors the process of their development and integration into the Java platform.
BellSoft is proud to be a member of the JCP Executive Committee together with Eclipse Foundation, Microsoft, IBM, Oracle, SAP SE, and other industry leaders.
↓
Each JSR is developed or revised by the dedicated Expert Group under the guidance of a Specification Lead (Spec Lead).
↓
The Spec Lead is responsible for Expert Group deliverables, i.e., the development of a specification, RI, and TCK:
- RI (Reference Implementation) is a “proof of concept” of a specification;
- TCK (Technology Compatibility Kit) is a set of tests to verify that the JSR implementation complies with the Specification.
For example, OpenJDK version 17 is a Reference Implementation for the Java SE 17 Platform JSR. Consequently, the TCK test suite is utilized to prove that a given RI (OpenJDK distribution) complies with the Java SE spec.
TCK-verified OpenJDK distributions guarantee issue-free migration from Oracle Java, which might be a burning question for companies dissatisfied with drastic changes to Oracle Java licensing.
Java Community Process Members
Any individual developer or organization can contribute to enriching the Java platform to the extent they deem fit, from providing feedback on currently developed features to joining an Expert Group working on a particular Java specification. For that purpose, the JCP program offers several roles and membership opportunities:
- Observers are individuals who don’t have to sign the JCPA but can review and comment on JSRs in work;
- Associate Members are individuals who sign an Associate Membership Agreement to contribute to JSRs and vote for the JCP EC;
- Partner Members are non-profit organizations (e.g., JUGs) that can sign a simplified Partner Membership Agreement to vote for or serve on the JCP EC;
- Full Members are individuals and organizations that sign the JCPA to be able to join an Expect Group, become a Spec Lead, or serve on the JCP EC.
The JCP EC comprises the JCP members, both major organizations and individual representatives of the Java community. In total, there are 16 JCP members on the EC (Oracle has a permanent seat) plus a non-voting chair represented by the PMO member.
So what exactly is the process?
All JSRs submitted to JCP must go through lengthy drafting, development, revision, enhancements, and testing procedures before they become full-fledged Java specifications.
Since Java development is a collaborative effort, and all voices and contributions have to be accounted for, this procedure took the shape of a well-defined JSR process framework that enables transparent cooperation between the Executive Committee, Expert Group, and JSR reviewers.
JSR process timeline
|
Stage |
Step |
Timeframe |
|
Initiation |
JSR submission and public review |
2–4 weeks |
|
The JCP EC approves or rejects the JSR |
7 days | |
|
Early draft |
The Expert Group (EG) is formed |
30–90 days |
|
The EG writes an Early Draft | ||
|
The Early Draft is submitted for public review and reworked based on the feedback if required | ||
|
Public Review |
A JSR draft specification goes out for a public review |
30–90 days |
|
The JCP EC decides whether the draft should proceed to the next step |
14 days | |
|
Final Release |
The EG proposes a final specification draft based on the feedback |
No limit on the timeframe |
|
The RI and TCK are completed | ||
|
The JCP EC reviews and approves the Proposed Final Draft, RI, and TCK |
14 days | |
|
The Specification is released together with RI and TCK | ||
|
Maintenance |
Requests for specification updates are tracked |
On ongoing basis |
|
The JCP EC approves or declines proposed changes |
30 days | |
|
The specification gets updated |
To anyone looking at the table above, it may seem that the Java standards are updated agonizingly slowly. However, these time limits are justified as the steps encompass
- Extensive work by the Expert Group,
- Substantial engagement of the community through numerous feedbacks and elaborate discussions,
- A thorough assessment of the results and prospects by the Executive Committee,
All of which guarantee that the specification is fully ready and can be seamlessly integrated into the platform. In addition, the Committee may conclude at any evaluation stage that further JSR development is unpromising, thus sparing the Expert Group unnecessary labor.
Besides, multiple JSRs are usually developed in parallel. For instance, as of September 2023, six JSRs are in active development, and 268 are in the Final Release stage!
Become a JCP member and take part in enhancing the Java platform!
The joint effort of individuals and organizations makes Java more potent with every release.
BellSoft made contributions an essential part of its business model. We commit fixes and patches to every OpenJDK release and are members of the key communities and organizations:
- JCP Executive Committee
- OpenJDK Vulnerability Group
- GraalVM Advisory Board
- Linux Foundation
- Cloud Native Computing Foundation
This way, we stay in touch with the community, help make Java better for everyone, and improve our products according to users’ needs.
You can contribute to the platform, too! There are numerous ways of getting involved: review the OpenJDK code and commit bug fixes, participate in Java projects, provide feedback on active JSRs, propose your enhancement, and so on. You can start by registering on the JSR site, reading the mailing lists, and taking part in discussions. And remember, even the smallest contribution can make a significant change!
