<div id="preamble">
<div class="sectionbody">
<div class="paragraph">
<p>Version 1.11. Effective September 1, 2023</p>
</div>
<div id="toc" class="toc">
<div id="toctitle" class="title">Table of Contents</div>
<ul class="sectlevel1">
<li><a href="#1_Purpose">1. Purpose</a>
<ul class="sectlevel2">
<li><a href="#edp-documents">1.1 Governance Documents</a></li>
<li><a href="#edp-terms">1.2 Terms and Definitions</a></li>
</ul>
</li>
<li><a href="#2_Principles">2. Principles</a>
<ul class="sectlevel2">
<li><a href="#2_1_Open_Source_Rules_of_Engagement">2.1 Open Source Rules of Engagement</a></li>
<li><a href="#2_2_Eclipse_Ecosystem">2.2 Eclipse Ecosystem</a></li>
<li><a href="#2_3_Three_Communities">2.3 Three Communities</a>
<ul class="sectlevel3">
<li><a href="#2_3_1_Committers">2.3.1 Developers</a></li>
<li><a href="#2_3_2_Users">2.3.2 Users</a></li>
<li><a href="#2_3_3_Adopters">2.3.3 Adopters</a></li>
</ul>
</li>
<li><a href="#2_4_Clear_Concise_and_Evolving">2.4 Clear, Concise, and Evolving</a></li>
<li><a href="#2_5_Freedom_of_Action">2.5 Freedom of Action</a></li>
</ul>
</li>
<li><a href="#3_Requirements">3. Requirements</a>
<ul class="sectlevel2">
<li><a href="#edp-emo-responsibility">3.1 EMO Responsibility</a></li>
</ul>
</li>
<li><a href="#4_Structure_and_Organization">4. Project Structure and Organization</a>
<ul class="sectlevel2">
<li><a href="#4_1_Committers">4.1 Committers</a></li>
<li><a href="#4_2_Code_and_Releases">4.2 Code and Resources</a></li>
<li><a href="#4_3_IP_Records">4.3 Reserved</a></li>
<li><a href="#4_4_Community_Awareness">4.4 Community Awareness</a></li>
<li><a href="#4_5_Scope">4.5 Scope</a></li>
<li><a href="#4_6_Leaders">4.6 Leaders</a>
<ul class="sectlevel3">
<li><a href="#4_6_1_PMC">4.6.1 Project Management Committee (PMC)</a></li>
<li><a href="#4_6_2_PL">4.6.2 Project Lead</a></li>
</ul>
</li>
<li><a href="#4_7_Committers_and_Contributors">4.7 Committers and Contributors</a></li>
<li><a href="#4_8_Councils">4.8 [Reserved]</a></li>
<li><a href="#4_9_Incubators">4.9 Permanent Incubator Projects</a></li>
<li><a href="#4_10_Plans">4.10 Project Plans</a></li><li><ins data-operation-index="1"><a href="#edp-security-team">4.11 Project Security Team</a></ins></li>
</ul>
</li>
<li><a href="#5_Reserved">5. [Reserved]</a></li>
<li><a href="#6_Development_Process">6. Development Process</a>
<ul class="sectlevel2">
<li><a href="#6_1_Mentors">6.1 Reserved</a></li>
<li><a href="#6_2_Project_Lifecycle">6.2 Project Lifecycle</a>
<ul class="sectlevel3">
<li><a href="#6_2_1_Pre-Proposal">6.2.1 Pre-Proposal Phase</a></li>
<li><a href="#6_2_2_Proposal">6.2.2 Proposal Phase</a></li>
<li><a href="#6_2_3_Incubation">6.2.3 Incubation Phase</a></li>
<li><a href="#6_2_4_Mature">6.2.4 Mature Phase</a></li>
<li><a href="#6_2_5_Top-Level">6.2.5 [Reserved]</a></li>
<li><a href="#6_2_6_Archived">6.2.6 Archived</a></li>
</ul>
</li>
<li><a href="#6_3_Reviews">6.3 Reviews</a>
<ul class="sectlevel3">
<li><a href="#6_3_1_Creation_Review">6.3.1 Creation Review</a></li>
<li><a href="#6_3_2_Graduation_Review">6.3.2 Graduation Review</a></li>
<li><a href="#6_3_3_Release_Review">6.3.3 Release Review</a></li>
<li><a href="#6_3_4_Promotion_Review">6.3.4 [Reserved]</a></li>
<li><a href="#6_3_5_Progress_Review">6.3.5 Progress Review</a></li>
<li><a href="#6_3_6_Termination_Review">6.3.6 Termination Review</a></li>
<li><a href="#6_3_7_Move_Review">6.3.7 [Reserved]</a></li>
<li><a href="#6_3_8_Restructuring_Review">6.3.8 Restructuring Review</a></li>
<li><a href="#6_3_9_Combining_Reviews">6.3.9 Combining Reviews</a></li>
</ul>
</li>
<li><a href="#6_4_Releases">6.4 Releases</a></li>
<li><a href="#6_5_Grievance_Handling">6.5 Grievance Handling</a></li>
</ul>
</li>
<li><a href="#7_Precedence">7. Precedence</a></li>
<li><a href="#8_Revisions">8. Revisions</a>
<ul class="sectlevel2">
<li><a href="#8_1_Reserved">8.1 [Reserved]</a></li>
<li><a href="#8_2_History">8.2 History</a>
<ul class="sectlevel3">
<li><a href="#changelog">ChangeLog</a></li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
</div>
</div>
<div class="sect1">
<h2 id="1_Purpose"><a class="anchor" href="#1_Purpose"></a><a class="link" href="#1_Purpose">1. Purpose</a></h2>
<div class="sectionbody">
<div class="paragraph">
<p>This document describes the development process for the Eclipse Foundation. In particular, it describes how the Membership at Large, the Board of Directors, other constituents of the Ecosystem, and the Eclipse Management Organization (EMO) lead, influence, and collaborate with Eclipse Projects to achieve the Purposes defined in the <a href="https://www.eclipse.org/org/documents/eclipse_foundation-bylaws.pdf">Bylaws</a>.</p>
</div>
<div class="paragraph">
<p>This document has the following sections:</p>
</div>
<div class="ulist">
<ul>
<li>
<p><a href="#2_Principles">Principles</a> outlines the basic principles upon which the development process is based.</p>
</li>
<li>
<p><a href="#3_Requirements">Requirements</a> describes the requirements that the Eclipse community has for its development process.</p>
</li>
<li>
<p><a href="#4_Structure_and_Organization">Structure and Organization</a> specifies the structure and organization of the Projects and Project community at Eclipse.</p>
</li>
<li>
<p><a href="#6_Development_Process">Development Process</a> outlines the lifecycle and processes required of all Eclipse Projects.</p>
</li>
</ul>
</div>
<div class="paragraph">
<p>This document defines terms used elsewhere in Eclipse governance documents. In the event of any conflict between the terms set forth in this document and the terms of the <a href="#edp-documents">documents listed below</a>, the terms of those documents shall take precedence.</p>
</div>
<div class="sect2">
<h3 id="edp-documents"><a class="anchor" href="#edp-documents"></a><a class="link" href="#edp-documents">1.1 Governance Documents</a></h3>
<div class="paragraph">
<p>All Committers and Project Leads engaged in Project activity are required to implement the policies and processes described by the <a href="https://www.eclipse.org/org/documents/">Eclipse Foundations Governance Documents</a>, including:</p>
</div>
<div class="ulist">
<ul>
<li>
<p><a href="https://www.eclipse.org/org/documents/eclipse_foundation-bylaws.pdf">Eclipse Foundation Bylaws</a></p>
</li>
<li>
<p><a href="https://www.eclipse.org/org/documents/eclipse_membership_agreement.pdf">Eclipse Foundation Membership Agreement</a></p>
</li>
<li>
<p><a href="https://www.eclipse.org/org/documents/Eclipse_IP_Policy.pdf">Eclipse Foundation Intellectual Property Policy</a></p>
</li>
<li>
<p><a href="https://www.eclipse.org/security/policy.php">Eclipse Foundation Security Policy</a></p>
</li>
<li>
<p><a href="https://www.eclipse.org/org/documents/Eclipse_Antitrust_Policy.pdf">Eclipse Foundation Antitrust Policy</a></p>
</li>
<li>
<p><a href="https://www.eclipse.org/org/documents/Community_Code_of_Conduct.php">Eclipse Foundation Community Code of Conduct</a></p>
</li>
</ul>
</div>
</div>
<div class="sect2">
<h3 id="edp-terms"><a class="anchor" href="#edp-terms"></a><a class="link" href="#edp-terms">1.2 Terms and Definitions</a></h3>
<div class="dlist glossary">
<dl>
<dt>Adopter </dt>
<dd>
<p>Adopters are the individuals and organizations that adopt Eclipse technology for inclusion in their own products and services.</p>
</dd>
<dt>Architecture Council </dt>
<dd>
<p>The Eclipse Architecture Council (AC) is a council of experienced Eclipse committers responsible for identifying and tackling any issues that hinder continued technological success and innovation, widespread adoption, and future growth of Eclipse technology. The Eclipse Architecture Council is formally defined in section VII of the Bylaws of the Eclipse Foundation.</p>
</dd>
<dt>Board of Directors </dt>
<dd>
<p>The business and technical affairs of the Eclipse Foundation are managed by or under the direction of the Eclipse Board of Directors.</p>
</dd>
<dt>Check Point Review </dt>
<dd>
<p>Check Point Review is a category of Review that includes: Creation Review, Progress Review, Release Review, and Graduation Review.</p>
</dd>
<dt>Committer </dt>
<dd>
<p>A committer is a software developer who has the necessary rights to make decisions regarding a Project.</p>
</dd>
<dt>Contributor </dt>
<dd>
<p>A Contributor is anybody who makes contributions to a Project.</p>
</dd>
<dt>Creation Review </dt>
<dd>
<p>A Creation Review is a type of Review that marks a Project&#8217;s transition from the Proposal Phase to the Incubation Phase.</p>
</dd>
<dt>Developer </dt>
<dd>
<p>A Committer or Contributor.</p>
</dd>
<dt>Ecosystem </dt>
<dd>
<p>An Ecosystem is a system in which companies, organizations, and individuals all work together for mutual benefit.</p>
</dd>
<dt>Eclipse Management Organization</dt>
<dd>
<p>The Eclipse Management Organization (EMO) consists of the Eclipse Foundation staff, and the Eclipse Architecture Council.</p>
</dd>
<dt>EMO(ED) </dt>
<dd>
<p>The term EMO(ED) generally refers to the Executive Director of the Eclipse Foundation. When discussing matters pertaining to the Eclipse Foundation Development Process, EMO(ED) refers to the subset of the EMO consisting of the Executive Director and whomever he or she may delegate specific approval authority to.</p>
</dd>
<dt>Graduation Review </dt>
<dd>
<p>A Graduation Review is a type of Review that marks a Project&#8217;s transition from the Incubation Phase to the Mature Phase.</p>
</dd>
<dt>Incubation Branding </dt>
<dd>
<p>Incubation Branding is the branding that must be applied to all Projects in the Incubation Phase.</p>
</dd>
<dt>Incubation Phase </dt>
<dd>
<p>The Incubation Phase is a Phase during which the Project Team develops the process, the community, and the technology for a new Project.</p>
</dd>
<dt>Integration Build </dt>
<dd>
<p>An Integration Build is a build of the Project content that is generated periodically and made available to the Developer community for testing purposes.</p>
</dd>
<dt>Major Release </dt>
<dd>
<p>A Major Release is a type of Release that includes either significant new functionality and/or breaking changes.</p>
</dd>
<dt>Mature Phase </dt>
<dd>
<p>The Mature Phase is a Phase during which a Project operates with an open and transparent process, has an actively involved and growing community, and produces Eclipse-quality technology.</p>
</dd>
<dt>Membership at Large </dt>
<dd>
<p>The Membership at Large (or <em>Membership</em>) refers to all members of all types, as defined by the <a href="https://www.eclipse.org/org/documents/eclipse_foundation-bylaws.pdf">Bylaws of the Eclipse Foundation</a>.</p>
</dd>
<dt>Milestone </dt>
<dd>
<p>A Milestone is a build of the Project content intended for limited distribution to demonstrate progress and solicit feedback.</p>
</dd>
<dt>Minor Release </dt>
<dd>
<p>A Minor Release is a type of Release that includes new features over a Major Release.</p>
</dd>
<dt>Nightly Build </dt>
<dd>
<p>A Nightly Build is a build of the Project content that is generated nightly and made available to the Developer community for testing purposes.</p>
</dd>
<dt>Permanent Incubator </dt>
<dd>
<p>A Permanent Incubator is a Project that is intended to perpetually remain in the Incubation Phase.</p>
</dd>
<dt>Phase </dt>
<dd>
<p>A Phase is a stage in the Project lifecycle. See Pre-proposal Phase, Proposal Phase, Incubation Phase, and Mature Phase.</p>
</dd>
<dt>Pre-proposal Phase </dt>
<dd>
<p>The Pre-proposal Phase is a Phase during which a new Project Proposal is created.</p>
</dd>
<dt>Progress Review </dt>
<dd>
<p>A Progress Review a type of Review that is used by a Project Team to summarize the accomplishments of the Project, verify that the Eclipse Development Process and IP Policy have been followed, and to highlight any remaining quality and/or architectural issues.</p>
</dd>
<dt>Project </dt>
<dd>
<p>A Project is the main operational unit for open source software development at the Eclipse Foundation.</p>
</dd>
<dt>Project Lead </dt>
<dd>
<p>A Project Lead, the first level in the Project Leadership Chain, is responsible for the overall well-being of a specific Project and serves as the primary liaison between that Project and the EMO.</p>
</dd>
<dt>Project Leadership Chain </dt>
<dd>
<p>The Project Leadership Chain is composed of a Project&#8217;s Project Lead(s), the leadership of the parent Project (if any), the PMC Leads and PMC Members for the Top-Level Project, the EMO, and the EMO(ED).</p>
</dd>
<dt>Project Management Committee </dt>
<dd>
<p>A Project Management Committee (PMC) is the primary leadership of a Top-Level Project with responsibility to ensure that the Projects within its purview are active and viable.</p>
</dd>
<dt>Project Proposal </dt>
<dd>
<p>A Project Proposal (or just <em>Proposal</em>) is a document that is presented to the PMC, Membership at Large, and EMO to describe a potential new Project.</p>
</dd>
<dt>Project Team </dt>
<dd>
<p>A Project Team is the collective of Committers with responsibilities and privileges on<ins data-operation-index="3"> a specific Project.</ins></p></dd><dt data-diff-node="ins" data-operation-index="3"><ins data-operation-index="3">Project Security Team </ins></dt><dd><p><ins data-operation-index="3">The Project Security Team is a collective responsible for implementing the <a href="https://www.eclipse.org/security/policy.php">Eclipse Foundation Security Policy</a> for</ins> a specific Project.</p>
</dd>
<dt>Proposal Phase </dt>
<dd>
<p>The Proposal Phase is a Phase during which a Project Proposal is presented to the community and Membership at Large to solicit feedback.</p>
</dd>
<dt>Release </dt>
<dd>
<p>A Release is a collection of Project artifacts intended for distribution beyond the Project Developers.</p>
</dd>
<dt>Release Candidate </dt>
<dd>
<p>A Release Candidate is a feature-complete Milestone.</p>
</dd>
<dt>Release Review </dt>
<dd>
<p>A Release Review is a type of Progress Review that is aligned directly with a specific Release.</p>
</dd>
<dt>Restructuring Review </dt>
<dd>
<p>A Restructuring review is a type of Review that is used to notify the community of significant changes to one or more Projects.</p>
</dd>
<dt>Review </dt>
<dd>
<p>A Review is formally designated period of time during which the Project Management Committee, the Membership at Large, and the EMO are given an opportunity to survey the current state of a Project, provide feedback, and validate that the Project is in good standing.</p>
</dd>
<dt>Scope </dt>
<dd>
<p>The Scope is the defined range of activities to be undertaken by a Project. The Project Team must operate within the bounds defined by the Project&#8217;s Scope.</p>
</dd>
<dt>Service Release </dt>
<dd>
<p>A Service Release, or <em>Bug-fix Release</em> is a type of Release that includes no significant changes or additions over the base Release.</p>
</dd>
<dt>Subproject </dt>
<dd>
<p>A synonym for Project.</p>
</dd>
<dt>Termination Review </dt>
<dd>
<p>A Termination Review is a type of Review that provides a final opportunity for a Project Team, the Project Leadership Chain, and the Eclipse Membership to consider the proposed archival of a Project.</p>
</dd>
<dt>Top-Level Project </dt>
<dd>
<p>A Top-Level Project is an organizational unit that defines an overall mission and scope for a collection of Projects.</p>
</dd>
<dt>Top-Level Project Charter </dt>
<dd>
<p>A Top-Level Project Charter describes the mission, purpose, scope, and operational rules for a Top-Level Project.</p>
</dd>
</dl>
</div>
</div>
</div>
</div>
<div class="sect1">
<h2 id="2_Principles"><a class="anchor" href="#2_Principles"></a><a class="link" href="#2_Principles">2. Principles</a></h2>
<div class="sectionbody">
<div class="paragraph">
<p>The following describes the guiding principles used in developing this development process.</p>
</div>
<div class="sect2">
<h3 id="2_1_Open_Source_Rules_of_Engagement"><a class="anchor" href="#2_1_Open_Source_Rules_of_Engagement"></a><a class="link" href="#2_1_Open_Source_Rules_of_Engagement">2.1 Open Source Rules of Engagement</a></h3>
<div class="ulist">
<ul>
<li>
<p><strong>Open</strong> - Eclipse is open to all; Eclipse provides the same opportunity to all. Everyone participates with the same rules; there are no rules to exclude any potential Contributors which include, of course, direct competitors in the marketplace.</p>
</li>
<li>
<p><strong>Transparent</strong> - Project discussions, minutes, deliberations, Project plans, plans for new features, and other artifacts are open, public, and easily accessible.</p>
</li>
<li>
<p><strong>Meritocratic</strong> - Eclipse is a meritocracy. The more you contribute the more responsibility you will earn. Leadership roles in Eclipse are also merit-based and earned by peer acclaim.</p>
</li>
</ul>
</div>
</div>
<div class="sect2">
<h3 id="2_2_Eclipse_Ecosystem"><a class="anchor" href="#2_2_Eclipse_Ecosystem"></a><a class="link" href="#2_2_Eclipse_Ecosystem">2.2 Eclipse Ecosystem</a></h3>
<div class="paragraph">
<p>Eclipse as a brand is the sum of its parts (all of the Projects), and Projects should strive for the highest possible quality in extensible frameworks, exemplary applications, transparent processes, and Project openness.</p>
</div>
<div class="paragraph">
<p>The Eclipse Foundation has the responsibility to <em>&#8230;&#8203;cultivate&#8230;&#8203;an Ecosystem of complementary products, capabilities, and services&#8230;&#8203;</em>. It is therefore a key principle that the Eclipse Foundation Development Process ensures that the Projects are managed for the benefit of both the open source community and the Ecosystem members. To this end, all Eclipse Projects are required to:</p>
</div>
<div class="ulist">
<ul>
<li>
<p>communicate their Project plans and plans for new features (major and minor) in a timely, open and transparent manner;</p>
</li>
<li>
<p>create high-quality frameworks capable of supporting the building of commercial grade products on top of them; and</p>
</li>
<li>
<p>ship extensible, exemplary applications which help enable a broad community of users.</p>
</li>
</ul>
</div>
</div>
<div class="sect2">
<h3 id="2_3_Three_Communities"><a class="anchor" href="#2_3_Three_Communities"></a><a class="link" href="#2_3_Three_Communities">2.3 Three Communities</a></h3>
<div class="paragraph">
<p>Essential to the Purposes of the Eclipse Foundation is the development of three inter-related communities around each Project:</p>
</div>
<div class="sect3">
<h4 id="2_3_1_Committers"><a class="anchor" href="#2_3_1_Committers"></a><a class="link" href="#2_3_1_Committers">2.3.1 Developers</a></h4>
<div class="paragraph">
<p>A thriving, diverse, and active community of Developers is the key component of any Eclipse Project. Ideally, this community should be an open, transparent, inclusive, and diverse community of Committers and (non-Committer) Contributors. Attracting new Contributors and Committers to an open source Project is time consuming and requires active recruiting, not just passive "openness". The Project Leadership must make reasonable efforts to encourage and nurture promising new Contributors.</p>
</div>
</div>
<div class="sect3">
<h4 id="2_3_2_Users"><a class="anchor" href="#2_3_2_Users"></a><a class="link" href="#2_3_2_Users">2.3.2 Users</a></h4>
<div class="paragraph">
<p>An active and engaged user community is proof-positive that the Project&#8217;s exemplary applications are useful and needed. Furthermore, a large user community is one of the key factors in creating a viable Ecosystem around an Eclipse Project, thus encouraging additional open source and commercial organizations to participate. Like all good things, a user community takes time and effort to bring to fruition, but once established is typically self-sustaining.</p>
</div>
</div>
<div class="sect3">
<h4 id="2_3_3_Adopters"><a class="anchor" href="#2_3_3_Adopters"></a><a class="link" href="#2_3_3_Adopters">2.3.3 Adopters</a></h4>
<div class="paragraph">
<p>An active and engaged Adopter community is the only way to prove that an Eclipse Project is providing extensible frameworks and applications accessible via documented APIs. Reuse of the frameworks within the companies that are contributing to the Project is necessary, but not sufficient to demonstrate an Adopter community. Again, creating, encouraging, and nurturing an Adopter community outside of the Project&#8217;s Developers takes time, energy, and creativity by the Project Leadership, but is essential to the Project&#8217;s long-term open source success.</p>
</div>
<div class="paragraph">
<p>The Eclipse community considers the absence of any one or more of these communities as proof that the Project is not sufficiently open, transparent, and inviting, and/or that it has emphasized applications at the expense of extensible frameworks or vice versa.</p>
</div>
</div>
</div>
<div class="sect2">
<h3 id="2_4_Clear_Concise_and_Evolving"><a class="anchor" href="#2_4_Clear_Concise_and_Evolving"></a><a class="link" href="#2_4_Clear_Concise_and_Evolving">2.4 Clear, Concise, and Evolving</a></h3>
<div class="paragraph">
<p>It is an explicit goal of the development process to be as clear and concise as possible so as to help the Project Teams navigate the complexities, avoid the pitfalls, and become successful as quickly as possible.</p>
</div>
<div class="paragraph">
<p>This document imposes requirements and constraints on the operation of the Projects, and it does so on behalf of the larger Eclipse community. It is an explicit goal of the development process to provide as much freedom and autonomy to the Projects as possible while ensuring the collective qualities benefit the entire Eclipse community.</p>
</div>
<div class="paragraph">
<p>Similarly, this document should not place undue constraints on the EMO or the Board of Directors that prevent them from governing the process as necessary. We cannot foresee all circumstances and as such should be cautious of being overly prescriptive and/or requiring certain fixed metrics.</p>
</div>
<div class="paragraph">
<p>The frameworks, applications, Projects, processes, community, and even the definition of quality continues to, and will continue to, evolve. Creating rules or processes that force a static snapshot of any of these is detrimental to the health, growth, and Ecosystem impact of Eclipse.</p>
</div>
<div class="paragraph">
<p>Part of the strength of this document is in what it does not say, and thus opens for community definition through convention, guidelines, and public consultation. A document with too much structure becomes too rigid and prevents the kind of innovation and change we desire for Eclipse. In areas where this document is vague, we expect the Projects and members to engage the community-at-large to clarify the current norms and expectations.</p>
</div>
</div>
<div class="sect2">
<h3 id="2_5_Freedom_of_Action"><a class="anchor" href="#2_5_Freedom_of_Action"></a><a class="link" href="#2_5_Freedom_of_Action">2.5 Freedom of Action</a></h3>
<div class="paragraph">
<p>Projects are required to engage in practices that ensure the continued viability of the Project, independent from the continued availability of external resources and services, or continued participation on any single individual, organization, or group.</p>
</div>
<div class="paragraph">
<p>In practical terms, Projects are required to use resources and services approved by the Eclipse Foundation. This includes (but is not limited to) all source code management, distribution channels for artifacts, issue tracking, documentation, and public communication channels.</p>
</div>
</div>
</div>
</div>
<div class="sect1">
<h2 id="3_Requirements"><a class="anchor" href="#3_Requirements"></a><a class="link" href="#3_Requirements">3. Requirements</a></h2>
<div class="sectionbody">
<div class="paragraph">
<p>This document is entirely composed of requirements. In addition to the requirements specified in this development process, the EMO is instructed to clarify, expand, and extend this process by creating a set of development guidelines to advance the creation, evolution, promotion, and support of the open source Projects; and to cultivate both a community and an Ecosystem of complementary products and services.</p>
</div>
<div class="sect2">
<h3 id="edp-emo-responsibility"><a class="anchor" href="#edp-emo-responsibility"></a><a class="link" href="#edp-emo-responsibility">3.1 EMO Responsibility</a></h3>
<div class="paragraph">
<p>The EMO has the responsibility and authority to mitigate issues that arise when Committers fail to perform the required behaviors or engage in practices that risk harm to Eclipse Projects, the community, and/or Ecosystem. This includes, but is not limited to, issues that arise due to a failure to implement the <a href="https://www.eclipse.org/security/policy.php">Eclipse Foundation Security Policy</a>, the <a href="https://www.eclipse.org/org/documents/Eclipse_IP_Policy.pdf">Eclipse Foundation Intellectual Property Policy</a>, the <a href="https://www.eclipse.org/org/documents/Community_Code_of_Conduct.php">Eclipse Foundation Community Code of Conduct</a>, or other governance policies of the Eclipse Foundation.</p>
</div>
<div class="paragraph">
<p>The EMO&#8217;s authority includes, but is not limited to, the ability grant specific individuals equivalent to Committer privileges, suspend access to Project resources, add or remove <del data-operation-index="5">Committers and</del><ins data-operation-index="5">Committers, Project Security Team Members,</ins> Project Leads, and&#8212;&#8203;in extreme cases&#8212;&#8203;terminate the Project.</p>
</div>
<div class="paragraph">
<p>The EMO is not permitted to override or ignore the requirements listed in this document without the express written endorsement of the Board of Directors.</p>
</div>
<div class="paragraph">
<p>The motivation for the EMO to take action along with description of the steps taken as part of the mitigation must be publicly disclosed within one week of action being taken. The <a href="#6_5_Grievance_Handling">Grievance Handling</a> section of this document describes the means by which a Member may respond in the event that they believe that the EMO has overstepped its authority.</p>
</div>
</div>
</div>
</div>
<div class="sect1">
<h2 id="4_Structure_and_Organization"><a class="anchor" href="#4_Structure_and_Organization"></a><a class="link" href="#4_Structure_and_Organization">4. Project Structure and Organization</a></h2>
<div class="sectionbody">
<div class="paragraph">
<p>A Project is the main operational unit at Eclipse. Specifically, all open source software development at Eclipse occurs within the context of a Project. Projects have leaders, Developers, code, builds, downloads, websites, and more. Projects are more than just the sum of their many parts, they are the means by which open source work is organized when presented to the communities of Developers, Adopters, and users. Projects provide structure that helps Developers expose their hard work to a broad audience of consumers.</p>
</div>
<div class="paragraph">
<p>Eclipse Projects are organized hierarchically. A special type of Project, <em>Top-Level Projects</em>, sit at the top of the hierarchy. Each Top-Level Project contains one or more Projects. Each Project may itself contain zero or more Projects. A Project that has one or more Projects is said to be the <em>parent</em> of those Projects. A Project that has a parent is oftentimes referred to as a <em>Subproject</em>. The term Project refers to either a Top-Level Project or a Subproject.</p>
</div>
<div class="paragraph">
<p>The descendants of a Project are the Project itself and transitive closure of its child Projects. The top parent of a Project is the Top-Level Project at the top of the hierarchy.</p>
</div>
<div class="paragraph">
<p>Projects are the unit entity for:</p>
</div>
<div class="ulist">
<ul>
<li>
<p>Committers;</p>
</li>
<li>
<p>code and Releases;</p>
</li>
<li>
<p>intellectual property (IP) records; and</p>
</li>
<li>
<p>community awareness</p>
</li>
</ul>
</div>
<div class="sect2">
<h3 id="4_1_Committers"><a class="anchor" href="#4_1_Committers"></a><a class="link" href="#4_1_Committers">4.1 Committers</a></h3>
<div class="paragraph">
<p>Each Project has exactly one set of Committers. Each Project&#8217;s set of Committers is distinct from that of any other Project, including Subprojects or parent Projects. All Project Committers have equal rights and responsibilities within the Project. Partitioning of responsibility within a Project is managed using social convention. A Project may, for example, divide itself into logical partitions of functionality; it is social convention that prevents Committers from one logical partition from doing inappropriate work in another. If finer-grained management of Committer responsibilities is required, a Project should consider partitioning (via a <a href="#6_3_8_Restructuring_Review">Restructuring Review</a>) into two or more Subprojects.</p>
</div>
<div class="paragraph">
<p>The Committers of a Project have the exclusive right to elect new Committers to their Project; no other group, including a parent Project, can force a Project to accept a new Committer.</p>
</div>
<div class="paragraph">
<p>There is no roll-up of Committers: the set of Committers on a Project is exactly that set of people who have been explicitly elected into that role for the Project (i.e. being a Committer on a Subproject does not give you any automatic rights on the "parent" Project or any child Project).</p>
</div>
<div class="paragraph">
<p>In practical terms, each Project has a single UNIX group of its Committers that provides write-access to the Project&#8217;s resources. Pictorially below, we see that a Project, in addition to the various resources and Committers it has, can also have zero or more Subprojects. Each of these Subprojects has its own distinct set of Committers and resources.</p>
</div>
<div class="imageblock">
<div class="content">
<del data-operation-index="7"><img src="data:image/png;base64,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" alt="resources" width="422" height="319"/></del><ins data-operation-index="7"><img src="data:image/png;base64,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" alt="resources" width="395" height="339"/></ins>
</div>
<div class="title">Project Committers, resources, and Subprojects</div>
</div>
</div>
<div class="sect2">
<h3 id="4_2_Code_and_Releases"><a class="anchor" href="#4_2_Code_and_Releases"></a><a class="link" href="#4_2_Code_and_Releases">4.2 Code and Resources</a></h3>
<div class="paragraph">
<p>Each Project owns and maintains a collection of resources.</p>
</div>
<div class="paragraph">
<p>Resources may include source code, a Project website, space on the downloads server, access to build resources, and other services provided by the Eclipse Foundation infrastructure. The exact infrastructure provided by the Eclipse Foundation varies over time and is defined outside this process document.</p>
</div>
<div class="paragraph">
<p>A Project is not strictly required to make use of all the resources made available; a Project might, for example, opt to <em>not</em> maintain a source code repository. Such a Project might operate as an organizational unit, or container, for several Subprojects. Similarly, a Project might opt to provide a consolidated website, build and/or download site for its Subprojects (the Subprojects would then not require those resources for themselves).</p>
</div>
<div class="paragraph">
<p>Namespaces are assigned to a Project by the EMO. All Project source code must be organized in the assigned namespaces and Projects can only Release code under their own namespace (that is, they cannot infringe on another Eclipse Project&#8217;s namespace).</p>
</div>
</div>
<div class="sect2">
<h3 id="4_3_IP_Records"><a class="anchor" href="#4_3_IP_Records"></a><a class="link" href="#4_3_IP_Records">4.3 Reserved</a></h3>

</div>
<div class="sect2">
<h3 id="4_4_Community_Awareness"><a class="anchor" href="#4_4_Community_Awareness"></a><a class="link" href="#4_4_Community_Awareness">4.4 Community Awareness</a></h3>
<div class="paragraph">
<p>Projects are the level of communication with the larger Eclipse community and Ecosystem. Projects may either have their own communications (website, mailing lists, forums/newsgroups, etc) or they may be part of a parent Project&#8217;s communications (website, mailing list, forums/newsgroups, etc). In either case, the Project is required to maintain an open and public communication channel with the Eclipse community including, but not limited to, Project plans, schedules, and design discussions.</p>
</div>
<div class="paragraph">
<p>All Projects must make the communication channels easy to find. Projects are further required to make the separate communication channels of their child Projects (if any) easy to find.</p>
</div>
<div class="paragraph">
<p>Any Project in the Incubation Phase must correctly identify its website and Releases. A Project with at least one descendant Project in Incubation Phase must correctly annotate its own website so as to notify the Eclipse community that incubating Projects exist in its hierarchy. Any Release containing code from an Incubation Phase Project must be correctly labeled, i.e., the Incubation Phase is viral and expands to cover all Releases in which it is included.</p>
</div>
</div>
<div class="sect2">
<h3 id="4_5_Scope"><a class="anchor" href="#4_5_Scope"></a><a class="link" href="#4_5_Scope">4.5 Scope</a></h3>
<div class="paragraph">
<p>Each Top-Level Project has a Charter which describes the purpose, Scope, and operational rules for the Top-Level Project. The charter should refer to, and describe any refinements to, the provisions of this development process. The Board of Directors approves the charter of each Top-Level Project.</p>
</div>
<div class="paragraph">
<p>Subprojects do not have separate charters; Subprojects operate under the charter of their parent Top-Level Project.</p>
</div>
<div class="paragraph">
<p>All Projects have a defined Scope and all initiatives within that Project are required to reside within that Scope. Initiatives and code that is found to be outside the Scope of a Project may result in the termination of the Project. The Scope of Top-Level Projects is part of the charter, as approved by the Board of Directors of the Eclipse Foundation.</p>
</div>
<div class="paragraph">
<p>The Scope of a Subproject is defined by the initial Project Proposal as Reviewed and approved by the Project Management Committee (PMC) (as further defined below) of the Project&#8217;s top parent and by the EMO. A Project&#8217;s Scope must be a subset of its parent&#8217;s Scope.</p>
</div>
</div>
<div class="sect2">
<h3 id="4_6_Leaders"><a class="anchor" href="#4_6_Leaders"></a><a class="link" href="#4_6_Leaders">4.6 Leaders</a></h3>
<div class="paragraph">
<p>There are two different types of Project Leadership at Eclipse: The Project Management Committee (PMC) and Project Leads. Both forms of leadership are required to:</p>
</div>
<div class="ulist">
<ul>
<li>
<p>ensure that their Project is operating effectively by guiding the overall direction and by removing obstacles, solving problems, and resolving conflicts;</p>
</li>
<li>
<p>operate using open source rules of engagement: meritocracy, transparency, and open participation; and</p>
</li>
<li>
<p>ensure that the Project and its Subprojects (if any) conform to the Eclipse Foundation IP policy and procedures.</p>
</li>
</ul>
</div>
<div class="paragraph">
<p>The leadership chain for a Project is composed of the Project&#8217;s Project Lead(s), the leadership of the parent Project (if any), the PMC leads and PMC members for the Top-Level Project, the EMO, and the EMO(ED).</p>
</div>
<div class="paragraph">
<p>In exceptional situations—such as Projects with zero active Committers, disruptive Committers, or no effective Project Leads—the Project Leadership Chain has the authority to make changes (add, remove) to the set of Committers and/or Project Leads of that Project, and otherwise act on behalf of the Project Lead.</p>
</div>
<div class="sect3">
<h4 id="4_6_1_PMC"><a class="anchor" href="#4_6_1_PMC"></a><a class="link" href="#4_6_1_PMC">4.6.1 Project Management Committee (PMC)</a></h4>
<div class="paragraph">
<p>Top-Level Projects are managed by a Project Management Committee (PMC). A PMC has one or more PMC leads and zero or more PMC Members. Together the PMC provides oversight and overall leadership for the Projects that fall under their Top-Level Project. The PMC as a whole, and the PMC leads in particular, are ultimately responsible for ensuring that the Eclipse Foundation Development Process is understood and followed by their Projects. The PMC is additionally responsible for maintaining the Top-Level Project&#8217;s charter.</p>
</div>
<div class="paragraph">
<p>PMC leads are approved by the Board of Directors; PMC members are elected by the existing PMC leads and members, and approved by the EMO(ED).</p>
</div>
<div class="paragraph">
<p>In the unlikely event that a member of the PMC becomes disruptive to the process or ceases to contribute for an extended period, the member may be removed by the unanimous vote of the remaining PMC members, subject to approval by the EMO. Removal of a PMC Lead requires approval of the Board of Directors.</p>
</div>
</div>
<div class="sect3">
<h4 id="4_6_2_PL"><a class="anchor" href="#4_6_2_PL"></a><a class="link" href="#4_6_2_PL">4.6.2 Project Lead</a></h4>
<div class="paragraph">
<p>Eclipse Projects are managed by one or more Project Leads. Project Leads are responsible for ensuring that their Project&#8217;s Committers are following the Eclipse Foundation Development Process, and that the Project is engaging in the right sorts of activities to develop vibrant communities of users, Adopters, and Contributors. The initial Project Leads are appointed and approved in the Creation Review. Subsequently, additional Project Leads must be elected by the Project&#8217;s Committers, approved by the Project&#8217;s PMC, and appointed by the EMO(ED).</p>
</div>
<div class="paragraph">
<p>To hold a Project Lead role on a Project, an individual must also hold a Committer role on that Project.</p>
</div>
<div class="paragraph">
<p>In the unlikely event that a Project Lead becomes disruptive to the process or ceases to contribute for an extended period, the individual may be removed by the unanimous vote of the remaining Project Leads (if there are at least two other Project Leads), or unanimous vote of the Project&#8217;s PMC.</p>
</div>
</div>
</div>
<div class="sect2">
<h3 id="4_7_Committers_and_Contributors"><a class="anchor" href="#4_7_Committers_and_Contributors"></a><a class="link" href="#4_7_Committers_and_Contributors">4.7 Committers and Contributors</a></h3>
<div class="paragraph">
<p>Each Project has a development team, led by the Project Leaders. The development team is composed of Committers and Contributors. Contributors are individuals who contribute code, fixes, tests, documentation, or other work that is part of the Project. Committers have write access to the Project&#8217;s resources (source code repository, bug tracking system, website, build server, downloads, etc.) and are expected to influence the Project&#8217;s development.</p>
</div>
<div class="paragraph">
<p>Contributors who have the trust of the Project&#8217;s Committers can, through election, be promoted Committer for that Project. The breadth of a Committer&#8217;s influence corresponds to the breadth of their contribution. A development team&#8217;s Contributors and Committers may (and should) come from a diverse set of organizations. A Committer gains voting rights allowing them to affect the future of the Project. Becoming a Committer is a privilege that is earned by contributing and showing discipline and good judgment. It is a responsibility that should be neither given nor taken lightly, nor is it a right based on employment by an Eclipse member company or any company employing existing Committers.</p>
</div>
<div class="paragraph">
<p>The election process begins with an existing Committer on the same Project nominating the Contributor. The Project&#8217;s Committers will vote for a period of no less than one week. If there are at least three (3) positive votes and no negative votes within the voting period, the Contributor is recommended to the Project&#8217;s PMC for commit privileges. If there are three (3) or fewer Committers on the Project, a unanimous positive vote of all Committers is substituted. If the PMC approves, and the Contributor signs the appropriate Committer legal agreements established by the EMO (wherein, at the very least, the Developer agrees to abide by the Eclipse Intellectual Property Policy), the Contributor becomes a Committer and is given write access to the source code for that Project.</p>
</div>
<div class="paragraph">
<p>At times, Committers may become inactive for a variety of reasons. The decision making process of the Project relies on active Committers who respond to discussions and vote in a constructive and timely manner. The Project Leads are responsible for ensuring the smooth operation of the Project. A Committer who is disruptive, does not participate actively, or has been inactive for an extended period may have his or her commit status revoked by the unanimous consent of the Project Leads. Unless otherwise specified, "an extended period" is defined as "no activity for more than six months".</p>
</div>
<div class="paragraph">
<p>Active participation in the user communication channels and the appropriate Developer mailing lists is a responsibility of all Committers, and is critical to the success of the Project. Committers are required to monitor and contribute to the user communication channels.</p>
</div>
<div class="paragraph">
<p>Committers are required to monitor the mailing lists associated with the Project. This is a condition of being granted commit rights to the Project. It is mandatory because Committers must participate in votes (which in some cases require a certain minimum number of votes) and must respond to the mailing list in a timely fashion in order to facilitate the smooth operation of the Project. When a Committer is granted commit rights they will be added to the appropriate mailing lists. A Committer must not be unsubscribed from a Developer mailing list unless their associated commit privileges are also revoked.</p>
</div>
<div class="paragraph">
<p>Committers are required to track, participate in, and vote on, relevant discussions in their associated Projects. There are three voting responses: <code>+1</code> (yes), <code>-1</code> (no, or veto), and <code>0</code> (abstain).</p>
</div>
<div class="paragraph">
<p>Committers are responsible for proactively reporting problems in the bug tracking system, and annotating problem reports with status information, explanations, clarifications, or requests for more information from Contributors. Committers are responsible for updating problem reports when they have done work related to the problem.</p>
</div>
<div class="paragraph">
<p>Committer, PMC lead or member, Project Lead, and council representative(s) are roles; an individual may take on more than one of these roles simultaneously.</p>
</div>
</div>
<div class="sect2">
<h3 id="4_8_Councils"><a class="anchor" href="#4_8_Councils"></a><a class="link" href="#4_8_Councils">4.8 [Reserved]</a></h3>

</div>
<div class="sect2">
<h3 id="4_9_Incubators"><a class="anchor" href="#4_9_Incubators"></a><a class="link" href="#4_9_Incubators">4.9 Permanent Incubator Projects</a></h3>
<div class="paragraph">
<p>A Project may designate a Subproject as a "Permanent Incubator". A Permanent Incubator is a Project that is intended to perpetually remain in the <a href="#6_2_3_Incubation">Incubation Phase</a>. Permanent Incubators are an excellent place to innovate, test new ideas, grow functionality that may one day be moved into another Project, and develop new Committers.</p>
</div>
<div class="paragraph">
<p>Permanent Incubator Projects never have Releases. Permanent Incubators may have builds, and downloads. They conform to the standard <a href="http://wiki.eclipse.org/Development_Resources/HOWTO/Conforming_Incubation_Branding">Incubation Branding</a> requirements and are subject to the IP due diligence rules outlined for incubating Projects. Permanent Incubators do not graduate.</p>
</div>
<div class="paragraph">
<p>The Scope of a Permanent Incubator Project must fall within the Scope of its parent Project. The Committer group of the Permanent Incubator Project must overlap with that of the parent Project (at least one Committer from the parent Project must be a Committer for the incubator). The parent Project&#8217;s Committers are responsible for ensuring that the incubator Project conforms to the rules set forth by the Eclipse Foundation Development Process.</p>
</div>
<div class="paragraph">
<p>A Permanent Incubator Project must be designated as such by including the word "Incubator" in its name (e.g. "Eclipse Dash Incubator"). To do otherwise is considered exceptional and requires approval from the PMC and EMO(ED).</p>
</div>
<div class="paragraph">
<p>Only Top-Level Projects and Projects in the <a href="#6_2_4_Mature">Mature Phase</a> may create a Permanent Incubator. Permanent Incubator Projects are created upon request; a Creation Review is not required.</p>
</div>
</div>
<div class="sect2">
<h3 id="4_10_Plans"><a class="anchor" href="#4_10_Plans"></a><a class="link" href="#4_10_Plans">4.10 Project Plans</a></h3>
<div class="paragraph">
<p>Projects are required to make a Project plan available to their community at the beginning of the development cycle for each major and Minor Release. The plan may be as simple as a short description and a list of issues, or more detailed and complex. Subprojects may opt to include their plans with those of their parent Project.</p>
</div>
<div class="paragraph">
<p>Project Plans must be delivered to the community through communication channels approved by the EMO. The exact nature of the Project plan varies depending on numerous variables, including the size and expectations of the communities, and requirements specified by the PMC.</p>
</div>
</div>
<div class="sect2" data-diff-node="ins" data-operation-index="9"><h3 id="edp-security-team" data-diff-node="ins" data-operation-index="9"><ins data-operation-index="9"><a class="anchor" href="#edp-security-team"></a><a class="link" href="#edp-security-team">4.11 Project Security Team</a></ins></h3><div class="paragraph" data-diff-node="ins" data-operation-index="9"><p data-diff-node="ins" data-operation-index="9"><ins data-operation-index="9">The Project Security Team is responsible for implementing the <a href="https://www.eclipse.org/security/policy.php">Eclipse Foundation Security Policy</a>.</ins></p></div><div class="paragraph" data-diff-node="ins" data-operation-index="9"><p data-diff-node="ins" data-operation-index="9"><ins data-operation-index="9">By default, the Project Security Team includes all Project Committers. In the default configuration, membership in the Project Security Team is automatic following successful appointment as a Committer; likewise, membership in the Project Security Team is automatically revoked when Committer status is revoked.</ins></p></div><div class="paragraph" data-diff-node="ins" data-operation-index="9"><p data-diff-node="ins" data-operation-index="9"><ins data-operation-index="9">If desired and sensible, a Project can designate a distinct Project Security Team. Any Project Committer may propose a creation of a distinct Project Security Team, subject to a positive vote of the Project Committers and approval from the PMC. The vote to create a distinct Project Security Team must run in a public channel for a period of no less than one week and requires simple majority (50% + 1) consensus of all Project Committers with no objections (only </ins><code data-diff-node="ins" data-operation-index="9"><ins data-operation-index="9">+1</ins></code><ins data-operation-index="9"> or abstentions, no </ins><code data-diff-node="ins" data-operation-index="9"><ins data-operation-index="9">-1</ins></code><ins data-operation-index="9"> votes). The same rule applies to disband the Project Security Team. The PMC must approve the vote.</ins></p></div><div class="paragraph" data-diff-node="ins" data-operation-index="9"><p data-diff-node="ins" data-operation-index="9"><ins data-operation-index="9">The Project Security Team must consist of at least two persons; at least one of whom must be a Project Committer. The Project Committers may elect non-Project Committers to the Project Security Team when they have related knowledge and experience. Project Security Team members are required to sign appropriate legal agreements as established by the EMO. Members of the Project Security team are voted in by all Project Committers using the same rules as for election of Committers with exceptions specified in this section.</ins></p></div></div></div>
</div>
<div class="sect1">
<h2 id="5_Reserved"><a class="anchor" href="#5_Reserved"></a><a class="link" href="#5_Reserved">5. [Reserved]</a></h2>
<div class="sectionbody">

</div>
</div>
<div class="sect1">
<h2 id="6_Development_Process"><a class="anchor" href="#6_Development_Process"></a><a class="link" href="#6_Development_Process">6. Development Process</a></h2>
<div class="sectionbody">
<div class="paragraph">
<p>Projects must work within their Scope. Projects that desire to expand beyond their current Scope must seek an enlargement of their Scope using a public Review as described below. Further, Projects must fit within the Scope defined by their containing Projects and the Scope defined in the charter of their Top-Level Project.</p>
</div>
<div class="paragraph">
<p>Projects must provide advanced notification of upcoming features via their Project plan.</p>
</div>
<div class="sect2">
<h3 id="6_1_Mentors"><a class="anchor" href="#6_1_Mentors"></a><a class="link" href="#6_1_Mentors">6.1 Reserved</a></h3>

</div>
<div class="sect2">
<h3 id="6_2_Project_Lifecycle"><a class="anchor" href="#6_2_Project_Lifecycle"></a><a class="link" href="#6_2_Project_Lifecycle">6.2 Project Lifecycle</a></h3>
<div class="paragraph">
<p>Projects go through distinct Phases. The transitions from Phase to Phase are open and transparent public Reviews.</p>
</div>
<div class="imageblock">
<div class="content">
<del data-operation-index="11"><img src="data:image/svg+xml;base64,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" alt="lifecycle" width="260" height="446"/></del><ins data-operation-index="11"><img src="data:image/svg+xml;base64,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" alt="lifecycle" width="212" height="448"/></ins>
</div>
<div class="title">An overview of the Project lifecycle Phases</div>
</div>
<div class="sect3">
<h4 id="6_2_1_Pre-Proposal"><a class="anchor" href="#6_2_1_Pre-Proposal"></a><a class="link" href="#6_2_1_Pre-Proposal">6.2.1 Pre-Proposal Phase</a></h4>
<div class="paragraph">
<p>An individual or group of individuals declares their interest in, and rationale for, establishing a Project. The EMO will assist such groups in the preparation of a Project Proposal.</p>
</div>
<div class="paragraph">
<p>The Pre-Proposal Phase ends when the proposal is published by EMO and announced to the Membership at Large by the EMO.</p>
</div>
</div>
<div class="sect3">
<h4 id="6_2_2_Proposal"><a class="anchor" href="#6_2_2_Proposal"></a><a class="link" href="#6_2_2_Proposal">6.2.2 Proposal Phase</a></h4>
<div class="paragraph">
<p>The proposers, in conjunction with the destination PMC and the community, collaborate in public to enhance, refine, and clarify the proposal.</p>
</div>
<div class="paragraph">
<p>The Proposal Phase ends with a <a href="#6_3_1_Creation_Review">Creation Review</a>, or withdrawal. The proposal may be withdrawn by the proposers at any point before the start of a Creation Review. The EMO will withdraw a proposal that has been inactive for more than six months.</p>
</div>
</div>
<div class="sect3">
<h4 id="6_2_3_Incubation"><a class="anchor" href="#6_2_3_Incubation"></a><a class="link" href="#6_2_3_Incubation">6.2.3 Incubation Phase</a></h4>
<div class="paragraph">
<p>The purpose of the Incubation Phase is to establish a fully-functioning open-source Project. In this context, incubation is about developing the process, the community, and the technology. Incubation is a Phase rather than a place: new Projects may be incubated under any existing Project.</p>
</div>
<div class="ulist">
<ul>
<li>
<p>A Project in the Incubation Phase can (and should) make Releases;</p>
</li>
<li>
<p>Top-Level Projects skip incubation and are immediately put into the Mature Phase;</p>
</li>
<li>
<p>The Incubation Phase ends with a Graduation Review or a Termination Review.</p>
</li>
<li>
<p>Designated <a href="#4_9_Incubators">Permanent Incubator Projects</a> remain perpetually in the Incubation Phase; they do not create Releases, so no Reviews are required.</p>
</li>
</ul>
</div>
<div class="paragraph">
<p>Many Eclipse Projects are proposed and initiated by individuals with extensive and successful software development experience. This document attempts to define a process that is sufficiently flexible to learn from all its participants. At the same time, however, the Incubation Phase is useful for new Projects to learn the community-defined Eclipse-centric open source processes.</p>
</div>
</div>
<div class="sect3">
<h4 id="6_2_4_Mature"><a class="anchor" href="#6_2_4_Mature"></a><a class="link" href="#6_2_4_Mature">6.2.4 Mature Phase</a></h4>
<div class="paragraph">
<p>The Project Team has demonstrated that they are an open-source Project with an open and transparent process, an actively involved and growing community, and Eclipse-quality technology. The Project is now a mature member of the Eclipse community.</p>
</div>
</div>
<div class="sect3">
<h4 id="6_2_5_Top-Level"><a class="anchor" href="#6_2_5_Top-Level"></a><a class="link" href="#6_2_5_Top-Level">6.2.5 [Reserved]</a></h4>

</div>
<div class="sect3">
<h4 id="6_2_6_Archived"><a class="anchor" href="#6_2_6_Archived"></a><a class="link" href="#6_2_6_Archived">6.2.6 Archived</a></h4>
<div class="paragraph">
<p>Projects that become inactive, either through dwindling resources or by reaching their natural conclusion, are archived. Projects are moved to archived status through a Termination Review.</p>
</div>
<div class="paragraph">
<p>If there is sufficient community interest in reactivating an archived Project, the Project can start again with a Creation Review. As there must be good reasons to have terminated a Project, the Creation Review provides a sufficiently high bar to prove that those reasons are no longer valid.</p>
</div>
</div>
</div>
<div class="sect2">
<h3 id="6_3_Reviews"><a class="anchor" href="#6_3_Reviews"></a><a class="link" href="#6_3_Reviews">6.3 Reviews</a></h3>
<div class="paragraph">
<p>The Eclipse Foundation Development Process is predicated on open and transparent behavior. All major changes to Eclipse Projects must be announced and Reviewed by the Membership at Large. Major changes include the Project Phase transitions as well as the introduction or exclusion of significant new technology or capability. It is a clear requirement of this document that members who are monitoring the appropriate media channels not be surprised by the post-facto actions of the Projects.</p>
</div>
<div class="paragraph">
<p>Projects are responsible for initiating the appropriate Reviews. If it is determined to be necessary, the Project Leadership Chain (e.g. the PMC or EMO) may initiate a Review on the Project&#8217;s behalf.</p>
</div>
<div class="paragraph">
<p>All Reviews have the same general process:</p>
</div>
<div class="olist arabic">
<ol class="arabic">
<li>
<p>The Project Team will complete all required due diligence under the Eclipse IP Policy prior to initiating the Review.</p>
</li>
<li>
<p>A Project representative (Project Lead or Committer) assembles Review documentation.</p>
</li>
<li>
<p>A Project representative presents the Review documentation to the Project&#8217;s PMC along with a request to proceed with the Review and for approval of the corresponding documentation.</p>
</li>
<li>
<p>Upon receiving approval from the PMC, a Project representative makes a request to the EMO to schedule the Review.</p>
</li>
<li>
<p>The EMO announces the Review schedule and makes the documentation available to the Membership at Large.</p>
</li>
<li>
<p>The EMO approves or fails the Review based on the feedback, the Scope of the Project, and the Purposes of the Eclipse Foundation as defined in the bylaws.</p>
</li>
</ol>
</div>
<div class="paragraph">
<p>The Review documentation requirements, and criteria for the successful completion of each type of Review will be documented by the EMO. PMCs may establish additional success criteria.</p>
</div>
<div class="paragraph">
<p>The Review period is open for no less than one week and usually no more than two weeks. The Review ends with the announcement of the results in the defined Review communication channel.</p>
</div>
<div class="paragraph">
<p>If any member believes that the EMO has acted incorrectly in approving or failing a Review may appeal to the Board of Directors to Review the EMO&#8217;s decision.</p>
</div>
<div class="sect3">
<h4 id="6_3_1_Creation_Review"><a class="anchor" href="#6_3_1_Creation_Review"></a><a class="link" href="#6_3_1_Creation_Review">6.3.1 Creation Review</a></h4>
<div class="paragraph">
<p>The purpose of the Creation Review is to assess the community and Membership at Large response to the proposal, to verify that appropriate resources are available for the Project to achieve its plan, and to serve as a Committer election for the Project&#8217;s initial Committers. The Eclipse Foundation strives not to be a repository of "code dumps" and thus Projects must be sufficiently staffed for forward progress.</p>
</div>
<div class="paragraph">
<p>The Creation Review documents must include short nomination bios of the proposed initial Committers. These bios should discuss their relationship to, and history with, the incoming code and/or their involvement with the area/technologies covered by the proposal. The goal is to help keep any legacy Contributors connected to new Project and explain that connection to the current and future Eclipse Membership at Large, as well as justify the initial Committers' participation in a meritocracy.</p>
</div>
</div>
<div class="sect3">
<h4 id="6_3_2_Graduation_Review"><a class="anchor" href="#6_3_2_Graduation_Review"></a><a class="link" href="#6_3_2_Graduation_Review">6.3.2 Graduation Review</a></h4>
<div class="paragraph">
<p>The purpose of the Graduation Review is to mark a Project&#8217;s change from the Incubation Phase to the Mature Phase.</p>
</div>
<div class="paragraph">
<p>The Graduation Review confirms that the Project is/has:</p>
</div>
<div class="ulist">
<ul>
<li>
<p>A working and demonstrable code base of sufficiently high quality.</p>
</li>
<li>
<p>Active and sufficiently diverse communities appropriate to the size of the graduating code base: Adopters, Developers, and users.</p>
</li>
<li>
<p>Operating fully in the open following the principles and Purposes of Eclipse.</p>
</li>
<li>
<p>A credit to Eclipse and is functioning well within the larger Eclipse community.</p>
</li>
</ul>
</div>
<div class="paragraph">
<p>A Graduation Review is generally <a href="#6_3_9_Combining_Reviews">combined</a> with a progress or Release Review.</p>
</div>
</div>
<div class="sect3">
<h4 id="6_3_3_Release_Review"><a class="anchor" href="#6_3_3_Release_Review"></a><a class="link" href="#6_3_3_Release_Review">6.3.3 Release Review</a></h4>
<div class="paragraph">
<p>A Release Review is a type of <a href="#6_3_5_Progress_Review">Progress Review</a> that is aligned directly with a specific Release. A Release Review must be concluded successfully before the corresponding <a href="#6_4_Releases">Release</a> is announced to the community.</p>
</div>
</div>
<div class="sect3">
<h4 id="6_3_4_Promotion_Review"><a class="anchor" href="#6_3_4_Promotion_Review"></a><a class="link" href="#6_3_4_Promotion_Review">6.3.4 [Reserved]</a></h4>

</div>
<div class="sect3">
<h4 id="6_3_5_Progress_Review"><a class="anchor" href="#6_3_5_Progress_Review"></a><a class="link" href="#6_3_5_Progress_Review">6.3.5 Progress Review</a></h4>
<div class="paragraph">
<p>The purposes of a Progress Review are: to summarize the accomplishments of the Project, to verify that the IP Policy is being followed, to highlight any remaining quality and/or architectural issues, and to verify that the Project is continuing to operate according to the principles and Purposes of Eclipse.</p>
</div>
</div>
<div class="sect3">
<h4 id="6_3_6_Termination_Review"><a class="anchor" href="#6_3_6_Termination_Review"></a><a class="link" href="#6_3_6_Termination_Review">6.3.6 Termination Review</a></h4>
<div class="paragraph">
<p>The purpose of a Termination Review is to provide a final opportunity for the Committers and/or Eclipse Membership at Large to discuss the proposed archiving of a Project. The desired outcome is to find sufficient evidence of renewed interest and resources in keeping the Project active.</p>
</div>
</div>
<div class="sect3">
<h4 id="6_3_7_Move_Review"><a class="anchor" href="#6_3_7_Move_Review"></a><a class="link" href="#6_3_7_Move_Review">6.3.7 [Reserved]</a></h4>

</div>
<div class="sect3">
<h4 id="6_3_8_Restructuring_Review"><a class="anchor" href="#6_3_8_Restructuring_Review"></a><a class="link" href="#6_3_8_Restructuring_Review">6.3.8 Restructuring Review</a></h4>
<div class="paragraph">
<p>The purpose of a Restructuring Review is to notify the community of significant changes to one or more Projects. Examples of "significant changes" include:</p>
</div>
<div class="ulist">
<ul>
<li>
<p>Movement of significant chunks of functionality from one Project to another.</p>
</li>
<li>
<p>Modification of the Project structure, e.g. combining multiple Projects into a single Project, or decomposing a single Project into multiple Projects.</p>
</li>
<li>
<p>Change of Project Scope.</p>
</li>
</ul>
</div>
</div>
<div class="sect3">
<h4 id="6_3_9_Combining_Reviews"><a class="anchor" href="#6_3_9_Combining_Reviews"></a><a class="link" href="#6_3_9_Combining_Reviews">6.3.9 Combining Reviews</a></h4>
<div class="paragraph">
<p>Reviews can be combined at the discretion of the PMC and EMO. Multiple Projects may participate in a single Review. Similarly, multiple Review types can be engaged in simultaneously. A parent Project may, for example, engage in an aggregated Progress Review involving itself and some or all of its child Projects; a consolidated Restructuring Review may move the code for several Projects; or a Progress Review may be combined with a Graduation Review. When multiple Reviews are combined, the Review documentation must explicitly state all of the Projects and types of Reviews involved, and include the required information about each.</p>
</div>
<div class="paragraph">
<p>It should be noted that the purpose of combining Reviews is to better serve the community, rather than to reduce effort on the part of the Project (though it is fortunate when it does both). Combining a progress and Graduation Review, or aggregating a Progress Review of a Project and several of its child Projects generally makes sense. Combining Progress Reviews for multiple unrelated Projects most likely does not.</p>
</div>
</div>
</div>
<div class="sect2">
<h3 id="6_4_Releases"><a class="anchor" href="#6_4_Releases"></a><a class="link" href="#6_4_Releases">6.4 Releases</a></h3>
<div class="paragraph">
<p>Any Project, with exception of Permanent Incubators, may make a Release. A Release may include the code from any subset of the Project&#8217;s descendants.</p>
</div>
<div class="paragraph">
<p><em>(Most of this section is paraphrased from the excellent <a href="http://www.apache.org/dev/release.html">Apache Software Foundation Releases FAQ</a>. The Eclipse community has many of the same beliefs about Releases as does the Apache community and their words were already excellent. The Apache Software Foundation Releases FAQ is distributed under the <a href="http://www.apache.org/licenses/LICENSE-2.0">Apache License, Version 2.0</a>.)</em></p>
</div>
<div class="paragraph">
<p>Releases are, by definition, anything that is distributed outside of the Committers of a Project. If consumers are being directed to download a build, then that build has been released (modulo the exceptions below). All Projects and Committers must obey the Eclipse Foundation requirements on approving any Release.</p>
</div>
<div class="paragraph">
<p>The <a href="https://www.eclipse.org/org/documents/Eclipse_IP_Policy.pdf">Eclipse IP Policy</a> must be followed at all times. Prior to issuing any Release, the Project Lead must assert that the IP Policy has been followed and all approvals have been received.</p>
</div>
<div class="paragraph">
<p>The Project Team must provide (either directly or indirectly) a link between the distribution form of Release artifacts and the corresponding source code.</p>
</div>
<div class="paragraph">
<p>A Project can make official Releases for one calendar year following a successful <a href="#6_3_5_Progress_Review">Progress Review</a> or <a href="#6_3_3_Release_Review">Release Review</a>. The Project Leadership Chain may&#8212;&#8203;at its discretion&#8212;&#8203;require that the Project engage in additional Reviews (e.g. a progress or Release Review) prior to issuing a Release.</p>
</div>
<div class="paragraph">
<p><strong>Exception 1: Nightly and Integration Builds</strong> During the process of developing software and preparing a Release, various nightly and Integration Builds are made available to the Developer community for testing purposes. Do not include any links on the Project website, blogs, wikis, etc. that might encourage non-early-adopters to download and use Nightly Builds, Release Candidates, or any other similar package (links aimed at early-adopters and the Project&#8217;s Developers are both permitted and encouraged). The only people who are supposed to know about such packages are the people following the Developer mailing list and thus are aware of the limitations of such builds.</p>
</div>
<div class="paragraph">
<p><strong>Exception 2: Milestone and Release Candidate Builds</strong> Projects are encouraged to use an agile development process including regular Milestones (for example, six week Milestones). Milestones and Release Candidates are "almost Releases" intended for adoption and testing by early-adopters. Projects are allowed to have links on the Project website, blogs, wikis, etc. to encourage these outside-the-Committer-circle early-adopters to download and test the Milestones and Release Candidates, but such communications must include caveats explaining that these are not official Releases. Milestones and Release Candidate builds must be labeled as such (e.g. <code>x.yMn</code>, <code>x.yRCn</code>, <em>alpha</em>, <em>beta</em>, or similar).</p>
</div>
<div class="paragraph">
<p><strong>Exception 3: Service Releases with no new features</strong> Service Releases with no significant changes or additions over the base Release are allowed to be released without an additional Review.</p>
</div>
<div class="paragraph">
<p>Under no circumstances are builds and Milestones to be used as a substitute for doing proper official Releases. Proper Release management and Reviews is a key aspect of Eclipse quality.</p>
</div>
<div class="paragraph">
<p>Releases and corresponding artifacts for Projects in the Incubation Phase must be labeled to indicate the incubation status of the Project. See <a href="http://wiki.eclipse.org/Development_Resources/HOWTO/Conforming_Incubation_Branding">Incubation Branding</a> for more information.</p>
</div>
</div>
<div class="sect2">
<h3 id="6_5_Grievance_Handling"><a class="anchor" href="#6_5_Grievance_Handling"></a><a class="link" href="#6_5_Grievance_Handling">6.5 Grievance Handling</a></h3>
<div class="paragraph">
<p>When a member has a concern about a Project, the member will raise that concern with the Project&#8217;s leadership. If the member is not satisfied with the result, the member can raise the concern with the parent Project&#8217;s leadership. The member can continue appeals up the Project Leadership Chain and, if still not satisfied, thence to the EMO, then the executive director, and finally to the Board of Directors. All appeals and discussions will abide by the guiding principles of being open, transparent, and public.</p>
</div>
<div class="paragraph">
<p>Member concerns may include:</p>
</div>
<div class="ulist">
<ul>
<li>
<p>Out of Scope. It is alleged that a Project is exceeding its approved Scope.</p>
</li>
<li>
<p>Dysfunctional. It is alleged that a Project is not functioning correctly or is in violation of one or more requirements of the Eclipse Foundation Development Process.</p>
</li>
<li>
<p>Contributor appeal. It is alleged that a Contributor who desires to be a Committer is not being treated fairly.</p>
</li>
<li>
<p>Invalid veto. It is alleged that a <code>-1</code> vote on a Review is not in the interests of the Project and/or of Eclipse.</p>
</li>
</ul>
</div>
<div class="paragraph">
<p>A variety of grievance resolutions are available to the EMO up to, and including, rebooting or restarting a Project with new Committers and leadership.</p>
</div>
</div>
</div>
</div>
<div class="sect1">
<h2 id="7_Precedence"><a class="anchor" href="#7_Precedence"></a><a class="link" href="#7_Precedence">7. Precedence</a></h2>
<div class="sectionbody">
<div class="paragraph">
<p>In the event of a conflict between this document and a Board of Directors-approved Project charter, the most recently approved document will take precedence.</p>
</div>
</div>
</div>
<div class="sect1">
<h2 id="8_Revisions"><a class="anchor" href="#8_Revisions"></a><a class="link" href="#8_Revisions">8. Revisions</a></h2>
<div class="sectionbody">
<div class="paragraph">
<p>As specified in the Bylaws, the EMO is responsible for maintaining this document and all changes must be approved by the Board of Directors.</p>
</div>
<div class="paragraph">
<p>Due to the continued evolution of the Eclipse technology, the Eclipse community, and the software marketplace, it is expected that the Eclipse Foundation Development Process (this document) will be reviewed and revised on at least an annual basis.</p>
</div>
<div class="paragraph">
<p>The EMO is further responsible for ensuring that all plans, documents and reports produced in accordance with this development process be made available to the Membership at Large via an appropriate mechanism in a timely, effective manner.</p>
</div>
<div class="sect2">
<h3 id="8_1_Reserved"><a class="anchor" href="#8_1_Reserved"></a><a class="link" href="#8_1_Reserved">8.1 [Reserved]</a></h3>

</div>
<div class="sect2">
<h3 id="8_2_History"><a class="anchor" href="#8_2_History"></a><a class="link" href="#8_2_History">8.2 History</a></h3>
<div class="paragraph">
<p>Changes made in this document:</p>
</div>
<div class="sect3">
<h4 id="changelog"><a class="anchor" href="#changelog"></a><a class="link" href="#changelog">ChangeLog</a></h4>
<div class="sect4">
<h5 id="2023-2023-09-01"><a class="anchor" href="#2023-2023-09-01"></a><a class="link" href="#2023-2023-09-01">[2023] - 2023-09-01</a></h5>
<div class="sect5">
<h6 id="added"><a class="anchor" href="#added"></a><a class="link" href="#added">Added</a></h6>
<div class="ulist">
<ul>
<li>
<p>List applicable governance documents <a href="https://gitlab.eclipse.org/eclipsefdn/emo-team/policies/development-process/-/issues/11">#11</a></p>
</li>
<li>
<p>Define EMO(ED) as a term</p>
</li>
<li>
<p>Project leads must also be committers <a href="https://gitlab.eclipse.org/eclipsefdn/emo-team/policies/development-process/-/issues/9">#9</a></p>
</li>
<li>
<p>Clarification that the unanimous consent of the project leads is required to retire a committer</p>
</li>
</ul>
</div>
</div>
<div class="sect5">
<h6 id="removed"><a class="anchor" href="#removed"></a><a class="link" href="#removed">Removed</a></h6>
<div class="ulist">
<ul>
<li>
<p>All references to mentors <a href="https://gitlab.eclipse.org/eclipsefdn/emo-team/policies/development-process/-/issues/1">#1</a></p>
</li>
<li>
<p>References to the "coordinated release" <a href="https://gitlab.eclipse.org/eclipsefdn/emo-team/policies/development-process/-/issues/13">#13</a></p>
</li>
</ul>
</div>
</div>
<div class="sect5">
<h6 id="changes"><a class="anchor" href="#changes"></a><a class="link" href="#changes">Changes</a></h6>
<div class="ulist">
<ul>
<li>
<p>Mentions of "Eclipse Development Process" changed to "Eclipse <em>Foundation</em> Development Process" <a href="https://gitlab.eclipse.org/eclipsefdn/emo-team/policies/development-process/-/issues/2">#2</a></p>
</li>
<li>
<p>"Meritocracy" changed to "Meritocratic" in the Open Source Rules of Engagement to be more consistent grammatically with “Open” and “Transparent”</p>
</li>
<li>
<p>Fixed bogus references to the Bylaws. Specifically removed a quotation of an older version of the Purposes defined in the Bylaws. <a href="https://gitlab.eclipse.org/eclipsefdn/emo-team/policies/development-process/-/issues/6">#6</a></p>
</li>
<li>
<p>Added section 3.1 which extends the options available to the EMO to mitigate the situation when committers fail to perform required behaviours or engage in practices that risk harm to an Eclipse project. Previously, the only option available to the EMO was to terminate the project <a href="https://gitlab.eclipse.org/eclipsefdn/emo-team/policies/development-process/-/issues/12">#12</a></p>
</li>
</ul>
</div>
</div>
</div>
<div class="sect4">
<h5 id="2020-2020-11-01"><a class="anchor" href="#2020-2020-11-01"></a><a class="link" href="#2020-2020-11-01">[2020] - 2020-11-01</a></h5>
<div class="sect5">
<h6 id="removed-2"><a class="anchor" href="#removed-2"></a><a class="link" href="#removed-2">Removed</a></h6>
<div class="ulist">
<ul>
<li>
<p>All references to the parallel IP Process</p>
</li>
<li>
<p>The "Revision" section (formerly 8.1) that had indicated the board meeting in which the specific revision was approved (this is is inconsistent with how we treat other documents).</p>
</li>
</ul>
</div>
</div>
<div class="sect5">
<h6 id="changes-2"><a class="anchor" href="#changes-2"></a><a class="link" href="#changes-2">Changes</a></h6>
<div class="ulist">
<ul>
<li>
<p>Document title changed to "Eclipse Foundation Development Process" to make it consistent with other documents.</p>
</li>
<li>
<p>Section 4.7 renamed from "Committers" to "Committers and Contributors"</p>
</li>
<li>
<p>In section 4.7, the reference to "submitters" changed to "Contributors"</p>
</li>
</ul>
</div>
</div>
</div>
<div class="sect4">
<h5 id="2020-2020-01-20"><a class="anchor" href="#2020-2020-01-20"></a><a class="link" href="#2020-2020-01-20">[2020] - 2020-01-20</a></h5>
<div class="sect5">
<h6 id="removed-3"><a class="anchor" href="#removed-3"></a><a class="link" href="#removed-3">Removed</a></h6>
<div class="ulist">
<ul>
<li>
<p>All references to the Eclipse Planning Council have been removed</p>
</li>
<li>
<p>The entire section 4.8, which quoted text from the bylaws regarding councils has been removed (the "Terms" section covers this)</p>
</li>
</ul>
</div>
</div>
<div class="sect5">
<h6 id="changes-3"><a class="anchor" href="#changes-3"></a><a class="link" href="#changes-3">Changes</a></h6>
<div class="ulist">
<ul>
<li>
<p>A reference to the bylaws was added in the definition of the Eclipse Architecture Council.</p>
</li>
</ul>
</div>
</div>
</div>
<div class="sect4">
<h5 id="2018-2018-12-14"><a class="anchor" href="#2018-2018-12-14"></a><a class="link" href="#2018-2018-12-14">[2018] - 2018-12-14</a></h5>
<div class="sect5">
<h6 id="added-2"><a class="anchor" href="#added-2"></a><a class="link" href="#added-2">Added</a></h6>
<div class="ulist">
<ul>
<li>
<p>A separate section that formally defines key terms has been added.</p>
</li>
<li>
<p>The notion of a Progress Review added to augment (and in some cases, replace) Release Reviews (Bug 496321).</p>
</li>
<li>
<p>Added a requirement that the Project Team must provide (either directly or indirectly) a link between the distribution form of Release artifacts and the corresponding source code.</p>
</li>
<li>
<p>A CHANGELOG based on "keep a changelog" <a href="https://keepachangelog.com/" class="bare">https://keepachangelog.com/</a></p>
</li>
</ul>
</div>
</div>
<div class="sect5">
<h6 id="removed-4"><a class="anchor" href="#removed-4"></a><a class="link" href="#removed-4">Removed</a></h6>
<div class="ulist">
<ul>
<li>
<p>Removed redundant restriction that Permanent Incubators cannot participate in the simultaneous release (they can&#8217;t release at all).</p>
</li>
<li>
<p>Removed discussion regarding specific labeling of Milestones and Release Candidates (replaced with an simple statement that Milestones and Release Candidates must be labeled as such with examples)</p>
</li>
</ul>
</div>
</div>
<div class="sect5">
<h6 id="changes-4"><a class="anchor" href="#changes-4"></a><a class="link" href="#changes-4">Changes</a></h6>
<div class="ulist">
<ul>
<li>
<p>Converted document source format to Asciidoctor.</p>
</li>
<li>
<p>The time period for votes and reviews is expressed in terms of simple weeks rather than "one week of generally accepted business days" which is unnecessarily complicated.</p>
</li>
<li>
<p>Removed the unnecessary statement that "Major releases continue to go through release reviews." from the description of the Mature Phase.</p>
</li>
<li>
<p>Content in the Releases section has been reorganized.</p>
</li>
<li>
<p>Release Reviews have been recast as a special type of Progress Review.</p>
</li>
<li>
<p>The requirement that a project engage in a Release Review prior to a release has been changed to a requirement that project can only release within a year of successfully engaging in either a Progress Review or a Release Review. Further, the Project Leadership Chain is granted the ability to compel a project to engage in a Progress Review.</p>
</li>
<li>
<p>The requirement that the "the IP Policy has been followed and all approvals have been received" has been moved from being a requirement of a Release Review to being a requirement of a Release. This is a bit subtle, but important given that with the introduction of a Progress Review a project may issue Releases without engaging in a Release Review.</p>
</li>
<li>
<p>Content in the Releases section has been reorganized so that the three exceptions are grouped followed by the discussion regarding milestones.</p>
</li>
<li>
<p>The notion "public comments" has been generalized to "feedback" in the Reviews section (Bug 538613).</p>
</li>
<li>
<p>Change the title of section 2.3.1 to "Developers", and section 4.7 to "Committers" (Bug 484587).</p>
</li>
<li>
<p>References to "Bug fix Releases" changed to "Service Releases" in the Releases section.</p>
</li>
</ul>
</div>
</div>
</div>
<div class="sect4">
<h5 id="2015-2015-12-31"><a class="anchor" href="#2015-2015-12-31"></a><a class="link" href="#2015-2015-12-31">[2015] - 2015-12-31</a></h5>
<div class="sect5">
<h6 id="changes-5"><a class="anchor" href="#changes-5"></a><a class="link" href="#changes-5">Changes</a></h6>
<div class="ulist">
<ul>
<li>
<p>Make the process of retiring/removing project members explicit (Bug 376001).</p>
</li>
<li>
<p>Streamline review requirements (Bug 415620).</p>
</li>
<li>
<p>Rewrite the section on requirements to be more clear and succinct (Bug 416185).</p>
</li>
<li>
<p>Appointed members of the Architecture Council are appointed to two (Bug 418208) year renewable terms.</p>
</li>
<li>
<p>Include "Freedom of Action" requirement in the EDP (Bug 471367).</p>
</li>
<li>
<p>Generalize the expected output of projects (Bug 477238).</p>
</li>
<li>
<p>Include definitions of terms required by other legal documents (Bug 480526).</p>
</li>
<li>
<p>Only one mentor required for an incubating project (Bug 463850).</p>
</li>
</ul>
</div>
</div>
</div>
</div>
</div>
</div>
</div>