<HTML>
<HEAD>

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

<title>NetBeans Edge - Numéro 26 - Avril 2005</title>
<meta NAME="description" CONTENT="The NetBeans Edge monthly newsletter, Numéro 26, Avril 2005 /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 2005 02-May 12:28 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-40.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 gratuits et commerciaux 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://http://services.netbeans.org/downloads/download.php?a=bp=1' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'>EDI NetBeans 4.0</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='https://netbeans.org/community/releases/41/' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'>EDI NetBeans 4.1 Release Candidate</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> Version de NetBeans à venir<br></font> </td></tr><td><a href='http://developers.sun.com/prodtech/javatools/jsenterprise/index.html' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'>Sun Java Studio Enterprise</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=51964&listName=nbusers' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Debate: Why not make "Fix Imports" automatic</font></a></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><a href='https://netbeans.org/servlets/ReadMsg?msgId=52405&listName=nbusers' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>NetBeans hang</font></a></td>
              <td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>19</font></td>
              </tr><tr>
              <td><a href='https://netbeans.org/servlets/ReadMsg?msgId=51652&listName=nbusers' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Netbeans 5.0</font></a></td>
              <td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>16</font></td>
              </tr>
<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=29890&listName=nbdev' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Split of openide into smaller logical pieces</font></a></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>
<tr>
        <td colspan='2' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FF9542'>openide</font></td>
        </tr><tr>
              <td><a href='https://netbeans.org/servlets/ReadMsg?msgId=15459&listName=openide' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Detecting first run?</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>
	</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'>183</font></td>
				</tr><tr><td><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Chuck Davis</font></td>
				<td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>48</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'>45</font></td>
				</tr><tr><td><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Rich Unger</font></td>
				<td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>43</font></td>
				</tr><tr><td><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Chuck Williams</font></td>
				<td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>35</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: 2,200,466; +66,234</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: 90,187; +2,316</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: 0; +-194,921</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'>+1,217</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-26.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-26_nl.html'><img src='/images_www/flags/nl_small.gif' width='20' height='13' alt='Dutch Edition' border='0'></a>&nbsp;</td>  <td align='right'><font face='Verdana, sans-serif, helvetica, arial' ><b>Numéro 26</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='s222'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans Edge, Numéro 26</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' ><p>Le projet NetBeans.org est passé à la vitesse supérieure. Basé sur la 
version 4.0 qui rencontra un succès, la version Release Candidate de l'EDI
NetBeans 4.1 est maintenant disponible. La version finale devant être 
disponible pour la mi-mai. Téléchargez-là, testez-là et partagez votre
opinion avec le restant de la communauté de NetBeans sur les listes 
de discussion.

<p>Dans ce numéro, apprenez comment Libérer la Puissance de 
l'offre conjointe de l'EDI NetBeans 4.1
Release Candidate / Serveur d'Application Sun Java System +
Pack de Mobilité NetBeans 4.1 RC +
Profileur NetBeans Milestone 6 = Un couple d'enfer !

<p>J'aimerais tout d'abord saisir cette opportunité qui m'est offerte pour
partager d'autres nouvelles concernant le projet NetBeans.org. Il y a quelques
contributeurs qui ont fait des vagues.
<ul>
<li><a href="http://blogs.sun.com/roller/page/roumen/">Roman Strobl</a> a créé 
des entrées comme la Qualité de NetBeans en Chiffres, et des Conseils pour la 
Performance du Scanning Classpath.
<li><a href="http://blogs.sun.com/roller/page/geertjan/">Geertjan Wielenga</a>
est devenu célèbre avec ses articles Monitor HTTP Requests on JBoss 4 from 
NetBeans IDE 4.1 et NetBeans IDE 4.1, Ant et Demi Moore.
<li><a
href="http://weblogs.java.net/blog/vbrabant/archive/2005/04/wink_is_great_1.html">
Vincent Brabant</a> a fait une belle présentation sur comment donner plus 
d'espace de travail pour éditer botre code dans l'EDI NetBeans 4.1.

