Development Resources/New Commmitter Handbook
This page is intended for new Eclipse committers, and contributors who plan to become committers. Having said that, there should be a little something in here for everybody.
We are attempting to keep this page as concise as possible (using plain English), while conveying as much information as possible. This document is not the definitive source of information about being an Eclipse committer. It is just the starting point: it provides many links to more information.
As a committer, you must be familiar with the following documents:
The Eclipse Resources page is intended as a reference into the rest of the documentation. If you have a question, this is a good place to start. If you can't find the help you need there you should ask your project lead, or PMC.
We are continually trying to improve this page. If you think that something can be improved, or something should be added, please let us know by opening a bug against Community/Process.
- 1 Terminology/Who's Who?
- 2 My Foundation Portal
- 3 Licenses, Intellectual Property Due Diligence, and other Legal Stuff
Top-level projects are "container projects" as defined by the Eclipse Development Project. As a container project, a top-level project does not contain code. Rather, a top-level project contains other projects. Each top-level project defines a charter that, amoung other things defines a scope for the types of projects that it contains. Top-level projects are managed by a Project Management Committed (described below).
There are, essentially, two different types of projects at Eclipse (as defined in the Eclipse Development Process).
"Container" projects are holders holders of other projects. You can think of a container project as a grouping of projects that make some logical sense together. Projects can be arbitrarily nested. A container project can itself contain container projects. Container projects do not include code and do not have committers.
"Operating" projects are where the real work happens. Each operating project has code and committers. Operating projects may, but do not necessarily, have a dedicated website (many operating projects share a website through their container project). Operating projects are sometimes referred to as "sub-projects" or as "components". The Eclipse Development Process treats these as equivalent.
Projects can be arbitrarily nested, forming a tree. The root of the tree is a single top-level project.
As a new committer, you are most likely associated with an operating projects.
There are numerous project-specific resources (including a list of all projects at Eclipse) on the Eclipse Projects Gateway page.
A committer is a software developer who has the necessary rights to write code into the project's source code repository. Committers are responsible for ensuring that all code that gets written into the project's source code repository is of sufficient quality. Further, they must ensure that all code written to an eclipse.org source code repository is clean from an intellectual property point of view. This is discussed with more detail below.
Contributions to an Eclipse project take many forms. As a committer, you should do everything possible to encourage contribution by members of the community that surrounds your project. Contributions take the form of code, input into your project's wiki pages, answering questions on newsgroups, and more.
Be aware that code contributions from outside of the project are best accepted through Bugzilla records. By attaching code to a Bugzilla record, the committer implicitly grants rights to use the code. Those contributions are subject to our IP policy.
Some of our documentation refers to contributors as developers.
Project Management Committee (PMC)
Each top-level project is governed by a PMC. The PMC has one or more leads along with several members. The PMC has numerous responsibilities, including the ultimate approval of new committers, and approval of intellectual property contributions. Effectively, the PMC provides oversight for each of the projects that are part of the top-level project.
Project Lead (PL)
Eclipse Management Organization (EMO)
Executive Director (EMO/ED)
Contribution Questionnaire (CQ)
Now this is a tough one. For most people in the broader community, "Eclipse" refers to a Java IDE based on the JDT project and assembled by the Eclipse Packaging Project. However, the term "Eclipse" is also used to refer to the Eclipse Foundation, the eclipse.org website, the community, the eco-system, and—of course—The Eclipse Project (which is just one of the top-level projects hosted by the Eclipse Foundation). Confusing?
My Foundation Portal
The My Foundation Portal is the primary mechanism for committers to interact with the Eclipse Foundation. Using the portal, you can update your personal information, manage information about your project, nominate new committers, and more. New functionality is added on an ongoing basis. The portal presents functionality in the form of individual components. The set of components depends on the roles assigned to you.
You can use either your Eclipse Bugzilla or your committer credentials to login. Some committer-specific functionality is only available when you login using your committer credentials.
Licenses, Intellectual Property Due Diligence, and other Legal Stuff
The Eclipse Legal page is the main resource for legal matters. Janet Campbell, Legal Counsel & Intellectual Property Team Manager for the Eclipse Foundation, presented a talk, IP for Eclipse Committers, at EclipseCon 2009 that provides a great overview of the IP policy and process at Eclipse.
As an Eclipse Committer, you should be familiar with the Eclipse Public License (EPL). Further, you should be aware of the Eclipse Distribution License (EDL). By default all code authored for an Eclipse project is subject to the EPL. The BSD-style EDL license is used by some Eclipse projects which require dual-licensing along with the EPL. Use of this license by an Eclipse project is on a case-by-case basis and requires unanimous approval of the Board of Directors.
Managing intellectual property is an important part of being an Eclipse Committer. All committers should be familiar with the Intellectual Property Due Diligence process. Any time you accept code from any party (committer or non-committer), you should consult this poster to determine what course of action to take. As a general rule, code created on an ongoing basis by committers for an Eclipse project can simply be committed into the project's source code repository.
Any library authored by a third-party that you intend to distribute from any eclipse.org resource, including those licensed under the EPL or EDL, are subject to the process. The Guidelines for the Review of Third Party Dependencies provides some guidance on dealing with these third party libraries.
The entry-point into the Eclipse IP Due Diligence Process is the Contribution Questionnaire (CQ). CQs are tracked in a separate Bugzilla instance known as IPZilla. Only committers and other authorized individuals may access IPZilla.
You should create a CQ using the My Foundation Portal. By using the portal, you are given an opportunity to locate similar existing CQs; by leveraging an existing CQ, you may be able to hasten the approval process. The CQ describes the contribution, including important information like the license under which it is distributed and identity of the various authors. Once your CQ is created, you must attach the source code for the library to the record. Do not attach binaries. A separate CQ is required for each library.
Do not commit any contribution to your project's source code repository until the CQ is explicitly marked as approved and a comment is added by the IP Due Diligence Team that explicitly states that you can commit the contribution.
An incubating project may make use of the Parallel IP Process. Using the Parallel IP Process, a contribution can be committed into a project's source code repository while the due diligence process is undertaken. If, at the end of the due diligence process, the contribution is rejected, it must be removed from the source code repository. The Parallel IP Process "How to" page provides some insight. Mature projects can take advantage of the parallel IP process for certain libraries.
Projects are encouraged, where possible, to reuse libraries found in the Orbit project. Leveraging these libraries will help to reduce redundancy across Eclipse projects.
If you are unsure about what you need to do or have other questions, ask your PMC.
This page is moderated by the EMO