<html><head>
<link rel="stylesheet" href="../default_style.css">
<title>Eclipse.org consortium</title></head>
<body>
<table border=0 cellspacing=5 cellpadding=2 width="100%" >
  <tr> 
    <td align=left width="72%"> <font class=indextop> eclipse.org<br>member agreement</font> 
      <br>
      <font class=indexsub> the open community driving the eclipse platform</font> </td>
    <td width="28%"><img src="../images/Idea.jpg" height=86 width=120></td>
  </tr>
</table>
<table border=0 cellspacing=5 cellpadding=2 width="100%" >
  <tr> 
    <td align="left" valign="top" bgcolor="#0080C0"><b><font color="#FFFFFF" face="Arial,Helvetica">eclipse.org 
      agreement of members</font></b></td>
  </tr>
  <tr> 
    <td> 
<P>This &quot;Agreement&quot; is intended to document your participation and to facilitate your cooperation as a member in Eclipse.org (&quot;Member&quot;).  Eclipse.org seeks Members who are willing to make substantial contributions in terms of time, technology, knowledge, and/or industry expertise and who share in the Eclipse.org vision.  That vision is to create an open platform for tool integration (&quot;Code Base&quot;) built by an open community of tool providers, operating under an open source model, with a Common Public License that grants royalty free source code and world-wide re-distribution rights.  As a Member, you will be extended additional privileges such as voting to establish the projects, policies, practices and priorities in Eclipse.org not available to the general community.  However, these privileges entail additional responsibilities, both to Eclipse.org and to other Members. This Agreement describes those privileges and responsibilities.</P>

<h3>1. Organization and Membership.  </h3>

<h4>1.1 Nominations and Election of Stewards</h4>
<P>As a Member you will be entitled to nominate one (1) Steward to the Board.  Your Nominee must complete an application form which is available on the Eclipse.org web site. Your nominee must be approved for participation on the Board by a two-thirds (2/3) majority of all existing Stewards.  If approved, your Steward will represent your organization in Eclipse.org and will act in accordance with the Bylaws.  You agree to support your Steward in the performance of his/her role in Eclipse.org.</P>

<h4>1.2 Eclipse.org Board and Bylaws</h4>
<P>Eclipse.org will be organized, managed, and administered by a Board.  Polices and procedures under which the Board shall operate are specified in the Eclipse.org Bylaws (&quot;Bylaws&quot;) attached to this document as Exhibit A.</P>

<h4>1.3 Addition of a Member</h4>
<P>Entities or persons who share in the Eclipse.Org vision may apply to the Board to become a Member in Eclipse.org.  If a two-thirds (2/3) majority of all existing Stewards agree with the acceptance of such person or entity as a Member and such person or entity signs the Membership Agreement, the person or company becomes a Member.</P>

<h4>1.4 Withdrawal or Removal of a Member</h4>

<P>You may terminate this Agreement and your participation in Eclipse.org as a Member at any time by sending a signed, written notice to the Secretary of the Board.  </P>

<P>A two-thirds (2/3) majority of all other existing Stewards may decide to terminate this Agreement and your participation in Eclipse.org as a Member.  If that happens, the Secretary of the Board will send you a signed, written notice stating that this Agreement has been terminated. Termination of this Agreement (for any reason) does not affect your rights or obligations under the Common Public License; it only terminates your participation in Eclipse.Org as a Member.  You may continue to use the Code Base as long as you comply with the Common Public License.</P>

<h4>1.5 Chairperson and Secretary of the Board</h4>
<P>A Chairperson and a Secretary shall be appointed by a majority of the Stewards.  The Chairperson and Secretary shall act in accordance with their roles as defined in the Bylaws.  In the event of an equal tie decision in any vote requiring a majority of the Stewards, the Chairperson shall be permitted to cast a single vote to break the tie.  The Chairperson and  Secretary have no other voting rights on the Board.  </P>

<h4>1.6 Affiliated Companies and Persons</h4>
<P>Corporations who are members of a group of corporations or who are affiliated by virtue of common ownership or a parent subsidiary relationship shall be entitled to only one Steward for the group of corporations or affiliates.</P>

<P>Similarly, only one person from a group of individuals who are members of a partnership may serve as a Steward.</P>

<h4>1.7 General</h4>
<P>Notwithstanding anything in this Agreement or the Bylaws to the contrary, Eclipse.org is not a legal entity (such as a corporation or limited liability company), and is not a partnership or joint venture. This means that you are not authorized to bind Eclipse.org or its Members to any contractual obligations. You are only authorized to act on your own behalf. Each member is alone responsible for its actions and omissions and the actions and omissions of its employees if the Member is an entity.</P>

<h3>2. Decision-Making. </h3>

<h4>2.1 Major Decisions</h4>
<P>Except as specifically outlined elsewhere in this Agreement, major decisions concerning Eclipse.org, such as (A) the formation or dissolution of one or more projects, and (B) the appointment, removal or replacement of a Project Lead, will be made by a majority of the Stewards.  </P>

<h4>2.2 Day-to-day Operation</h4>
<P>A majority of the Stewards will set the ground rules and procedures for the day-to-day management of Eclipse.org.</P>

<h4>2.3 Committees</h4>
<P>A majority of the Stewards may create one or more committees to address specific or general operating issues or the management of projects.  Committees may not be empowered to make decisions or take actions that require specific majority vote of the Stewards as outlined herein.</P>

<h3>3. Projects.  </h3>