[NdT: les présentations sont également disponibles en français depuis 
<a href="http://fr.netbeans.org/edi/41/tutoriels/">le coin des francophones</a>
ainsi que sur <a href="http://brabant.developpez.com">ma page personelle</a>.]

Et <a href="http://cld.blog-city.com/">Charles Ditzel</a> continue de 
propulser NetBeans dans la lumière grâce à son blog avec de nombreuses
entrées NetBeans et la très intéressant <a
href="http://files.blog-city.com/files/aa/1263/b/NetBeansWorking.html">NetBeans
Quick Links page</a>.</li></ul>

<p>Il y a d'autres contributions qui valent la peine d'être mentionnées et 
d'y passer du temps:

<ul>
<li><a
href="https://netbeans.org/kb/articles/ebay-sdk-api-calls-demo.html">Launcer
L'Application de démo eBay Java SDK API depuis l'EDI NetBeans 4.0</a> de
Brian Leonard.
<li><a href="https://netbeans.org/kb/archive/index.html">Générer et Exécuter le
Projet Looking Glass avec NetBeans</a> de Charlie Hunt</li></ul>

Et pour terminer, voici le nom des personnes qui ont eu leur
articles publié dans le cadre du concours <a
href="https://netbeans.org/competition/win-with-netbeans.html">Gagnez Avec NetBeans</a>: 
Rich Unger, Ben Suter, Jason Stapley, Randahl Fink Isaksen,
Raguraman Krishnamurthy, Vincent Brabant, Gregg Sporar, Miki Shimizu, Tommi
Laukkanen, Zsolt Kiss, Travis Romney, Ryoji Sawa, Arthur Cheng et
Jean-Baptiste Renaux. Félicitations!

<p>Vos commentaires, remarques et suggestions sont toujours appréciés et nous
sommes toujours à l'écoute. Envoyez votre feedback, commentaires ou nouvelles
<a href="mailto:nbmarketing@netbeans.org">ici</a>.


<p><b>Le coin des francophones:</b>
<p>Il y a beaucoup de choses qui se sont faites ces dernieres semaines.
<ul>
<li>Tout d'abord, vous pouvez trouver les <a
href="http://fr.netbeans.org/edi/articles/concours/">
traductions en français de la plupart
des articles du concours Win a iPod</a></li>
<li>Ensuite, vous pouvez télécharger 
<a href="https://netbeans.org/projects/fr/downloads?folderID=29"
la traduction des brouillons du nouveau livre concernant l'EDI NetBeans.
(Plus que 3 chapitres à traduire)
</a></li>
<li>Il existe une <a href="http://wiki.java.net/bin/view/Netbeans/Communaut%E9Francophone">
nouvelle page dans le wiki pour les francophones</a>
</li>
<li>En exclusivité pour la communauté francophone de NetBeans,
<a href="http://fr.netbeans.org/edi/41/tutoriels/">
deux petites démos flash, vous montrant en action des trucs et astuces
avec l'EDI NetBeans 4.1</a>. D'autres devraient suivre. Et je donnerai toujours 
la primeure à la communauté francophone.
</li>
<li>Et pour terminer, Sun Belux organise un événement spécial pour la sortie 
de l'EDI NetBeans 4.1 le 25 et 26 Mai 2005. Voici la 
page d'inscription.
Vous aurez la possibilité de gagner un voyage aller-retour Bxl-San Francisco, 
avec l'entrée à JavaOne. 
</li>
</ul>

