Collaborating with Sun on JDK 7

Java SE is a very large and complex technology. The Java Community Process (JCP) has been instrumental in bringing the industry together to evolve the technology — but Sun also needs you, the Java community of developers, to work with us in making each new release of the technology as good or better than the last.

The JDK is in the process of being open sourced.  Currently the openjdk project supplies the HotSpot, javac and JavaHelp components.  Contributions may be submitted through the openjdk project or through the process discussed below.

Why Collaborate with Sun?

Sun spends a great deal of effort designing, developing, and testing the JDK. From working with JCP Expert Groups on major new features, to gathering feedback about those features from developers, vendors, and end-users, and then developing code and testing it to guarantee it's ready to release to the world is a big task. When everything is done, the specs, reference implementation (JDK), and Technology Compatibility Kit (TCK) become the definition of each new Java SE technology release. All vendor implementation efforts (both open source and proprietary) are dependent upon the success of these three parts. While it is true that the JDK is a Sun product, it is also the proof of concept of the specification and TCK.

When developers join with Sun on building a new release, they improve the technology in many ways. For example:

• Sun does not have the resources to fix every bug in the JDK. Minor problems must often be left unfixed when creating a new release. When someone (you?) fixes these problems, all JDK developers can benefit.
• Occasionally bugs you fix can be included in an update for the current JDK release, so a fix contributed today could be made available to developers much sooner than the next major JDK release.
• Bugs you identify can lead to fixes that are shared by all vendors who license the source.
• Minor enhancements to the API that you suggest and contribute can become part of all implementations and benefit many developers.
• Problems you identify can influence corrections to the specification, documentation, and TCK providing benefits to all implementations.
• Bug fixes and enhancements you make today could someday be migrated to Java ME code (which borrows many features from the JDK).

Probably best of all, by working with Sun, developers help themselves by making the technology more robust and usable for everyone.

Getting Started

1. Download the latest JDK 7 source and binaries here. The JDK 7 source snapshots are covered under the Java Research License (JRL) and the associated binaries are covered under a Pre-Release Software Evaluation Agreement.
2. The source and binaries can be used to:
   • investigate new features
   • test existing applications for JDK 7 regression errors
   • identify and contribute fixes and enhancements to Sun
   • create your own research project on java.net
3. To collaborate with Sun, we ask that you first apply for a jdk.Researcher project role in the JDK Collection of Projects which confirms your acceptance of the JRL.
4. Once the project role is approved (which should take less than one business day — we're working to make it automatic), go to the jdk-collaboration project to begin! Here you can:
   • review the mailing list archive and dev forum
   • participate in discussions with other community members about the source and bugs
   • contribute bug fixes and enhancements.

Testing Builds

Sun spends a great deal of effort testing the Java Runtime to ensure compatibility with prior releases. Regressions (bugs which cause behavior differences with past releases) are a high priority and will be fixed up to the final product release. Finding such problems early is very important and given the size, breadth and complexity of the JDK, Sun must rely on the developer community and end-users to assist in finding problems we miss.

If you discover a problem, please let us know on bugs.sun.com.

Contributing Code to Sun

If you have a fix to a nagging bug or a clever solution or enhancement that you'd like to contribute to Sun, THAT'S GREAT! -- we'd love to see it! But you'll also need to do the following:

• Sign the Sun Contributor Agreement and fax it to 1+408-715-2540, or scan and email it to sun_ca@sun.com. You only need to do this once — all fixes contributed by you will be covered by one agreement (including other Sun projects like NetBeans and Open Solaris).
  This agreement provides Sun with the legal permissions required to incorporate your bug fixes and enhancements into the JDK code-base. Note that since the JDK 7 source is covered under the JRL, any contributions and related discussions about the source are most easily facilitated in an environment where such can be openly aired. For this reason, Sun asks that you first be assigned the jdk.Researcher role (described above) to gain access to this environment (i.e., the jdk-collaboration project).
• When your Contributor Agreement is received, you will be assigned the project role of jdk.Contributor. From that point, you are free to contribute as much and as often as you wish by using the contribution mechanism in the jdk-collaboration project.
• There are no rules about how to select bugs and contribute fixes, but in the interest of getting good feedback and assistance from Sun and others in the developer community, we suggest you let the community know what you're doing and proceed as follows:
  1. Select a bug you'd like to work on from the web bug list or if you'd like an easy fix to get started, the starter bug list.
  2. If the bug or enhancement you wish to work on does not currently exist on the web bug list, please submit your bug or enhancement to bugs.sun.com. You can begin work on the fix but watch the web bug list for your bug/enhancement to be posted so you can proceed with the following steps.
  3. Verify that a fix for your bug has not already been started by someone else by searching through threads for that bug id on the dev forum in the jdk.collaboration project.
  4. If no thread exists, start one on the dev forum in the jdk.collaboration project with the exact name of the bug id to let others know you're working on it. If another person has already begun work on this bug,consider collaborating on the fix or choose something else.
  5. If you create a thread, please include the URL to the bug report in your first thread post (this URL can be found by finding the bug on the web bug list). By including this URL, it makes it easy to check the current bug status.
  6. Use the forum to discuss ideas with the community, investigate means to attack the bug or enhancement, and/or provide your fix for comments before submitting it to Sun.
  7. When your fix is complete and ready to submit, please follow the instructions on the jdk.collaboration project page.
• Sun requests that each bug fix be accompanied by a simple unit test that verifies the problem or deficiency your fix addresses. Contributions will be evaluated by senior engineers at Sun for robustness, quality, platform independence, etc. If your fix is deficient in some manner, you will be informed and asked to correct and resubmit it (i.e., it won't fall into a black hole).

You do not need to build the entire JDK in order to submit a fix. It is OK if you only build and test the files you have changed.

This chart describes how bug fix submissions are processed at Sun. You should normally receive confirmation of receipt and a status of your contribution, along with a bug ID, within a week of submission. Tracking your contribution status can be accomplished by monitoring the associated bug ID in the bug database.

This sample contribution shows what we are looking for in these contributions.

Sun wants to get to know you too! We are looking for those individuals in the community who are as passionate as we are about improving the JDK (we know you're out there). However, we are also very concerned about maintaining platform stability, so we want a graduated way of welcoming new contributors.

Our expectations are to start gently and to identify people who provide high quality bug feedback and work with them, initially to integrate smallish bug fixes. Over time, as we get to know and trust people's input, we would hope that we could work up to riskier fixes, then feature enhancements, and eventually all the way to collaboration on larger strategic enhancements.

Any questions? If so, please let us know on the feedback forum.