<HTML>
<HEAD>

<!-- Browseable online at https://netbeans.org/community/news/edge-23_fr.html -->

<title>NetBeans Edge - Numéro 23 - Mai 2004</title>
<meta NAME="description" CONTENT="The NetBeans Edge monthly newsletter, Numéro 23, Mai 2004 /French Edition">
<meta http-equiv="content-language" content="fr">
<meta http-equiv="content-type" content="text/html;  charset=utf-8">

<link rel="stylesheet" type="text/css" href="/netbeans.css">
<!-- ------------------------------------------------------ -->
<!-- Please do not edit this file by hand, it is rebuilt    -->
<!-- automatically and your changes will be lost.           -->
<!-- Contact webmaster@netbeans.org for details             -->
<!-- Rebuilt at 2004 24-Jun 14:11 CET                       -->
<!-- ------------------------------------------------------ -->

</HEAD>
<BODY>
<center>
<table border="0" WIDTH="584" bordercolor=red cellpadding="0" cellspacing="0">

<TR>
<TD COLSPAN="3">
<table border='0' cellpadding='0' cellspacing='0' width='100%'>
<tr>
<td width='5' height='88' align='left' valign='top' background='/images_www/marketing_newsletter/template/sprout_banner_bg.gif'><img src='/images_www/marketing_newsletter/template/netbeans-edge-left.png' width='5' height='88' border='0' alt='-'></td>
<td width='100%' height='88' align='center' background='/images_www/marketing_newsletter/template/sprout_banner_bg.gif'><a href='/community/news/newsletter/index.html'><img src='/images_www/marketing_newsletter/template/netbeans-edge.png' width='574' height='88' border='0' alt='banner'></a></td>
<td width='5' height='88' align='right' valign='top' background='/images_www/marketing_newsletter/template/sprout_banner_bg.gif'><img src='/images_www/marketing_newsletter/template/netbeans-edge-right.png' width='5' height='88' border='0' alt='-'></td>
</tr>
</table>
</TD>
</TR>