<p>Si vous avez un blog en français, faites-le nous savoir !!.
On en fera mention dans le prochain numéro.</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='s233'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans<sup><small>TM</small></sup> Software Day at 2005 JavaOne</b></font><br>&nbsp;<br><img src='/images_www/marketing_newsletter/109.png' widht='125' height='125' border='0' alt='NetBeans Day 05 - 23k' align='left' vspace='2' hspace='10'><font face='Verdana, sans-serif, helvetica, arial' >Le dimanche, 26 Juin, après-midi, le jour avant la Conférence JavaOne 2005, 
l'équipe de NetBeans tiendra un événement GRATUIT à l'hôtel Argent
près du Centre Moscone. Vous y apprendrez ce qui se trame avec l'EDI
NetBeans<sup><small>TM</small></sup> et les autres outils de Sun.
James Gosling, le père de Java<sup><small>TM</small></sup>,  
va discuter du future des outils de développement Java. Les avancées
dans les technologies des outils vont avoir un impact dramatique
sur les développeurs concevant des solutions avec la technologie
Java J2SE<sup><small>TM</small></sup>, 
J2EE<sup><small>TM</small></sup> et J2ME<sup><small>TM</small></sup>.
Ces nouvelles technologies vont accroitre la productivité des 
développeurs, ainsi que la qualité et la performance de 
l'application. 

Il y aura également des interventions de leaders logiciels de Sun:

<p><table>
<tr>
	<td>Sun Fellow</td>
	<td>Graham Hamilton</td>
</tr>
<tr>
	<td>Sun Distinguished Engineer</td>
	<td>Bill Shannon</td>
</tr>
<tr>
	<td>Sun Distinguished Engineer</td>
	<td>Bob Brewin</td>
</tr>
<tr>
	<td>Sun Distinguished Engineer</td>
	<td>Tim Lindholm</td>
</tr>
<tr>
	<td>Director of Web Technologies</td>
	<td>Tim Bray</td>
</tr>

</table>
<p>Peut-être y aura-t-il d'autres invités spéciaux.  

<p>Tous les participants recevront une copie du Livre 
Guide Pratique EDI NetBeans, qui sera juste sorti des presses.

<p>
Pour plus d'information sur l'Agenda, les biographies des orateurs
et l'enregistrement en ligne, cliquez sur le lien ci-dessous.</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/javaone/2005/nb-day.html' target='new'>NetBeans Software Day Home</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='s231'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>EDI NetBeans 4.1 Release Candidate</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >Découvrez la dernière version de l'EDI NetBeans 4.1 à venir.

<p>Choisissez entre l'EDI NetBeans 4.1 RC seul et l'offre conjointe
avec le Serveur d'Application Sun Java System PE 8.1.
Sélectionnez quel téléchargement vous désirez sur le second écran
après avoir cliqué sur le lien ci-dessous.

<ul><li><a
href="http://services.netbeans.org/downloads/download.php?type=4.1rc1">
Téléchargement EDI NetBeans 4.1 Release Candidate</a>
</ul>

Le travail effectué sur la Release Candidate 4.1 consiste principalement 
sur la stabilisation du noyau et sur la performance.
 Nous vous demandons de nous aider à tester la version et à nous faire 
 parvenir votre feedback. Nous approchons de la version finale qui est 
 planifiée pour la mi-mai.

<p>Pour plus d'information sur l'EDI NetBeans 4.1, 
veuillez visiter:
<ul><li><a
href="https://netbeans.org/community/releases/41/relnotes.html">
Les Notes de Release</a>
<li><a href="https://netbeans.org/kb/archive/index.html">
Support Documentation 4.1</a></li></ul>

Merci. Nous attendons vos commentaires.
</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/41/index.html' target='new'>plus d'infos</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='s226'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Pack Mobilité NetBeans 4.1 Release Candidate</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >Le pack de Mobilité release candidate est maintenant disponible
sur NetBeans.org.

<ul><li><a
href="http://services.netbeans.org/downloads/download.php?type=4.1rc1">Venez le 
télécharger</a></li></ul>

<b>Un Aperçu des Nouvelles Fonctionnalités :</b>

<ul><li><b>Visual Design Editor</b> - Gérer visuellement
le workflow de votre MIDlet (ou préférez-vous mobilette),
et concevez et coder le GUI 
en manipulant les éléments à la souris.

<li><b>Support End-to-end Pour les Applications Enterprise</b> - Assistant 
pour la créations d'applications J2ME-J2EE. Vous permet de créer rapidement
des applications client J2ME/server.

