<HTML>
<HEAD>
<title>NetBeans Edge - Numéro 21 - Avril 2004</title>
<meta NAME="description" CONTENT="The NetBeans Edge monthly newsletter, Numéro 21, Avril 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 05-May 16:19 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 of modules libres et commerciauw disponibles pour votre 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 où NetBeans est un membre fédéré<br></font> </td></tr><td><a href='http://' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'></font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> <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'>nbdev</font></td>
        </tr><tr>
              <td><a href='https://netbeans.org/servlets/ReadMsg?msgId=729718&listName=nbdev' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Re: "I want an IDE that manage his projects by using Ant !"</font></a></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><a href='https://netbeans.org/servlets/ReadMsg?msgId=726363&listName=nbdev' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>give me "netbeans"</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=738137&listName=nbdev' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Re: How to measure responsivness?</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 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=730169&listName=nbusers' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Project Rave</font></a></td>
              <td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>14</font></td>
              </tr><tr>
              <td><a href='https://netbeans.org/servlets/ReadMsg?msgId=738035&listName=nbusers' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Netbeans Linux performance</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>
	</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'>176</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'>38</font></td>
				</tr><tr><td><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Glenn Holmer</font></td>
				<td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>29</font></td>
				</tr><tr><td><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Trung Duc Tran</font></td>
				<td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>27</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'>26</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: Avril</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,345,614; +83,588</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: 45,540; +3,776</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: 39,662; +19,817</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'>+4,008</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-21_pt_BR.html'><img src='/images_www/flags/pt_small.gif' width='20' height='13' alt='Portuguese Edition' border='0'></a>&nbsp;<a href='/community/news/edge-21_ru.html'><img src='/images_www/flags/ru_small.gif' width='20' height='13' alt='Russian Edition' border='0'></a>&nbsp;<a href='/community/news/edge-21_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-21.html'><img src='/images_www/flags/uk_small.gif' width='20' height='13' alt='English Edition' border='0'></a>&nbsp;</td>  <td align='right'><font face='Verdana, sans-serif, helvetica, arial' ><b>Numéro 21</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='s177'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans Edge, Numéro 21</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' ><p>Bienvenue au 21ième numéro du mensuel NetBeans. Après 20 numéro sous le nom de Sprout (symbolisant la croissance vers la maturité), nous avons décidé qu'il était temps de passer à quelque chose de nouveau, et avec la sortie de NetBeans 3.6, il n'y avait pas de meilleur moment pour vous offrir l'opportunité d'être au-dessus du lot, et d'avoir NetBeans Edge!</p>  <p>Sans surprise, la sortie de l'EDI NetBeans 3.6 est le sujet principal de ce numéro. Félécitation à tous les membres de la Communauté NetBeans.org pour les efforts incroyables en fournissant la dernière version de l'EDI open source, libre et original: l'EDI NetBeans 3.6 !</p>  <p>Ce mois-ci, NetBeans Edge mettra l'accent sur les ressources qui vous aideront à démarrer dans l'utilisation de l'EDI NetBeans 3.6 et à étendre NetBeans montant votre développement d'un cran. NetBeans 3.6 ... . Et après ? NB3.6 sera disponible en plusieurs langues et sera inclus dans diverses offres. Tous les détails dans ce numéro.</p>  <p>Dans le lots des nouvelles concernant NB3.6, le programme NetCAT touche à sa fin. Les résultats de l'enquête Customer Acceptance peuvent être <a href="http://qa.netbeans.org/processes/cat/36/results/ca_results.html">vus</a>.  <p>Il y a eu 86% de participations des membres du programmes NetCAT qui ont voté à cette enquête. Et un autre ... notable fut que le support de Refactoring a été élu comme la fonctionnalité préférée pour la version suivant. Excellent Travail !</p>  <p>Pour comprendre où est NetBeans aujourd'hui et où NetBeans sera demain, Vincent Brabant a interviewé Steve Wilson, Directeur de la Technologie NetBeans. </p>  <p>Comme la future version NetBeans 4.0 commence à se matérialiser, NetBeans Edge vous indiquera la façon dont vous pourrez avoir un avant-gout de: Refactoring, le nouveau système de projet, et d'autres fonctionnalités plannifiées pour la version 4.0. Si vous désirez jeter un regard en arrière avant d'aller de l'avant, allez voir quelques unes de nos <a href="https://netbeans.org/about/press/awards.html">dernières récompenses </a>.</p>  <p>Ce numéro exceptionnel fut mis en place par l'équipe de nbmarketing. Mais n'hésitez pas à <a href="mailto:nbdiscuss-fr@netbeans.org[Suggestions NB Edge]">donner vos suggestions </a> ou <a href="mailto:nbdiscuss-fr@netbeans.org">nous rejoindre</a>.</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>&nbsp;</td>
      <td align='right'><font face='Verdana, sans-serif, helvetica, arial' >&nbsp;Robert Demmer</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='s178'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Ressources EDI NetBeans Version 3.6</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >L'EDI NetBeans 3.6 est maintenant disponible en <a href="http://services.netbeans.org/downloads/download.php?a=b&amp;p=1">téléchargement</a>. La dernière version se voit agrémentée d'un large nombre de fonctionnalités améliorant la productivité de code, le 'look and feel' et fournissant aux développeurs une meilleure intégration pour concevoir des applications web, Swing et mobiles.</p>  <hr> Ressources  <p><b>Aide en Ligne de NetBeans</b> - La documentation incluse dans l'EDI NetBeans lui-même. Pressez F1 pour ouvrir l'aide en ligne.</p>  <p><a href="https://netbeans.org/community/releases/36/Whats_New_fr.html"> Quoi de neuf docteur ?</a> - Lisez à propos des dernières et remarquables fonctionnalités, n'attendant que d'être découverte.<p>  <p><a href="https://netbeans.org/community/releases/36/relnotes_fr.html"> Notes de Version</a> - Désirez savoir ce qui a changé depuis la version 3.5.1? C'est ce docuemt-ci qu'il vous faut lire.  <p><a href="https://netbeans.org/kb/archive/index.html"> Guide de Démarrage Rapide EDI NetBeans 3.6</a> - Ce document vous fait découvrir les bases d'utilisation de l'EDI NetBeans 3.6 en créant une simple application Hello World. Et elle est concue pour que vous progressez aussi rapidement que possible.</p>  <p><a href="https://netbeans.org/kb/archive/index.html"> Utilisez l'EDI 3.6 avec le JDK 1.5 (Tiger) </a> - Un rapide <i>Comment ?</i> pour utiliser NetBeans 3.6 avec JDK 1.5.  <p><a href="https://netbeans.org/kb/archive/index.html">Utiliser l'EDI 3.6</a> - Ce guide est concu pour vous donner une introduction plus détaillée de l'EDI que ce qui est disponible dans le Guide De Démarrage Rapide. De Nombreux aspects de l'EDI sont explorés plus en détail.</p>  <p><a href="https://netbeans.org/kb/archive/index.html">Conception Visuel dans l'EDI NetBeans 3.6</a> - Ce court tutoriel vous guide à travers le processus de création d'une application appelée ColorSwitch. Vous allez concevoir un simple programme qui vous permets de modifier la couleur d'un panneau de gris, vers noir en passant par gris moyen.</p>  <p>Démo Album Photo NetBeans - Mets en évidence quelques unes des fonctionnalités de NetBeans concernant les applications web, de bureau et mobiles. Une démo Flash montre comment utiliser l'EDI NetBeans 3.5.1 mais vous pouvez télécharger une fichier ZIp contenant: code source, script démo, et instruction d'installation pour l'utiliser avec NetBeans 3.6.  <hr>Pour plus de supportn, vous pouvez<a href="https://netbeans.org/community/lists/top.html">souscrire</a> à la liste  nbgeneral-fr@netbeans.org où vous trouverez des amateurs et experts prêts à répondre à vos questions.</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/kb/' target='new'>supports et documents</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='s182'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Versions Multilingues et Offres Couplées</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >Maintenant que la version Anglaise de l'EDI est sortie, il est temps de regarder sur ce qui est encore à venir concernant la version 3.6.  <ul> <li>22 Avril: Offre Couplée Java 2 Edition Standard / EDI NetBeans 3.6 Anglais</li> <li>12 Mai: Version Multilingue de l'EDI NetBeans 3.6 (Chinois, Japonais)</li> <li>12 Mai: Offre Couplée Sun Java System Application Server 8 Platform Edition / EDI NetBeans 3.6 Anglais</li> <li>18 Mai: Offre Couplée Multilingue (Chinois, Japonais) Java 2 Edition Standard / EDI NetBeans 3.6</li> <li>9 Juin: Offre Couplée Multilingue (Chinois, Japonais) Sun Java System Application Server 8 Platform Edition / EDI NetBeans 3.6</li></ul>  Plus d'information sur <a href="http://java.sun.com/j2se/index.jsp">Java 2 Standard Edition</a> ou <a href="http://wwws.sun.com/software/products/appsrvr_pe/index.html">Sun Java System Application Server 8 Platform Edition</a>.</p>  <p>Egalement en chantier sont les traductions de l'EDI NetBeans 3.6 en Neerlandais et Russe, contribution faites par la communauté. Elles sont actuellement disponibles dans les builds de développement, mais sont attendue pour le mois de Mai ou Juin. Restez à l'écoute pour plus d'informantions.</p>  <p>Si vous désirez contribuer aux efforts de traduction. Veuillez visiter la page <a href="https://netbeans.org/community/contribute/localise.html">Traduire l'EDI NetBeans et/ou Traduire le Contenu du Site Web</a>. </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;</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='s179'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans sous les feux de la rampe: Steve Wilson</b></font><br>&nbsp;<br><a href="" onClick='window.open("/images_www/marketing_newsletter/99_big.jpg", "", "width=820, height=820, toolbar=no, location=no, directories=no, status=no")'><img src='/images_www/marketing_newsletter/99.jpg' widht='100' height='150' border='0' alt='Steve Wilson - 5k' align='left' vspace='2' hspace='10'></a><font face='Verdana, sans-serif, helvetica, arial' >Dans un interview exclusif pour NetBeans Edge, Vincent Brabant a eu une session de Questions/Réponses avec Steve Wilson. Steve a actuellement deux casquettes: une en tant que Directeur Ingénierie pour le Core Developer Platform (CDP) et Directeur pour la Technologie NetBeans.  <p>Voici un petit extrait: <hr> <i>Vincent</i>: Parlez-nous de la collaboration entre l'équipe NetBeans.org, l'équipe Sun Java Studio Enterprise et l'équipe Sun Java Studio Creator <p><i>Steve</i>: Le fait d'avoir ces deux produits commerciaux conçus au-dessus du code de base de NetBeans est un énorme défis, mais cela résulte en un NetBeans encore plus amélioré. Ces deux équipes ont des demandes spécifiques en terme de fonctionnalités que les utilisateurs décident et nous essayons de le leur fournir dans l'EDI de base. En même temps, nous incorporont souvent des suggestions, rustines, et même de nouvelles fonctionnalités provenant de ces équipes dans le code source de base. <hr> D'autres sujets couverts dans l'interview inclut: la logique derrière la version de NetBeans 3.6 avant le 4.0 planifié auparavant, ce qui est en cours de développement pour le NetBeans 4.0 (Refactoring, le nouveau système de Projet) et l'après 4.0. C'est un interview à ne pas manquer.  </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/interviews/steve_wilson_fr.html' target='new'>L'interview dans son intégralité</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='s184'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Java Studio Mobility Pack pour NetBeans</b></font><br>&nbsp;<br><a href="" onClick='window.open("/images_www/marketing_newsletter/102_big.jpg", "", "width=820, height=820, toolbar=no, location=no, directories=no, status=no")'><img src='/images_www/marketing_newsletter/102.jpg' widht='100' height='267' border='0' alt='Mobile - 10k' align='left' vspace='2' hspace='10'></a><font face='Verdana, sans-serif, helvetica, arial' >Le pack Java Studio Mobility modules est disponible pour l'EDI NetBeans. Le pack Java Studio Mobility est utilisé pour le développement d'applications qui peuvent être déployées pour des appareils mobiles intégrant la technologie Java. Avec des fonctionnalités optimisées pour les développement de MIDP (Mobile Information Device Profile) / CLDC (Connected Limited Device Configuration), les développeurs d'applications utilisant la technologie de la plateforme Java J2ME bénéficieront des capacités RAD lors du développement d'applications J2ME MIDP.  <p>Ces modules sont maintenant disponibles auprès du Centre de Mise à Jour Béta de l'EDI NetBeans 3.6, dans la section Free 3rd-Party modules / J2ME Wireless.</p>  <p><b><i>Please note:</b></i> Due to last minute changes the modules are now available and located on the NetBeans IDE 3.6 Auto Update Center in the J2ME Wireless folder.</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/releases/36/mobility_features.html' target='new'>Features and Benefiets</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='s183'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Une Modification au niveau du Centre de Mise à Jour</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >Une conversation sur la list de discussion aumasuters@netbeans.org a aboutit sur un nouveau concept qui est maintenant implémenté pour la version de NetBeans 3.6. Son but est de rehausser le niveau de qualité de NetBeans en améliorant la structure des Centres de Mise à Jour de NetBeans et la clarté du contenu.  <p>Le plan est d'avoir 5 types de centres de mises à jour qui devraient être distinct pour chaque release (c'est à dire que Développement pour 3.6 sera différent de Développement pour 4.0): <ul> <li>Développement: utilisé uniquement durant la phase de développement. Pas pour un usage utilisateur final. Sera utilisé pour les modules ne faisant pas partie de la distribution standard, mais qui sont mis à jour journalièrement.</li> <li>Béta: Dans les versions finales, pour les modules en qualité Béta. <li>Stable: utilisés pour les modules qui rencontrent les critères de stabilité pour une version donnée</li> <li>Third Party: utilisé pour les modules qui rencontrent les critères de stabilités pour une version donnée, fournit par des parties tierces (c'est-à-dire pas netbeans.org)</li> <li>HotFixes: Utilisé pour la délivrance de petites rustines qui rencontrent les critères de qualité pour la version donnée</li> </ul> Pour plus d'information quant à ces modification ou pour donner votre avis, veuillez regarder le <a href="https://netbeans.org/servlets/ReadMsg?msgId=722647listName=nbusers"> message original</a> envoyé sur nbusers.</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;</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='s185'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Mise à Jour sur les Activités concernant NetBeans 4.0</b></font><br>&nbsp;<br><a href="" onClick='window.open("/images_www/marketing_newsletter/98_big.png", "", "width=820, height=820, toolbar=no, location=no, directories=no, status=no")'><img src='/images_www/marketing_newsletter/98.png' widht='150' height='105' border='0' alt='Refactoring 4.0 - 14k' align='left' vspace='2' hspace='10'></a><font face='Verdana, sans-serif, helvetica, arial' ><b>Version Alpha Refactoring NetBeans 4.0</b> <p>Au cas où vous l'auriez manquée, une version alpha du refactoring pour NetBeans 4.0 est maintenant disponible sur NetBeans.org. Vous pouvez la télécharger et jouer avec les fonctionnalités comme Renommer Paquetage / Classe / Méthode / Champs, Modifier Paramètres de la méthode ou Encapsulation Champs.</p>  <p>Si vous désirez rejoindre la communauté de développeurs autout du refactoring, veuillez souscrire à la liste de développeur (dev@refactoring.netbeans.org) depuis <a href="https://netbeans.org/projects/refactoring/lists">la page de mailing list</a> du projet et envoyez vos commentaires concernant cette version alpha sur dev@refactoring.netbeans.org.</p>  <p> Pour plus d'information concernant le Refactoring dans NetBeans 4.0, y compris le téléchargement de la version Alpha, les fonctionnalités re Refactoring plannifiées et la Roadmap, veuillez visiter <ul><li><a href="http://refactoring.netbeans.org">http://refactoring.netbeans.org</a></li></ul>  <p><b>Nouveau Système de Projet basé sur Apache Ant</b></p>  <p>Un système de projet completement nouveau, basé sur Apache Ant, un outil de déploiement open-source, orienté Java, qui a fait ses preuves et qui est le standard de-facto. Ce nouveau système aura une architechture ouverte, que les modules tiers pourront étendre pour supporter les genres d'applications Java actuels et futurs. NetBeans incluera des types de projets pour les applications de bureau J2Se, et les applications web deux-tiers (JSPs, servlets, Tag Libs) en standard. Les utilisateurs ne devront pas avoir peur d'être bloqué dans des systèmes de projets propriétaires. <ul> <li><a href="http://translatedfiles.netbeans.org/projects/buildsys/projects_quickstart_fr.html">http://translatedfiles.netbeans.org/projects/</a></li></ul>  * L'intégration des fonctionnailtés de Refactoring avec le nouveau Système de Projets and la fusion dans le tronc est plannifiée pour la fin du mois d'avril. Il est également prévu de publier l'API de Refactoring, comme cela, vous pourrez écrire et contribuer vos propres fonctionnalités de Refactoring.</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/releases/40/nb40_features_fr.html' target='new'>NetBeans 4.0 Release Plan</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='s180'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Le Saviez-vous ?</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' ><b>Qu'il y a une nouvelle d'enregistrer un driver JDBC dans NB3.6 ?</b><br/> Maintenant, il est possible de charger le driver depuis n'importe quel endroit. Il n'est plus nécessaire de devoir le placer dans le répertoire <nb>/lib/ext. Vous devez juste enregistrer le driver dans l'EDI. Pour faire cela, cliquez-droit sur le noeud Drivers et sélectionnez l'action Add Driver. Spécifier les informations requises et votre driver apparaîtra sous le noeud drivers.  <p>Pour plus d'informations, voir l'aide concernant l'Explorateur de Base de Données dans l'EDI ou <a href="http://db.netbeans.org/uispecs/db_jdbc_driver_manager.html"> regarder ici</a>.  <p>Astuce fournie par: Radko . Najman @ Sun . com  <p><b>Que vous pouvez demander au débogueur de s'arrêter sur une exception ? </b><br/> Rendez-vous dans la fenêtre des points d'arrêts, cliquez-droit, sélectionnez New Breakpoint. Dans la liste déroulante située à droite, choisissez Exception, et modifier l'option située en bas pour thrown ou caught, et définissez votre classe d'exception. Si vous désirez toutes les exceptions, choisissez "Throwable".  <p>Astuce fournie par : Torbjorn . Norbye @ Sun . COM  <p><b>Qu'il y a une mailing list en Chinois, Français, Japonais et Russe?  <a href="https://netbeans.org/community/lists/top.html">Inscrivez-vous  ici!</a> </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;Vincent Brabant</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>