<tr>
	<td width="173" valign="top" bgcolor="#205481"><a href='https://netbeans.org/'><img src="/images_www/marketing_newsletter/template/transparent-nb-logo.gif" width="173" height="50" border="0" alt="Logo" hspace="0" vspace="0"></a>
	<a href="http://services.netbeans.org/downloads/download.php?a=b&amp;p=1"><img src="/images_www/marketing_newsletter/template/download-36.gif" width="173" height="20" border="0" alt="Download" hspace="0" vspace="0"></a><br>

	<!-- left menu -->

	&nbsp;<br>
  &nbsp;<font face='Verdana, sans-serif, helvetica, arial' size='2' color='#ffffff' class='default'><b>A Surveiller</b></font>
	<table BORDER="0" width="170" cellpadding="0" cellspacing="0" bgcolor="#205481">
	<tr>
		<td valign="top" height="10" background="/images_www/marketing_newsletter/template/transparent_top_menu_l.gif"><img src="/images_www/pixel.gif" width="170" height="10" border="0" alt=""></td>
	</tr>
	<tr>
		<td background="/images_www/marketing_newsletter/template/transparent_middle_menu_l.gif">
		<table border='0' width="160" bgcolor="#205481">
		<td><a href='https://netbeans.org/catalogue' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'>Catalogue de Module</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> Catalogue de modules commerciaux ou gratuits disponibles pour l'EDI NetBeans. <br></font> </td></tr><td><a href='http://www.java.net' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'>java.net</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> Communauté Java dont NetBeans est un membre fédéré<br></font> </td></tr><td><a href='http://services.netbeans.org/downloads/download.php?a=b&amp;p=1' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'>Nouveau! EDI NetBeans 3.6</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> Disponible en Téléchargement<br></font> </td></tr><td><a href='http://developers.sun.com/prodtech/javatools/jsstandard/index.html' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'>Portail Sun Java Studio</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> Ressources concernant NetBeans<br></font> </td></tr>		</table>
	</td>
	</tr>
	<tr>
		<td valign="top" height="26" background="/images_www/marketing_newsletter/template/transparent_bottom_menu_l.gif"><img src="/images_www/pixel.gif" width="170" height="26" border="0" alt=""></td>
	</tr>
	</table>

	<br>&nbsp;<br>
  &nbsp;<font face='Verdana, sans-serif, helvetica, arial' size='2' color='#ffffff' class='default'><b>Discussions Animées</b></font>
	<table BORDER="0" width="170" cellpadding="0" cellspacing="0">
	<tr>
		<td valign="top" height="10" background="/images_www/marketing_newsletter/template/transparent_top_menu_l.gif"><img src="/images_www/pixel.gif" width="170" height="10" border="0" alt=""></td>
	</tr>
	<tr>
		<td background="/images_www/marketing_newsletter/template/transparent_middle_menu_l.gif">
		<table border='0' width="160">
		<tr>
        <td colspan='2' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FF9542'>nbusers</font></td>
        </tr><tr>
              <td><a href='https://netbeans.org/servlets/ReadMsg?msgId=753710&listName=nbusers' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Re: Mount a filesystem? Huh?</font></a></td>
              <td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>42</font></td>
              </tr><tr>
              <td><a href='https://netbeans.org/servlets/ReadMsg?msgId=758391&listName=nbusers' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>someone help?</font></a></td>
              <td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>15</font></td>
              </tr><tr>
              <td><a href='https://netbeans.org/servlets/ReadMsg?msgId=751756&listName=nbusers' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Re: Projects 4.0 questions</font></a></td>
              <td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>12</font></td>
              </tr><tr>
              <td><a href='https://netbeans.org/servlets/ReadMsg?msgId=748064&listName=nbusers' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Re: any date for jsp-compiling in 3.6?</font></a></td>
              <td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>11</font></td>
              </tr><tr>
              <td><a href='https://netbeans.org/servlets/ReadMsg?msgId=758041&listName=nbusers' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Package header help</font></a></td>
              <td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>11</font></td>
              </tr>
	</table>
		</td>
	</tr>
	<tr>
		<td valign="top" height="26" background="/images_www/marketing_newsletter/template/transparent_bottom_menu_l.gif"><img src="/images_www/pixel.gif" width="170" height="26" border="0" alt=""></td>
	</tr>
</table>

<!-- Update by Jack -->
	<br>&nbsp;<br>
&nbsp;<font face='Verdana, sans-serif, helvetica, arial' size='2' color='#ffffff' class='default'><b>Les posteurs les plus actifs</b></font>
	<table BORDER="0" width="170" cellpadding="0" cellspacing="0">
	<tr>
		<td valign="top" height="10" background="/images_www/marketing_newsletter/template/transparent_top_menu_l.gif"><img src="/images_www/pixel.gif" width="170" height="10" border="0" alt=""></td>
	</tr>
	<tr>
		<td background="/images_www/marketing_newsletter/template/transparent_middle_menu_l.gif">
		<table border='0' width="160">
		
<tr><td><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Jesse Glick</font></td>
				<td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>99</font></td>
				</tr><tr><td><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Samuel</font></td>
				<td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>52</font></td>
				</tr><tr><td><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Illya Kysil</font></td>
				<td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>40</font></td>
				</tr><tr><td><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Jaroslav Tulach</font></td>
				<td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>36</font></td>
				</tr><tr><td><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>vincent brabant</font></td>
				<td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>24</font></td>
				</tr>		</table>
		</td>
	</tr>
	<tr>
		<td valign="top" height="26" background="/images_www/marketing_newsletter/template/transparent_bottom_menu_l.gif"><img src="/images_www/pixel.gif" width="170" height="26" border="0" alt=""></td>
	</tr>
</table>