<li><b>Support configuration amélioré</b> - Capabilités définies par
l'Utilisateur, permettant une plus grande flexibilité lors de la création
de blocs de code. Aussi, vous pouvez maintenant utiliser des modèles de projets
pour créer une configuration une fois pour toute et l'utiliser dans de multiples
projets.

<li><b>Configuration Améliorée Obfuscation </b> - Maintenant, vous
avez un plus grand contrôle sur vos paramètres d'obfuscation.

<li><b>Support Attributs Utilisateur Améliorés</b> - Crée des attributs 
personnalisés et choisis leur emplacement, soit dans votre fichier JAD, soit 
dans le fichier manifest JAR, ou dans les deux.</li>

</ul>

<b>Resources:</b>
<ul><li><a href="https://netbeans.org/kb/archive/index.html">J2ME MIDP
Development for NetBeans IDE 4.1</a> (Inclus des fonctionnalités de haut niveau)
<li><a href="https://netbeans.org/kb/archive/index.html">Guide Démarrage 
Rapide pour les développeurs J2ME</a>
<li><a href="http://blogs.sun.com/roller/resources/lukas/me-screenshot-rc1.png"
Target="_blank">copie d'écrans</a>
</li></ul>
Vous devez avoir l'EDI NetBeans 4.1 et le Pack de Mobilité NetBeans 4.1 installé
avant de pouvoir démarrer le développement J2ME MIDP. Voyez la page de développement
J2ME MIDP ci-dessus pour des instructions quant au téléchargement et l'installation
de l'environnement complet.

<p>Pour des informations concernant le <b>Pack de Mobilité NetBeans 4.0</b>, 
veullez <a
href="https://netbeans.org/kb/articles/mobility.html">continuer 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;</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='s223'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Profileur NetBeans Milestone 6 est Disponible</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >Le Profileur NetBeans est un projet pour intégrer la technologie de profiling 
JFluid, issue de Sun Labs, dans l'EDI NetBeans. Le but de ce projet est de 
fournir une solution de profiling puissante et flexible, qui est étroitement
intégrée à l'EDI. La dernière version du Profileur NetBeans (Milestone 6) 
travaille avec l'EDI NetBeans 4.0 et 4.1.

<p>Visitez <a
href="http://profiler.netbeans.org">http://profiler.netbeans.org</a> pour 
télécharger la dernière version ou pour plus d'informations.

<p><b>Fonctionnalités Clefs dans Milestone 6:</b>
<ul><li>Support pour JDK 1.4.2 et JDK 6.0 (Mustang) (plus à ce sujet dans Quoi de Neuf)
<li>Intégration étroite dans l'EDI
<li>Profiling à basse overhead, utilisant la technologie JFluid
<li>approche basée sur des Tâches pour simplifier le profiling
<li>Profiling performance Processeur
<li>Profiling Mémoire. Détection memory leak
<li>Attachement à une application qui s'exécute (déployée)
<li>Profiling Threads</li>
</ul>

<b>Quoi de neuf dans la version Milestone 6:</b><ul>

