<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> cobol IDE</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> 
        Major Corporations Back New Eclipse Open Source COBOL IDE Project</b></span></b></h1>
      
      <P>RALEIGH, NC Dec. 05, 2002 Eclipse has launched a new open-source project focused on 
	  development tools for the COBOL language. The project has been organized by Eclipse member 
	  companies Fujitsu, Hitachi, IBM, and Serena Software, who are participating in the development 
	  of COBOL related extensions to the Eclipse platform. </p>
	  
		<p>"To help establish the Eclipse COBOL Tools Project, Fujitsu has donated our work on COBOL tools developed for our NetCOBOL for Linux product," said Ronald Alepin, Vice President Strategic Planning, Fujitsu Software Corporation. "We're committed to helping the tools development community deliver leading edge features, allowing other vendors and users, to add increasingly powerful complementary facilities."</p> 
		<p>"As a founding, and participating member in eclipse, we welcome this initiative to help integrate COBOL developers into the Open Source community", said David Chew, Director, Enterprise Transaction Systems at IBM. </p> 
		<p>"This is a significant step in the mission of creating a truly multi-language platform in Eclipse," said Ryuji Takanuki, Director, Language Processor and Development Environment, Software Division, Hitachi, Ltd, "Hitachi is excited at the opportunity to collaborate with the other Eclipse members in creating and deploying an integrated development environment for COBOL applications."</p> 
		<p>"At Serena, we work extensively with enterprise project development teams that rely on COBOL during their project lifecycles," said Kevin Parker, Vice President of Research and Development, SERENA Software, Inc. "We became involved in and are dedicated to this project to help customers improve the overall development infrastructure as applications and enterprise architectures increasingly become more sophisticated and evolved."</p> 
		<p>The COBOL project starts with six plug-ins to the Eclipse base that provide functions such as bridging to a COBOL compiler, COBOL sensitive editor, and building and debugging COBOL applications. All the features are integrated into the Eclipse IDE and demonstrate the adaptability of the Eclipse platform to different programming languages and tasks.</p> 
		<p>Eclipse plug-in tools serve a large community of developers working on projects worldwide. COBOL now joins Java(R) and C/C++ in language oriented projects active within Eclipse. Independent tools providers are developing additional support for other development languages for use within the Eclipse development environment. </p> 
		<p>The Eclipse Platform and information on the Eclipse COBOL Project, including documentation and source code are available immediately via download from 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> Eclipse is an open-source community that creates technology, 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(TM) 
            language, and comes with extensive plug-in construction toolkits and 
            examples. It has already been deployed on a range of development workstations 
            including Linux(R), QNX(R) and Windows(R) based systems. Full details 
            of the Eclipse community and white papers documenting the design of 
            the Eclipse Platform are available at www.eclipse.org.<br>
            <br>
            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.
         </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> 
            <div align="center">Contact: Marc Erickson <br>
              Email: mre@us.ibm.com <br>
              Contact Tel: 919-562-8283 </div>
            <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, WebSphere. DB2, MQSeries, and VisualAge are trademarks 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>