<br>&nbsp;<br>
&nbsp;<font face='Verdana, sans-serif, helvetica, arial' size='2' color='#ffffff' class='default'><b>Statistiques: Mai</b></font>
<table BORDER="0" width="170" cellpadding="0" cellspacing="0">
	<tr>
		<td valign="top" height="10" background="/images_www/marketing_newsletter/template/transparent_top_menu_l.gif"><img src="/images_www/pixel.gif" width="170" height="10" border="0" alt=""></td>
	</tr>
	<tr>
		<td background="/images_www/marketing_newsletter/template/transparent_middle_menu_l.gif">
		<table border='0' width="160">
		<tr>
<td colspan='2' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FF9542'>Téléchargements EID</font></td>
</tr>
<tr>
<td colspan='2' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Total: 1,408,044; +63,799</font></td>
</tr>
<tr>
<td colspan='2' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FF9542'>Téléchargements Plateforme</font></td>
</tr>
<tr>
<td colspan='2' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Total: 50,079; +4,610</font></td>
</tr>
<tr>
<td colspan='2' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FF9542'>Insciptions</font></td>
</tr>
<tr>
<td colspan='2' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Total: 71,217; +31,555</font></td>
</tr>
<tr>
<td colspan='2' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FF9542'>Messages postés</font></td>
</tr>
<tr>
<td colspan='2' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>+3,639</font></td>
</tr>
		</table>
		</td>
	</tr>
	<tr>
		<td valign="top" height="26" background="/images_www/marketing_newsletter/template/transparent_bottom_menu_l.gif"><img src="/images_www/pixel.gif" width="170" height="26" border="0" alt=""></td>
	</tr>
</table>

	<!-- left menu -->

	</td>

<!--
	<td valign="top" height='82' colspan="2" align="right"><img src="/images_www/marketing_newsletter/template/banner.jpg" width="411" height="82" border="0" alt="Banner" hspace="0" vspace="0"></td>
</tr>
<tr>
-->

	<td bgcolor="#FFF0D4" width="410" valign='top'>

	<table border='0' width="100%">
	<tr>
  <td><a href='/community/news/edge-23.html'><img src='/images_www/flags/uk_small.gif' width='20' height='13' alt='English Edition' border='0'></a>&nbsp;<a href='/community/news/edge-23_nl.html'><img src='/images_www/flags/nl_small.gif' width='20' height='13' alt='Dutch Edition' border='0'></a>&nbsp;<a href='/community/news/edge-23_ru.html'><img src='/images_www/flags/ru_small.gif' width='20' height='13' alt='Russian Edition' border='0'></a>&nbsp;</td>  <td align='right'><font face='Verdana, sans-serif, helvetica, arial' ><b>Numéro 23</b></font></td></tr>
	</table>

	<table border='0' width='100%' cellspacing='3' cellpadding='3'>
  <tr>
  <td align='center'><table border='0' cellpadding='0' cellspacing='0' width='98%'>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='TOP' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'>&nbsp;</td>
      <TD  VALIGN='TOP' class='tabler' align='right' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <td class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      <td colspan='2'><a name='s192'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans Edge, Numéro 23</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >Avec l'apparition de l'été dans l'hémisphère Nord, les choses commencent
à chauffer.

<p>Les préparatifs pour le NetBeans Day et JavaOne sont bien en cours et nous
espérons vous un maximum d'entre vous. Pour tout ce qui concerne NetBeans, il 
n'y a pas d'autre endroit où se trouver.

<p>Vous le savez déjà certainement, mais pour ceux d'entre vous qui ne le savent
pas encore, le traffic du site NetBeans.org, les inscrits à la liste de 
distribution et les téléchargements n'ont jamais été aussi grands que 
maintenant.  Un meilleur EDI, une plus grande implication de la communauté, 
et un très bon support de l'industrie sont quelques'unes des forces conductrices.
C'est votre participation qui nous indique la direction du projet NetBeans pour 
ne pas mentionner l'organisation de notre tout premier NetBeans Day!

