<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> hyades UML2 test profile</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> 
        Eclipse Project Hyades to Implement UML Test Profile</b></span></b></h1>
      <UL>
        <LI>Automated Software Quality (ASQ) Project Works to Release U2TP Drivers Into Open-Source Community</LI>
	  </UL>
      <P>
RALEIGH, NC--April 15, 2003--Eclipse project Hyades announced today its commitment to release an open-source implementation of the UML 2 Test Profile specification (U2TP), which was submitted to the Object Management Group (OMG) on March 3, 2003. The U2TP specification was well received by the OMG and is scheduled for approval at the next Technical Meeting in June 2003.       </p>
      <P>
The Hyades project will provide full lifecycle integration of advanced test and trace facilities for Automated Software Quality (ASQ) and boasts some leading software companies in its membership, including IBM's WebSphere and Rational Software divisions, Parasoft, Scapa Technologies, Telelogic and SAP.  Hyades today also welcomed Eclipse member Fraunhofer Institute for Open-Communication Systems (FOKUS), which led the U2TP specification initiative as an active project participant.	  </p>
	  <P> Hyades is committed to implementing the U2TP which is expected to be 
        formally adopted by the OMG later in 2003. The U2TP specification itself 
        can be found at <a href="http://www.fokus.fraunhofer.de/u2tp" target="_blank">www.fokus.fraunhofer.de/u2tp</a>. 
        Facilities to manage and manipulate U2TP-based test models inside the 
        Eclipse workbench through the Eclipse Modeling Framework are already available 
        at <a href="http://www.eclipse.org/hyades" target="_blank">www.eclipse.org/hyades</a>. 
        The Hyades implementation will track changes to the U2TP model and the 
        underlying UML 2 language as these standards move towards final adoption 
        and contribute coordinated feedback into the finalization process. </p>
      <P>
Mike Norman, Hyades project lead and CEO of Scapa Technologies, commented, "The implementation of the U2TP standard in the Eclipse framework offers the Automated Software Quality community an opportunity to move from poorly-integrated, proprietary testing and tracing solutions to a set of interoperable tools based around open standards inside a universal tools platform.  The Hyades project is building this interoperability layer for the benefit of the whole Eclipse ecosystem and we look forward to working with FOKUS to that end."	  </p>
      <P>
FOKUS has been involved in defining test profiles for a variety of telecom and datacom technologies and instrumental in driving standardization initiatives in the OMG and the European Telecommunications Standards Institute (ETSI).	  </p>
      <P>
Ina Schieferdecker, Head of the Competence Center for Testing, Interoperability and Performance (TIP) within FOKUS, led the U2TP specification process.  On joining Hyades, Dr Schieferdecker said, "The U2TP work is now moving from specification to implementation. By joining Hyades at this time we will provide continuity as this important emerging standard is implemented for the benefit of the whole Eclipse ecosystem-from Enterprise software through to embedded systems."	  </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 The Hyades Project</font></b></td>
		</TR>
		<TR>
		<td align=left>
		<TABLE  width="100%" CELLSPACING=0 CELLPADDING=3>
		<tr>
		  <td> 
            <P>The Hyades project provides an open-source platform for Automated Software Quality (ASQ) tools and a range of open-source reference implementations of ASQ tooling for testing, tracing and monitoring software systems.  By closely integrating ASQ tooling into the Eclipse development environment and providing effective tool interoperability among ASQ tools and with other tools, the Hyades project aims to allow a consistent and continuous approach to ASQ processes from the earliest stages of development through to deployment and out into production.  For ASQ tool vendors and integrators, Hyades is delivering an extensible framework and infrastructure that embraces automated testing, trace, profiling, monitoring and asset management.</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">About 
      FOKUS</font></b></td>
		</TR>
		<TR>
		<td align=left>
		<TABLE  width="100%" CELLSPACING=0 CELLPADDING=3>
		<tr>
		  <td> 
            <P>FOKUS researches and develops advanced technologies for the information society, inspired by a vision of a user-oriented PC and communication environment available at any time.  The vision takes full account of the versatility and individuality of users and their personal attitudes and capabilities and it also covers place and time factors governing information selection and the range of options open to the user for access to the communication environment.  Driven by this vision, FOKUS has developed a seamless communication infrastructure which can carry global location-neutral services in a range of different quality levels.</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>