<li>Support pour les JDK Tiger (5.0) et Mustang (6.0) - le profileur 
supporte le profiling des pré-versions actuelles de Mustang (les pré-versions
de Mustang peuvent être téléchargées depuis <a
href="https://mustang.dev.java.net">https://mustang.dev.java.net</a>). Le 
JDK 5.0 sera supporté à partir de la version 5.0_04 (plannifié pour 
sortir à la fin Juin)
<li>Nouveau Panneau de Contrôle du Profileur
<li>Performance Significative Amélioration de la réponse de l'Interface
Utilisateur, y compris un overhead encore plus petit du profileur dans le mode
Monitoring

<li>Nouveau installeur, simplifiant le processus d'installation

<li>(Comme toujours) Un grand nombre de bugfixes</li></ul>

La liste complete des nouvelles fonctionnalités,
améliorations et rustines, peuvent être trouvés
ici.

D'autres nouvelles:
<ul><li>Si vous l'avez raté, il y avait un interview très informative et
très intéressante; <a
href="http://java.sun.com/developer/technicalArticles/Interviews/Dmitriev_qa.html">
Better Profiling through Code Hotswapping: A Conversation with JFluid Project Lead,
Misha Dmitriev</a>
<li>Une version mise à jour de <a
href="https://netbeans.org/kb/articles/nb-profiler-tutor-6.html">
NetBeans IDE 4.0 Profiler Tutorial</a> est maintenant disponible
pour la version Milestone 6.</li></ul>

L'équipe de profiling développe également des outils liés au profiling.
Le premier outil disponible est une intégration de Visual GC dans l'EDI NetBeans.
Pour plus de détails, voir la <a href="http://profiler.netbeans.org/visualgc/index.html">
Page d'accueil Module Intégration Visual GC</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><font face='Verdana, sans-serif, helvetica, arial' >[<a href='http://profiler.netbeans.org' target='new'>plus d'information et téléchargement</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='s234'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Projet Coyote</b></font><br>&nbsp;<br><img src='/images_www/marketing_newsletter/110.jpg' widht='100' height='125' border='0' alt='Coyote - 18k' align='left' vspace='2' hspace='10'><font face='Verdana, sans-serif, helvetica, arial' >Le but de cet projet est de développer un ensemble de modules NetBeans pour aider
les développeurs à écrire du code dans les languages dynamiques en utilisant l'EDI
NetBeans. Initiallement, ils se sont focalisés sur les langages
<a href="http://groovy.codehaus.org">Groovy</a> et <a
href="http://www.jython.org">Jython</a>, mais nous anticipons
avec un framework commun, permettant le support d'autres langages.</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://coyote.dev.java.net/' target='new'>Apprendre plus</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='s225'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans Switch</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >De plus en plus de développeurs sont intéressés par l'EDI NetBeans et tirer 
profit de toutes les fonctionnalités disponibles directement à l'installation.
C'est pourquoi nous, la communauté NetBeans, avons lancé le site "Switch". 
Lisez les histoires des développeurs et apprenez pourquoi ils sont passés à l'EDI
NetBeans. Apprenez comment l'EDI NetBeans augmente la productivité du développeur
et combien il est facile de franchir le pas. Une partie du programme "Switch to NetBeans"
offre le Module d'Importation de Projet d'Eclipse pour une transition simple et sans
douleur de projets basés sur Eclipse dans l'EDI NetBeans.

<p>Faites passer le mot et convertissez vos amis et collègues en 
leur montrant ce que le nouveau NetBeans a à offrir! Tant que vous y êtes, 
venez prendre quelques uns des nouveaux <a
href="https://netbeans.org/community/teams/marketing/collateral.html">
Graphismes NetBeans</a> et postez les sur le Net ou 
dans la signature de votre mail.</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://fr.netbeans.org/edi/migrer/index.html' target='new'>Basculer vers 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='s235'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans a besoin de vous - Veuillez voter!</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >Le Java Developer's Journal, LinuxWorld Magazine, et le 
Web Services Journal tiennent leur annuel 
Readers' Choice awards.  NetBeans a été nominé dans les 
trois! <p>Veuillez prendre quelques minutes 
et votez pour votre EDI favori. La période de vote se cloture le 31 Juillet.

<p>Vous pouvez voter pour NetBeans dans l'une des catégories suivantes du JDJ:
<ul><li><b>Best Java Debugging Tool</b> (Page 8) - NetBeans 
<li><b>Best Java IDE Environment</b> (Page 9) - NetBeans/Java Studio
Enterprise</li></ul>

[<a href="http://jdj.sys-con.com/general/readerschoice.htm">JDJ Readers' Choice
Awards Voting</a>]

<p>Vous pouvez voter pour NetBeans dans l'une des catégories suivantes du LinuxWorld Magazine:
<ul><li><b>Best Linux Developer Tool</b> (Page 3) - NetBeans/Java Studio
Enterprise
<li><b>Best Linux Programming Environment</b> (Page 10) - NetBeans/Java Studio
Enterprise</li></ul>

[<a href="http://linux.sys-con.com/general/readerschoice.htm">LinuxWorld
Magazine Readers' Choice Awards Voting</a>]

<p>Vous pouvez également voter pour NetBeans dans la catégorie suivante du Web Services Journal:
<ul><li><b>Best Web Services IDE</b> (Page 12) - NetBeans/Java Studio
Enterprise</li></ul>

[<a href="http://webservices.sys-con.com/general/readerschoice.htm">Web
Services Journal Readers' Choice Awards Voting</a>]</p>


[Note du Traducteur: Vous pouvez également voter pour NetBeans sur le site de 
<a href="http://www.developpez.net/forums/viewtopic.php?t=321412">Développez.com
</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='s228'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Catalogue de Module</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' >Il y a plusieurs plugins disponibles 
pour l'EDI NetBeans 4.0.
Dans cette partie, nous mettons en évidence quelques uns d'entre eux.

<p><a href="http://www.insitechinc.com/">XTT v5.0 - Smart Web Clients for
Java</a> - XTT - Smart Web Clients for Java est un framework
de développement RAD, basé sur Java, pour concevoir et distribuer des 
applications web basées sur Swing. Vous pouvez également regarder le belle <a
href="http://www.insitechinc.com/demo.php3">démo de InsiTech</a>.

<p><a href="http://www.refactorit.com/?id=5327">RefactorIT 2.5 Update 7</a> -
Aqris Software a sorti la version 2.5 Update 7 de RefactorIT. 2.5 Update 7
s'intègre sans problème avec la version 
4.0+ de NetBeans et il supporte les répertoires sous contrôle de CVS pour toutes ses
transformations. RefactorIT supporte pleinement J2SE 5.0 et 
vient avec de nombreuses améliorations sur le célèbre analyseur graphique
de dépendance. 

<p><a href="http://www.visual-paradigm.com/sdenb.php">SDE 2.1</a> - SDE 2.1 pour 
NetBeans fournit un support complet UML 2.1 pour votre NetBeans.
Vous pouvez modeliser votre application avec les dernières notations et diagrammes
UML. L'Environnement de modélisation Visual Paradigm s'intègre sans problème
avec NetBeans; De ce fait, vous pouvez effectuer vos analyses, conceptions, 
implémentations et déploiement dans une seule plateforme. Votre code et 
documentation est toujours synchronisée. Vous pouvez discuter à propos de votre
design avec vos collègues en sketching les diagrammes UML
dans l'EDI NetBeans.

<p><a
href="http://sourceforge.net/project/showfiles.php?group_id=56262package_id=63621">PMD
Plugin</a> - Une nouvelle version du Plugin PMD qui fonctionne avec l'EDI NetBeans 
4.0 et livrée avec la dernière version de l'outils PMD est maintenant 
disponible. PMD est un outils qui parcourt le code source Java et qui regarde
après des problèmes potentiels. Le plugin permet son exécution depuis l'EDI
et rajoute des hyperliens avec le résultat produit.

<p><a href="http://mevenide.codehaus.org/mevenide-netbeans-project/">Mevenide
0.6</a> - Le but du projet est de fournir le support de type de projet Maven 
pour l'EDI NetBeans 4.0. Les fonctionnalités incluent la reconnaissance des projets 
Maven, la configuration du projet dans l'EDI, l'exécution de Maven, le support
de l'éditeur pour les fichiers de configurations, ...
Les modifications dans cette version inclut:
<ul><li>Ajout navigation repository local et distant. Permet le téléchargement
d'artifcats depuis le repository distant.
<li>Ajout édition des dépendances dans 
la configuration visuelle du projet.
<li>Lie le rapport de findbugs avec l'éditeur de l'EDI. Ajoute des annotations 
dans l'éditeur.</li></ul>

<a href="http://www.appperfect.com/index.html">AppPerfect</a> a mis à jour
3 offres NetBeans: AppPerfect JVM Profiler, AppPerfect Unit Tester et 
AppPerfect Code Analyzer. 
</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'></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>