<p>Et maintenant, il y a une autre façon d'être impliqué.
N'avez-vous jamais rêvé d'être un écrivain et de voir vos travaux publiés ?
Tentez votre chance. Ecrivez un article Comment, concevez un tutoriel, 
conduisez une interview, créez une présentation Flash et dites-nous comment 
vous utilisez NetBeans ou pourquoi vous l'aimez! C'est votre histoire. Révélez
au monde ce que vous pensez qu'ils doivent savoir à propos de NetBeans! Si votre
histoire est publiée dans the Edge, nous vous enverrons un T-Shirt NetBeans.
Envoyez-nous votre histoire à <a
href="mailto:nbmarketing@netbeans.org">nbmarketing@netbeans.org</a>.

<p>Avec notre pied sur l'accélérateur, nous allons ensemble de l'avant. 
Fin juin, vous découvrirez notre nouveau site et une version béta de NetBeans 
4.0 début Juillet. Veuillez boucler votre ceinture parce que NetBeans va
décoller !

<p>Rendez-vous le mois prochain pour que vous restez sur une longueur d'avance
avec NetBeans Edge!</font></td>
      <td><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'><td colspan='4'>&nbsp;</td></tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'><font face='Verdana, sans-serif, helvetica, arial' >&nbsp;Robert Demmer</font><br><font class='smalltext'><i>Translated by: Vincent Brabant</i></font></td>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <TD  colspan='2' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <TD  aligm='right' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      </table><img src='/images_www/pixel.gif' width='1' height='4' bolder='0'><table border='0' cellpadding='0' cellspacing='0' width='98%'>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='TOP' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'>&nbsp;</td>
      <TD  VALIGN='TOP' class='tabler' align='right' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <td class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      <td colspan='2'><a name='s200'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans Sofware Day</b></font><br>&nbsp;<br><a href="" onClick='window.open("/images_www/marketing_newsletter/105_big.png", "", "width=820, height=820, toolbar=no, location=no, directories=no, status=no")'><img src='/images_www/marketing_newsletter/105.png' widht='200' height='46' border='0' alt='NetBeans Day - 4k' align='left' vspace='2' hspace='10'></a><font face='Verdana, sans-serif, helvetica, arial' ><p><p><p>Le NetBeans Day est maintenant tout proche. <p>Obtenez votre ticket
d'entrée gratuite pour le 29 Juin à San Francisco.

<p>Apprenez plus concernant;
<ul><li>Les dernières avancées dans la Technologie NetBeans
<li>Le développement de modules NetBeans pour la plateforme et l'EDI
<li>Le développement J2EE avec NetBeans
<li>Concevoir des Applications Mobiles Avec NetBeans
<li>Partenaires NetBeans</li>
<li>Et bien d'autres choses encore...</li>
</ul>

Les informations mises à jour sont maintenant disponibles concernant le 
programme, la biographies des orateurs, et autres. Les places sont limitées.
Si vous n'êtes pas encore inscrits, faites-le aujourd'hui.

<p>Egalement disponibles pour les membres de la communauté NetBeans: une 
ristourne de 200$ sur le prix d'entrée pour JavaOne.</p>
</font></td>
      <td><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'><td colspan='4'>&nbsp;</td></tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <td><font face='Verdana, sans-serif, helvetica, arial' >[Information NetBeans Day]</font>&nbsp;</td>
      <td align='right'><font face='Verdana, sans-serif, helvetica, arial' >&nbsp;</font></td>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <TD  colspan='2' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <TD  aligm='right' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      </table><img src='/images_www/pixel.gif' width='1' height='4' bolder='0'><table border='0' cellpadding='0' cellspacing='0' width='98%'>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='TOP' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'>&nbsp;</td>
      <TD  VALIGN='TOP' class='tabler' align='right' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <td class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      <td colspan='2'><a name='s198'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans Software Media Kit on CD</b></font><br>&nbsp;<br><a href="" onClick='window.open("/images_www/marketing_newsletter/103_big.png", "", "width=820, height=820, toolbar=no, location=no, directories=no, status=no")'><img src='/images_www/marketing_newsletter/103.png' widht='88' height='88' border='0' alt='NB CD - 4k' align='left' vspace='2' hspace='10'></a><font face='Verdana, sans-serif, helvetica, arial' >Le follement populaire EDI NetBeans 3.6 est maintenant disponible à votre 
