<h1 id="new-eclipse-foundation-committer-and-contributor-agreements">New
	Eclipse Foundation Committer and Contributor Agreements FAQ</h1>

<p>As most are aware, the Eclipse Foundation is now about to start
	hosting specifications as open source projects. This is very exciting
	for us, and we think it represents a new opportunity for creating
	innovative specifications using a vendor neutral process. The first
	specification projects will be a part of the Jakarta EE initiative, but
	we expect other specification projects to follow shortly.</p>
<p>As a result, we have updated our standard contributor and
	committer agreements, and all our committers and contributors, as well
	as those members who have member committer agreements, will need to
	re-sign their agreement with us.</p>
<h2 id="what-agreements-have-changed">What Agreements have Changed?</h2>
<ol>
	<li><a href="https://www.eclipse.org/legal/ECA.php">Eclipse
				Contributor Agreement</a> (ECA);</li>
	<li><a
		href="https://www.eclipse.org/legal/committer_process/EclipseIndividualCommitterAgreementFinal.pdf">Eclipse
				Individual Committer Agreement</a> (ICA); and</li>
	<li><a
		href="https://www.eclipse.org/legal/EclipseMemberCommitterAgreementFinal.pdf">Eclipse
				Member Committer and Contributor Agreement</a> (MCCA) (Formally <em>Member Committer Agreement</em>).</li>
</ol>
<h2 id="what-changes-were-made-to-the-agreements">What Changes were
	made to the Agreements?</h2>
<p>The changes to the Agreements are basically:</p>
<ol>
	<li>We added terms to explicitly allow code contributions to
		Eclipse projects to be used as the basis for specifications. As you
		may know, the Eclipse Foundation has created a new specification
		process, largely motivated by the migration of the Java EE
		specifications from Oracle's Java Community Process (JCP) to the
		Eclipse Foundation.</li>
	<li>We added terms to the committer agreements which embed what is
		covered by the Eclipse Contributor Agreement (ECA). So now committers
		only have to sign or be covered by one document. This reduces the
		amount of paperwork required from committers, and eliminates the
		requirement for employees of member companies with an MCCA to
		individually sign an ECA.</li>
</ol>
<p>The links below provide redlined PDFs showing the differences
	between the previous version of the agreements, and the revisions
	announced on November 5, 2018. We encourage you to review these with
	your advisors.</p>
<ol>
	<li><a
		href="2018-09-26-final-eclipse-contributor-agreement-redline.pdf">Eclipse 
				Contributor Agreement</a> (annotated);</li>
	<li><a
		href="2018-10-22-final-individual-committer-agreement-redline.pdf">Individual
				Committer Agreement</a> (annotated); and</li>
	<li><a
		href="2018-11-05-final-member-committer-and-contributor-agreement-redline.pdf">Member
				Committer and Contributor Agreement</a> (annotated).</li>
</ol>
<h2 id="how-does-this-re-signing-exercise-affect-me">How does this
	Re-signing Exercise affect me?</h2>
<p>If you are an existing Eclipse Committer or Contributor, staff
	will be reaching out personally to you in the future requesting you
	update your agreement.</p>
<p>Please note that this effort will take a number of months to
	complete as this involves hundreds of agreements. We are committed to
	make this update happen in as smooth a fashion as possible and to have
	virtually no disruption to the flow of contributions being made. We are
	hopeful that you will be supportive of the change, and will react
	quickly and favorably when we do contact you.</p>
<h2
	id="does-my-employer-still-need-to-complete-the-eclipse-employer-consent-form">Does
	my employer still need to complete the Eclipse Employer Consent Form?</h2>
<p>No, the Eclipse Employer Consent Form is no longer a requirement
	as that obligation has now been incorporated into the Individual
	Committer Agreement (see Section 1.4 Committer Representations)</p>
<h2 id="what-is-the-difference-between-an-ica-the-mcca-and-the-eca">What
	is the difference between an ICA, the MCCA and the ECA?</h2>
<p>The Eclipse Individual Committer Agreement (ICA) is required by
	Eclipse Committers who are not employed by an Eclipse Member which has
	a Member Committer and Contributor Agreement on file.</p>
<p>The Eclipse Member Committer and Contributor Agreement (MCCA) can
	be signed only by Eclipse Members. This agreement covers all
	employees/contractors/contributors employed by said Member.</p>
