<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> JDJ editors' choice awards</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">News 
      Advisory </font></b></td>
  </tr>
  <tr> 
    <td> <br>
      <h1 ALIGN="CENTER"><b><span style='font-size:16.0pt;font-family:Arial;"Times New Roman"'><b> 
        Eclipse.org Receives Two JDJ Editors' Awards</b></span></b></h1>
      <UL>
        <LI>Honored for J2SE and Eclipse Platform Technology</LI>
      </UL>
      <P> In the June issue of Java Developer's Journal, the editors announced 
        that Eclipse platform has been awarded two JDJ Editors' Choice Awards.</p>
      <P> Jason Bell, J2SE editor for JDJ, wrote &quot;After being anti-IDE for 
        so long I've finally caved in. It (Eclipse) has nice CVS utils, project 
        frameworks, code refactoring and 'sensible' code generation (especially 
        for beans). Add industry backing and a very fired up user base and you 
        have one winning product.&quot;</p>
	  <P> Glen Cordrey, the J2ME editor, commented &quot;Again, free goes a long 
        way, especially with the support piling up behind it (Eclipse).</p>
      <P> &quot;We are pleased and honored that JDJ editors have recognized the 
        Eclipse platform not only for its innovation, but also as a highly productive 
        development environment,&quot; stated John Wiegand, Eclipse project lead. 
        &quot;The community has worked hard to ensure that the Eclipse Platform 
        is a highly productive platform for creating, integrating and deploying 
        application development tools for use across a broad range of operating 
        environments.&quot;</p>
      </td>
  </tr>
  </table>
&nbsp;

		<table width="100%" cellspacing=0 cellpadding=3 align=center>
		<tr bgcolor="#999999">
		
    <td align="left" valign="top" bgcolor="#0080C0"><font color="#FFFFFF" face="Arial,Helvetica"><b>About the JDJ Editors' 
      Choice Awards</b></font></td>
		</TR>
		<TR>
		<td align=left>
		<TABLE  width="100%" CELLSPACING=0 CELLPADDING=3>
		<tr>
		  <td> 
            <P>The editors of Java Developer's Journal are in a unique position 
              when it comes to Java development. All are active coders in their 
              &quot;day jobs,&quot; and they have the good fortune to getting 
              a heads up on many of the latest and greatest software releases. 
              They were asked to nominate three products from the last 12 months 
              that they felt had not only made a major impact on their own development, 
              but also on the Java community as a whole.</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">About 
      Eclipse</font></b></td>
		</TR>
		<TR>
		<td align=left>
		<TABLE  width="100%" CELLSPACING=0 CELLPADDING=3>
		<tr>
		  <td> 
            <P>Eclipse is an open source ecosystem of royalty-free technology 
              and a universal 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;, MacOS&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 
              <a href="http://www.eclipse.org" target="_blank">http://www.eclipse.org</a>. 
            </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>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. Java and all Java-based trademarks 
              are trademarks or registered trademarks of Sun Microsystems, Inc. 
              in the United States and other countries.</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>