convenance sur CD.

<p>Obtenez le dernier Kit Logiciel concernant l'EDI NetBeans 3.6 Mulilingue
(Anglais, Japonais et Chinois Simplifié) pour un coût modique.

<p>Tout ce dont vous avez besoin pour commencez à développez des applications 
Java est inclut : 
L'EDI NetBeans 3.6, la plateforme Java 2 Edition Standard 1.4.2 (J2SE SDK 1.4.2)
 et le pack de modules de mobilité pour NetBeans, les tutoriels et bien d'autres
 choses encore.
 
<p>Supporte les Environnements Windows, Solaris et Linux.</p></font></td>
      <td><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'><td colspan='4'>&nbsp;</td></tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <td><font face='Verdana, sans-serif, helvetica, arial' >[<a href='http://javashoplm.sun.com/ECom/docs/Welcome.jsp?StoreId=1&PartDetailId=NBEI9-306-T99M' target='new'>Commander le Kit NetBeans</a>]</font>&nbsp;</td>
      <td align='right'><font face='Verdana, sans-serif, helvetica, arial' >&nbsp;</font></td>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <TD  colspan='2' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <TD  aligm='right' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      </table><img src='/images_www/pixel.gif' width='1' height='4' bolder='0'><table border='0' cellpadding='0' cellspacing='0' width='98%'>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='TOP' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'>&nbsp;</td>
      <TD  VALIGN='TOP' class='tabler' align='right' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <td class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      <td colspan='2'><a name='s197'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Vote pour le Conseil d'Administration de NetBeans</b></font><br>&nbsp;<br><img src='/images_www/marketing_newsletter/35.jpg' widht='100' height='100' border='0' alt='Governance - 2k' align='left' vspace='2' hspace='10'><font face='Verdana, sans-serif, helvetica, arial' >Les élections du Conseil d'Administration arrivent à leur fins.
Vous avez encore un peut de temps pour enregistrer vos votes, si cela n'est pas
encore faits. La période de vote se terminera le 16 Juin à minuit du dernier
fuseau horaire. Le nouveau conseil sera annoncé le 17 Juin.

<p>Les candidats finaux sont:
<ul>
<li>Vincent Brabant
<li>Meg Garrison
<li>Glenn Holmer
<li>David Strupl
<li>Lluis Turro
<li>Rich Unger</li></ul>

Bonnes chances à tous nos candidats!</p>
</font></td>
      <td><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'><td colspan='4'>&nbsp;</td></tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <td><font face='Verdana, sans-serif, helvetica, arial' >[<a href='https://netbeans.org/community/articles/nbelections.html' target='new'>Voir les profiles des candidats et voter</a>]</font>&nbsp;</td>
      <td align='right'><font face='Verdana, sans-serif, helvetica, arial' >&nbsp;</font></td>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <TD  colspan='2' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <TD  aligm='right' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      </table><img src='/images_www/pixel.gif' width='1' height='4' bolder='0'><table border='0' cellpadding='0' cellspacing='0' width='98%'>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='TOP' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'>&nbsp;</td>
      <TD  VALIGN='TOP' class='tabler' align='right' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <td class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      <td colspan='2'><a name='s201'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Catalogue de Modules</b></font><br>&nbsp;<br><img src='/images_www/marketing_newsletter/36.gif' widht='100' height='100' border='0' alt='Catalogue - 7k' align='left' vspace='2' hspace='10'><font face='Verdana, sans-serif, helvetica, arial' ><b>RefactorIT 2.0.2 Edition Communauté</b>
<p>La version freeware de RefactorIT est maintenant disponible via le 
Centre de Mise à Jour des modules tiers de l'EDI NetBeans 3.6.
Il supporte des projets de taille limitée (50 fichiers sources), et n'inclut
pas de support Ant ou ligne de commande, mais autrement, il est pleinement 
fonctionnel. Il n'a pas de limite dans le temps.
Plus d'information peuvent être trouvée sur <a
href="http://www.refactorit.com">refactorit.com</a>.