<p>The Eclipse Contributor Agreement (ECA) is required by all other
	non Eclipse Committers in order to contribute to Eclipse projects.</p>
<h2
	id="the-member-committer-agreement-is-now-the-member-committer-and-contributor-agreement.-why-the-change">The
	Member Committer Agreement is now the Member Committer and Contributor
	Agreement. Why the change?</h2>
<p>This agreement has been updated to include not only those
	committers in a Member’s employ, but contributors as well. We leveraged
	this opportunity to incorporate this feature into the former Member
	Committer Agreement. We plan on providing quarterly updates to members
	identifying those covered under this agreement.</p>
<h2
	id="do-i-need-to-re-sign-the-eca-if-ive-already-signed-the-updated-ica">Do
	I need to re-sign the ECA if I’ve already signed the updated ICA?</h2>
<p>By re-signing the Individual Committer Agreement (dated Oct/18),
	you will no longer be required to sign the Eclipse Contributor
	Agreement.</p>
<h2
	id="how-do-i-know-if-i-am-already-covered-by-a-member-committer-agreement">How
	do I know if I am already covered by a Member Committer Agreement?</h2>
<p>
	Your Eclipse Company Representative should know the answer to this
	question. If they do not or there is uncertainty, please email <a
		href="mailto:emo-records@eclipse.org">emo-records@eclipse.org</a>
	requesting this information.
</p>
<h2 id="how-do-i-re-sign-my-agreement">How do I Re-sign my
	Agreement?</h2>
<p>You will receive a personal email providing you with instructions
	on how to complete the revised agreement.</p>
<h2
	id="i-am-a-committer-employed-by-a-member-company---do-i-have-to-do-anything">I
	am a Committer employed by a Member Company - Do I have to do anything?
</h2>
<p>If your employer is an Eclipse Member with a Member Committer
	Agreement on file, we will be working with those Members to arrange for
	them to sign the updated agreement. You will receive email
	communication identifying when your employer has signed the new
	agreement and will confirm you do not need do anything else.</p>
<p>If your employer is an Eclipse Member which does not have a
	Member Committer Agreement on file, they will have the opportunity to
	sign the new agreement. However, at this time, we would ask you to
	re-sign the Individual Committer Agreement only. Please note the Eclipse
	Employer Consent Form is no longer a requirement.</p>
<h2 id="how-will-i-know-if-i-re-signed-successfully">How will I
	know if I Re-signed Successfully?</h2>
<p>You will receive a copy of the executed agreement via email. If
	you re-signed the ECA, when you log into eclipse.accounts.org, the
	system will indicate you have signed The Eclipse Contributor Agreement
	version 3.0.0.</p>
<h2 id="are-there-any-legal-obligations-requiring-me-to-resign">Are
	there any legal obligations requiring me to re-sign?</h2>
<p>No, there are no legal obligations requiring you to re-sign.</p>
<h2 id="what-happens-if-i-do-not-resign-my-committer-agreement">What
	Happens If I do not Re-sign My Committer Agreement?</h2>
<p>Unfortunately, Individual Committers who do not re-sign will have
	their committer accounts revoked at the end of the exercise.</p>
<h2 id="what-happens-if-i-do-not-resign-my-contributor-agreement">What
	Happens If I do not Re-sign My Contributor Agreement?</h2>
<p>Unfortunately, Eclipse Contributors will lose their ability to
	contribute to Eclipse projects.</p>
<h2 id="how-can-i-opt-out-of-this-re-signing-exercise">How can I
	opt out of this Re-signing Exercise?</h2>
<p>
	Should you decide to opt out, you must relinquish your
	committer/contributor status. To opt out, send an email to <a
		href="mailto:emo-records@eclipse.org">emo-records@eclipse.org</a>.
</p>
<h2
	id="i-believe-my-employer-information-is-incorrect-in-your-systems.-what-do-i-do">I
	believe my Employer Information is incorrect in your systems. What do I
	do?</h2>
<p>
	Please log into <a href="https://accounts.eclipse.org/">accounts.eclipse.org</a>
	and update your employer information. It is your responsibility as a
	committer to ensure we have accurate employer information and the
	necessary legal paperwork on file to cover your committer account.
</p>
<h2 id="i-have-questions-not-listed-here-who-do-i-contact">I have
	questions not listed here, who do I contact?</h2>
<p>
	Please send an email to <a href="mailto:license@eclipse.org">license@eclipse.org</a>
</p>