<h4>3.1 Creation of a Project</h4>
<P>The Stewards may decide to establish one or more Projects consistent with the Vision.  If this happens, the Stewards will define the scope, establish a written charter, and appoint a Project Lead for each Project.  The Project Lead for a project can be changed by a decision of a majority of the Stewards.  The Stewards will also implement a process  so that contributions to the Project and to Eclipse.org can be licensed under the terms and conditions of the Common Public License.</P>

<h4>3.2 Role of the Project Lead</h4>
<P>The Project Lead will set the ground rules and procedures for the day-to-day management of the Project in accordance with the charter for the Project.  The Project Lead will be a member of the Board for the duration of the Project.  However, the Project Lead will not be entitled to a vote at Board meetings unless that person is also a Steward.</P>

<h4>3.3 Cancellation of Project</h4>
<P>A Project can be cancelled by a decision of a majority of the Stewards.</P>

<h3>4. Common Public License. </h3>

<P>This Agreement is a supplement to the Common Public License attached to this document as <U>Exhibit B</U>. You agree that your participation in Eclipse.org is subject to the terms and conditions of the Common Public License in addition to this Agreement.  </P>

<h3>5. Costs and Expenses, Providing Resources.  </h3>

<P>Each Member will bear its own costs for participating in Eclipse.org, including any travel costs.  The Members are expected to collectively provide the support and resources necessary for the operation of Eclipse.org to ensure that its Vision is realized.  This support may include, but not be limited to, marketing support, public relations, facilities, and computer systems.  Unless specified otherwise in a signed agreement, any such support is not guaranteed to continue uninterrupted during its term.  For example, business plans of the Member may require interruptions arising from maintenance or relocation of the equipment, and may require assignment of alternative space.  Any such support, resources, including development code and personnel, equipment, space, and services provided by a Member are provided on an as-is basis, without warranty of any kind.  A Member may find it advisable to terminate any such support and may do so at any time in its sole discretion.  The Member is not required to provide any notice, but agrees to notify the Secretary of the Board as soon as possible.</P>

<P>Members are expected to honor any specific offers of support made by a Steward on behalf of its Member.  Instances of a failure to provide promised support will be reviewed by the Board which may take necessary actions including, but not limited to, revoking membership or suspending voting privileges.</P>

<h3>6. Confidentiality and Publicity. </h3>

<P>Unless specified otherwise in a signed agreement, all information exchanged by Members during the operation of Eclipse.org is non-confidential. However, you agree not to use the name of any other Member to generate publicity unless that Member approves.</P>

<P>The Board shall establish policies and procedures for the management and control of the organizations name and/or logo.  No Member shall use the name and/or logo in any manner which does not comply with such policies and procedures.</P>

<h3>7. Limitations. </h3>

<P>YOUR PARTICIPATION AND THE PARTICIPATION OF THE OTHER MEMBERS IN ECLIPSE.ORG IS ON AN &quot;AS IS&quot; BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  NEITHER YOU NOR ANY MEMBER SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS, LOST SALES, LOST REVENUE OR LOSS OF GOODWILL), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THIS AGREEMENT, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</P>

<h3>8. Changes. </h3>

<P>New developments may make changes to this Agreement necessary or advisable. For example, a modification may add additional terms to facilitate new Project activities. This Agreement may be modified by agreement of a two-thirds (2/3) majority of all Stewards.  The Secretary of the Board must give all current Members fifteen (15) days prior written notice (which may be an email) before the change becomes effective.  Any agreed upon changes shall be prospective only. This Agreement may not be modified in any other manner.</P>

<h3>9. Termination.  </h3>

<P>Please note that termination of this Agreement (for any reason) does not affect the Common Public License; it only terminates your participation in Eclipse.org as a Member. You may continue to use the Code Base as long as you comply with the Common Public License.</P>

<h3>10. Change in Control.  </h3>

<P>If you (i) are a legal entity (such as a corporation or partnership) and not a natural person, and (ii) experience a change in control, then you must notify the other Members within thirty (30) days of the change in the control.  A majority of the current Stewards must indicate their acceptance of your continued status as a Member within sixty (60) days of the change in control or this Agreement and your participation in Eclipse.org as a Member will be terminated.  If that happens, the Secretary will send you a signed written notice.  A change in control is a change in who owns or controls a majority of your ownership interests (such as a change in who holds a majority of your capital stock or other ownership interests) or a change within a short period of time of a majority of your highest level of management (such as a change within a short period of time of a majority of the members of your board of directors or other similar management board).</P>

<h3>12. Freedom of Action.</h3>

<P>The Members are committed to fostering open competition in the development of open source software, and Eclipse.org is intended to foster such competition.  You hereby acknowledge that you and the other Members may be competitors in certain lines of business and agree to act in a manner which complies in all material respects with applicable state, federal and international antitrust laws and regulations. You agree not to communicate with the other Members in a manner which may violate such laws, which may include communicating with respect to prices, costs, quantity or quality of production levels or other similar information.</P>

<h3>13. General.</h3>

<P>This Agreement will be governed by the laws of the State of New York, without regard to conflicts of law principles. This Agreement, the counterpart versions of this Agreement signed by the other Members, and the Common Public License are the only agreements between you and the other Members with respect to Eclipse.org, and they supersede any prior agreement. This Agreement is a personal contract, and it may not be assigned or otherwise transferred to any other person, including by operation of law. You agree to comply with all applicable laws and regulations while participating in Eclipse.org.</P>
<hr width="85%">
      <p><a href="main.html">Return to the eclipse.org consortium main page</a></p>
      </td>
  </tr>
  </table>
&nbsp;
&nbsp;
</body></html>