<p><b>JRefactory</b> - <a
href="http://plugins.netbeans.org/">Refactoring</a>

<p>JRefactory permet le (re)formattage du code avec beaucoup de styles de 
code et d'options, des commentaires Javadoc par défaut, et tags sont 
optionellement générés. FindBugs 0.7.2 est inclut ainsi qu'un Détecteur de 
Copier Coller et une version de PMD qui est intégré avec un support de 
refactoring. Un visualisateur de Diagramme de Classe UML est inclut, qui permet
également de lancer des actions de refactoring. Il y a 16 refactorings 
actuellement implémentés.

<p><b>App Perfect Code Analyzer</b> - <a
href="http://plugins.netbeans.org/">Outils Java</a>

<p>AppPerfect Code Analyzer est conçu pour exécuter deux fonctions clés du 
développement logiciels: Review du code Java et forcer les bonnes 
pratiques de code. AppPerfect Code Analyzer exécute des analyses statiques de 
votre code source Java et Java Server Pages (JSP).

<p><b>AppPerfect Unit Tester</b> - <a
href="http://plugins.netbeans.org/">Outils Test</a>

<p>AppPerfect Unit Tester est un système de gestion de test unitaire.
Il automatise la génération et l'exécution de vos tests unitaires. Les tests 
unitaires forment les bases des tests logiciels au niveau du développeur. Les 
tests unitaires font généralement références aux tests logiciels basés sur les 
plus petits éléments logique de ce logiciel. En Java, c'est typiquement
un fichier class.

<p><b>AppPerfect JVM Profiler</b> - <a
href="http://plugins.netbeans.org/">Profiling</a>

<p>AppPerfect J2EE/JVM Profiler vous aide à diagnostiquer et résoudre
les problèmes de performance, les <i>memory leaks</i>, les problèmes de 

multi-threading et les problèmes d'usage des ressources systèmes dans vos 
applications Java pour assurez le plus grand niveau de stabilité et 
de <i>scalability</i> de vos applications. AppPerfect J2EE/JVM Profiler 
vous fournit une analyses des causes à l'origine de ces problèmes 
et vous aide à les résoudre.

<p><b>Struts Console</b> - <a
href="http://plugins.netbeans.org/">Web</a>

<p>La mise à jour 4.6 de Struts Console est une application Swing gratuite
pour le développement et la gestion d'applications basées sur Struts. Avec 
Struts Console, vous pouvez éditer visuellement les fichiers de 
configuration JSP Tag Library, Struts, Tiles et Validator.

</font></td>
      <td><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'><td colspan='4'>&nbsp;</td></tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <td><font face='Verdana, sans-serif, helvetica, arial' >[<a href='https://netbeans.org/catalogue' target='new'>Catalogue de Modules</a>]</font>&nbsp;</td>
      <td align='right'><font face='Verdana, sans-serif, helvetica, arial' >&nbsp;</font></td>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <TD  colspan='2' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <TD  aligm='right' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      </table><img src='/images_www/pixel.gif' width='1' height='4' bolder='0'><table border='0' cellpadding='0' cellspacing='0' width='98%'>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='TOP' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'>&nbsp;</td>
      <TD  VALIGN='TOP' class='tabler' align='right' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <td class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      <td colspan='2'><a name='s199'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Articles de Presse</b></font><br>&nbsp;<br><img src='/images_www/marketing_newsletter/3.jpg' widht='100' height='106' border='0' alt='Press - 2k' align='left' vspace='2' hspace='10'><font face='Verdana, sans-serif, helvetica, arial' ><a href="http://wiki.netbeans.org/wiki/view/NetBeansUserFAQ">
FAQ Apps Web Mises à Jour</a>
- Si vous développez des Applications Web et avez des questions, 
cette page est une bonne place par où commencer.

