<html><head>
<link rel="stylesheet" href="../../default_style.css">
<title>Eclipse.org consortium</title></head>
<body text="#000000" bgcolor="#ffffff" link="#0000ee" vlink="#551a8b" alink="#ff0000">
<table border=0 cellspacing=5 cellpadding=2 width="100%" >
  <tr> 
    <td align=left width="72%"> <font class=indextop> koi project</font><br>
      <font class=indexsub> </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">Press release</font></b></td>
  </tr>
  <tr> 
    <td> <br>
      <h1 ALIGN="CENTER"><b><span style='font-size:16.0pt;font-family:Arial;"Times New Roman"'><b> 
        New Eclipse Project Addresses Collaborative Development<br>
        Infrastructure Requirements </b></span></b></h1>
      <UL>
        <LI>Infrastructure is basis for extending platform to support developer collaboration</LI>
        <LI>Instantiations, Inc. donates source code to launch project</LI>
      </UL>
	
      <P>December 19, 2002 - Eclipse has launched a new open-source project focused on creating an infrastructure for developer collaboration tools. Instantiations, a supporting member of Eclipse, is organizing the project and has contributed a substantial body of source code to the effort. The Koi Project will make it possible to create new categories of developer collaboration tools with the Eclipse Platform and other tools. The Eclipse Platform and information on the Koi Project, including documentation and project source code, are available via download from http://www.eclipse.org.  
      </p>
      <P>"At Instantiations, we understand the needs of enterprise development teams who create business critical software systems," said Allen Wirfs-Brock, Chief Technology Officer, Instantiations, Inc. "We initiated the Koi Project because we are dedicated to enhancing the overall development infrastructure of the Eclipse Platform as applications and developer requirements increasingly become more sophisticated."</p>
	  <P>The Eclipse Platform provides an excellent base for hosting innovative development tools. Current collaborative development in Eclipse is limited to course-grained file revision via access to external source code control systems. The goal of the Koi Project is to develop standard facilities that support dynamic, fine-grained collaborative activities between development team members. </p>
      <P>"Adding the infrastructure for collaborative development, via the Koi Project, is a major extension to the Eclipse Platform," said Skip McGaughey, chairperson of the Eclipse Board of Stewards. "Instantiations has taken a leadership role in this project and we're excited about working within the Eclipse community to implement the collaborative development infrastructure." </p>
      <P>Eclipse plug-in tools serve a large community of developers working on projects worldwide. Koi now joins the XSD, AspectJ and Stellation projects that are active within the Eclipse Technology PMC. Many independent tool providers are developing additional support for other technologies for use within the Eclipse development environment. </p>
      <P>The Eclipse Platform and information on the Eclipse Koi Project, including documentation and source code are available via download from http://www.eclipse.org. </p>

      </td>
  </tr>
  </table>
&nbsp;

		<table width="100%" cellspacing=0 cellpadding=3 align=center>
		<tr bgcolor="#999999">
		
    <td align="left" valign="top" bgcolor="#0080C0"><b><font color="#FFFFFF" face="Arial,Helvetica">About 
      Eclipse</font></b></td>
		</TR>
		<TR>
		<td align=left>
		<TABLE  width="100%" CELLSPACING=0 CELLPADDING=3>
		<tr>
		  <td> 
            <P>Eclipse is establishing an ecosystem for open-source development 
              technology based on an open universal platform for tools integration. 
              The open-source Eclipse community creates royalty-free technology 
              as a platform for tools integration. Eclipse based tools give developers 
              freedom of choice in a multi-language, multi-platform, multi-vendor 
              supported environment. Eclipse delivers a plug-in based framework 
              that makes it easier to create, integrate and use software tools, 
              saving time and money. By collaborating and sharing core integration 
              technology, tool producers can concentrate on their areas of expertise 
              and the creation of new development technology. The Eclipse Platform 
              is written in the Java&#153; language, and comes with extensive 
              plug-in construction toolkits and examples. It has already been 
              deployed on a range of development workstations including Linux&reg;, 
              QNX&reg; and Windows&reg; based systems. Full details of the Eclipse 
              community and white papers documenting the design of the Eclipse 
              Platform are available at http://www.eclipse.org.</p>

		</td>
		</tr>
        </table></table>&nbsp;

		<table width="100%" cellspacing=0 cellpadding=3 align=center>
		<tr bgcolor="#999999">
		
    <td align="left" valign="top" bgcolor="#0080C0"><b><font color="#FFFFFF" face="Arial,Helvetica">Media 
      contacts</font></b></td>
		</TR>
		<TR>
		<td align=left>
		<TABLE  width="100%" CELLSPACING=0 CELLPADDING=3>
		<tr>
		  <td> 
            <p align="center">Barbara Stewart<br>
              Patterson and Associates<br>
              480-488-6909<br>
              barbara@patterson.com</p>
            <hr width="85%">
              
              <P><SUP>(1) </sup>Some components of Eclipse may be governed by license terms other than the CPL. </P>
            <P>&#9;Brand or product names are registered trademarks or trademarks 
              of their respective holders. IBM is a trademark of International 
              Business Machines Corporation in the United States, other countries, 
              or both. Java and all Java-based trademarks are trademarks or registered 
              trademarks of Sun Microsystems, Inc. in the United States and other 
              countries. Microsoft, Windows, Windows NT and the Windows logo are 
              trademarks of Microsoft Corporation in the United States, other 
              countries, or both.</P>
<hr width="85%">
            <p><a href="../main.html">Return to the eclipse.org consortium main page</a></p>
        </td>
		</tr>
        </table></table>&nbsp;        
&nbsp;
</body></html>