<p><a
href="https://netbeans.org/kb/articles/web-apps-quickstart-36_fr.html">
URL Démarrage Rapide Module Web Corrigée</a> - Dans la dernière édition de 
NetBeans Edge, nous vous avions fourni une URL incorrecte pour ce document.
Nous réparons notre erreur dans ce numéro.

<p><a
href="http://www.prnewswire.com/cgi-bin/stories.pl?ACCT=SVBIZINK3.storySTORY=/www/story/06-01-2004/0002184597EDATE=TUE+Jun+01+2004,+09:06+AM">
Sun Répond à la Demande Générale d'un Desktop Alternatif</a> - Le nouveau
Java Desktop System fournit un riche environnement de développement pour Linux 
et les développeurs Java incluant l'EDI NetBeans 3.6.

<p><a href="http://www.eweek.com/article2/0,1759,1579413,00.asp">eWeek 
passe en revue l'EDI NetBeans</a> - 
Avec une palette inhabituelle de support pour tout types de projets Java, 
spécialement dans un outil si bon marché (téléchargeable gratuitement ou 
9.95$ sur un CD), NetBeans 3.6 de NetBeans.org maintient la bonne cadence de la
communauté open-source des innovations basées sur les standard tout en traçant 
la route pour des raffinement importants du Language Jave et de la plateforme.

<p><a href="http://www.itworld.com/AppDev/716/040510javaleap/pfindex.html">

Java prêt pour un grand saut en avant</a> - 
Pour maximiser Java, Gosling suugère l'utilisation d'outils EDI (
environnement de développement intégré) qui peuvent assister dans tout le 
processus de développement. Il y a des outils pour à peu près tout le monde," 
a déclaré Gosling.
Grandement recommandé est l'EDI NetBeans qui, déclare Gosling, est 
l'outil de développement central, qui est aussi une plateforme pour d'autres 
outils étant aussi extensibles que NetBeans.

<p><a href="http://www.softwarereality.com/reviews/netbeans36.jsp">Review:
NetBeans 3.6 Usability</a> - Veuillez noter que c'est plus 
une review de l'utilisation qu'un review des fonctionnalités. 
NetBeans contient de nombreuses fonctionnalités (<a
href="https://netbeans.org/community/releases/36/Whats_New_fr.html">
Voici une liste </a> de ce qu'il y a de nouveau dans 3.6 -- impressionnant). 
La liste des fonctionnalités est l'un des points forts de NetBeans. 
Aussi, si nous prenons cela en compte, concentrons nous sur les endroits de 
ce puissant EDI qui ont vraiment besoin d'améliorations.

<p>NetBeans 4.0 
Intégrera du Refactoring, Intégration avec Ant - 
Alors que NetBeans 3.6, disponible depuis mi-avril, 
supporte un nouvel interface, NetBeans 4.0, qui est pévu pour le mois d'Août 
comptera un nouveau système de projet qui fonctionne avec Apache Ant et 
qui supportera les modifications faites dans le Langage de Programmation Java.</font></td>
      <td><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'><td colspan='4'>&nbsp;</td></tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <td><font face='Verdana, sans-serif, helvetica, arial' >[<a href='https://netbeans.org/about/press/articles.html' target='new'>archive de presses</a>]</font>&nbsp;</td>
      <td align='right'><font face='Verdana, sans-serif, helvetica, arial' >&nbsp;</font></td>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <TD  colspan='2' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <TD  aligm='right' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      </table><img src='/images_www/pixel.gif' width='1' height='4' bolder='0'><table border='0' cellpadding='0' cellspacing='0' width='98%'>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='TOP' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'>&nbsp;</td>
      <TD  VALIGN='TOP' class='tabler' align='right' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <td class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      <td colspan='2'><a name='s193'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>JUnit Test Generator (TG)</b></font><br>&nbsp;<br><a href="" onClick='window.open("/images_www/marketing_newsletter/104_big.gif", "", "width=820, height=820, toolbar=no, location=no, directories=no, status=no")'><img src='/images_www/marketing_newsletter/104.gif' widht='120' height='60' border='0' alt='Swinburne - 1k' align='left' vspace='2' hspace='10'></a><font face='Verdana, sans-serif, helvetica, arial' >Des Etudiants de l'Université de Swinburne, Melbourne, Australie, viennent 
d'achever la première phase d'un Générateur de Test JUnit, appelé <i>TG</i>.
Leur but initial était de fournir un outil pour 
permettre aux enseignants et professeurs d'automatiser la correction du travail 
des étudiants. Finalement, ils ont développés quelque chose ayant une 
application beaucoup plus large - un Front end à Junit qui simplifie grandement 
et accélère la productuin de scripts de test unitaire en même temps qu'il donne 
au développeur une flexibilté absolue en modifiant ces scripts pour 
satisfaire leurs besoins uniques.

<p><i>TG</i> effectue les choses suivantes :
<ul><li>Lit les propriétés de la classe Java et les convertit en XML pour une
manipulation plus aisée;
<li>Affiche la classe et ses composants dans une arborescence;
<li>Permet aux tests d'être rajouté à chacune des méthodes publiques;
<li>Fournit une 'boite à outils" pour ajouter les éléments de test courants 
- assertion, blocs try catch, etc - à chacun des tests qui se constitue dans un
panneau séparé de l'éditeur;
<li>Utilise un éditeur de coloration syntaxique intégré pour travailler sur les 
test;
<li>Génère un test case natif Java depuis la collection des tests;
<li>Compile et exécute le test case;
<li>Enregistre les tests rechargeables aussi bien en XML qu'en code Java.
</li></ul>

TG comprend de nombreuses autres fonctionnalités qui peuvent être investiguée
en exécutant la version <a href="http://cit3.cdn.swin.edu.au/tg/downloads">
webstart béta </a> également <a
href="http://cit3.cdn.swin.edu.au/majorprojects_2004/js/downloads/webstart/TGW.jnlp">
disponible ici</a>.

<p>Il y a également un système d'aide étendu pour vous assister dans ces 
aspects du système qui ne sont pas immédiatement évident. 
Tous commentaires sont les bienvenus - utilisez la page 'About'
pour les détails de contacts ou la   page d'accueil du projet à:
<ul>
<li>
<a href="http://cit3.cdn.swin.edu.au/tg/">
http://cit3.cdn.swin.edu.au/tg/</a></li></ul>

La phase deux du projet concernera le développement des systèmes de contrôle
de test et de distribution. Nous espérons en faire un projet NetBeans officiel.
NetBeans est utilisé par tous nos étudiants Java, et une option que nous
examinons certainement est l'intégration de TG dans l'EDI NetBeans.</p>
</font></td>
      <td><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'><td colspan='4'>&nbsp;</td></tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <td><font face='Verdana, sans-serif, helvetica, arial' >[<a href='http://cit3.cdn.swin.edu.au/tg' target='new'>page d'accueil du projet</a>]</font>&nbsp;</td>
      <td align='right'><font face='Verdana, sans-serif, helvetica, arial' >&nbsp;Wayne Abrehart</font></td>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <TD  colspan='2' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <TD  aligm='right' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      </table><img src='/images_www/pixel.gif' width='1' height='4' bolder='0'></td>
  </tr>
  </table>
	</td>
	<TD width="1" bgcolor="#205481"><IMG SRG="/images_www/pixel.gif" width="1" height="850" src="/images_www/pixel.gif" border="0" alt=""></TD>
</tr>
<tr>
<td height='5' bgcolor="#205481"><img src='/images_www/marketing_newsletter/template/sprout_b_l.gif' width='5' height='5' border='0' alt='-'></td>
<td colspan='2' height='5' align='right' background='/images_www/marketing_newsletter/template/sprout_b_c.gif'><img src='/images_www/marketing_newsletter/template/sprout_b_r.gif' width='5' height='5' border='0' alt='-'></td>
</tr>

</table>
</center>
</BODY>
</HTML>
