<HTML>
<HEAD>

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

<title>NetBeans Edge - Numéro 25 - Octobre 2004</title>
<meta NAME="description" CONTENT="The NetBeans Edge monthly newsletter, Numéro 25, Octobre 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 19-Nov 14:56 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'>Module Catalogue</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> Catalogue de modules commerciaux et gratuits 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'> Centre Communautaire Java dont NetBeans est un membre fédéré<br></font> </td></tr><td><a href='http://services.netbeans.org/downloads/download.php?a=b&amp;p=1' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'>NetBeans IDE 3.6</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> Disponible en Téléchargement<br></font> </td></tr><td><a href='https://netbeans.org/community/releases/40/index.html' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'>Nouveau! EDI NetBeans 4.0 Béta</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> La release suivante<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'>openide</font></td>
        </tr><tr>
              <td><a href='https://netbeans.org/servlets/ReadMsg?msgId=835872&listName=openide' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>3.5.1 to 4.0</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 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=850096&listName=nbusers' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Re: [TECHNOLOGY] - JAVA + NetBeans + ??? = easy & scalable production!</font></a></td>
              <td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>23</font></td>
              </tr><tr>
              <td><a href='https://netbeans.org/servlets/ReadMsg?msgId=843332&listName=nbusers' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Re: Is NB4.0 really ready for J2SE 5 ?</font></a></td>
              <td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>21</font></td>
              </tr><tr>
              <td><a href='https://netbeans.org/servlets/ReadMsg?msgId=849314&listName=nbusers' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Re: Mainclass attribute in Jar-manifest</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=849416&listName=nbusers' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>List cvs modules</font></a></td>
              <td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>18</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'>95</font></td>
				</tr><tr><td><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Tim Boudreau</font></td>
				<td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>92</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'>69</font></td>
				</tr><tr><td><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Peter Nabbefeld</font></td>
				<td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>44</font></td>
				</tr><tr><td><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Ilias Lazaridis</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>		</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: Octobre</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,722,087; +51,409</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: 71,314; +3,287</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: 124,680; +12,604</font></td>
</tr>
<tr>
<td colspan='2' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FF9542'>Messages postés</font></td>
</tr>
<tr>
<td colspan='2' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>+3,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-25.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-25_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-25_ru.html'><img src='/images_www/flags/ru_small.gif' width='20' height='13' alt='Russian Edition' border='0'></a>&nbsp;</td>  <td align='right'><font face='Verdana, sans-serif, helvetica, arial' ><b>Numéro 25</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='s208'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans Edge, Numéro 25</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >Bienvenue au numéro 25 de NetBeans Edge!

<p>La grande nouvelle du mois d'août fut l'annonce de la disponibilité de l'EDI 
NetBeans 4.0 Béta et de la Plateforme NetBeans 4.0 Béta!

<p>Prenez l'opportunité de télécharger et de tester la dernière version de
l'EDI NetBeans 4.0 qui est en train de gagner les critiques, convainquant des 
développeurs du monde entier et qui déchaîne la communauté NetBeans. Pour
emprunter une citation de James Goslings, 
"<i><a href="http://blogs.sun.com/jag/">NetBeans 4.0 Rocks!</a></i>"

<p>Le nouveau programme NetBeans 4.0 NetCAT (<a
href="http://qa.netbeans.org/processes/cat/40/index.html">what is NetCAT?</a>)
est en cours. Durant les premiers 48 heures de l'appel aux participants, plus de 
260 réponses valides nous sont parvenues. Les anticipations de l'EDI 
NetBeans 4.0 est terribles!

<p>Prenez une tasse de café, asseyez-vous et lisez plus à propos de NetBeans 4.0
Béta 1 et ce que cela signifie pour vous. N'oubliez-pas que la liste de distribution 
nbdiscuss_fr@netbeans.org est là pour que vous puissez poser vos questions et 
fournir des astuces.
<a href="https://netbeans.org/community/lists/top.html">Souscrivez ou 
consulter les archives</a>. Vous pouvez également aider à la promotion de la 
dernière version en plaçant un <a
href="https://netbeans.org/community/teams/marketing/movetheneedle.html">
graphique NetBeans</a> sur votre page web ou le <a
href="https://netbeans.org/community/teams/marketing/collateral.html">logo officiel de 
NetBeans </a>.

<p><a href="mailto:nbmarketing@netbeans.org">
Vos commentaires et pensées sont toujours appréciés.</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;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='s209'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>EDI NetBeans 4.0 Béta 1</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >Nous sommes heureux de vous annoncer la disponibilité immédiate de l'EDI et 
la plateforme NetBeans 4.0 Béta 1.

<a href="https://netbeans.org/downloads/index.html">Téléchargez-les</a>

<p><b>Fonctionnalités Principales:</b>
<ul>
<li><b>Support Tigre (J2SE 5.0) </b> - Support des fonctionnalités du langage
de la Plateforme Java 2, Edition Standard .0
<li><b>Système de Projet basé sur Ant</b> - Un nouveau système de projet basé 
sur le projet Open Source Apache Ant 
<li><b>Support J2ME MIDP</b> Support développement Plateforme Java 2, 
Édition Micro (J2ME) Mobile Information Device Profile (MIDP)
<li>Java refactoring - incluant: renommer (classe/méthode/champs), 
déplacer classe, renommer paquetage, modifier les paramètres de la méthode, 
encapsuler le champs et trouver les références
<li><b>Support accru de J2EE</b> - Support Développement Plateforme Java 2, 
Édition Entreprise (J2EE) pour l'EDI NetBeans 4.x 
(Early Access disponible en October)
<li>Performance Profiler (bientôt disponible)</li></ul>

L'Early Access initial du Performance Profiler est disponible MAINTENANT 
en tant que module séparé pour l'EDI NetBeans 3.6. La version béta sera 
disponible en tant que téléchargement additionnel pour la version production
de l'EDI NetBeans 4.0 en Décembre. <a href="http://profiler.netbeans.org/">Plus 
d'information</a>.

<p>Le planning de l'EDI NetBeans 4.0 :
<ul>
<li>Fin Septembre - Version 4.0 Béta 2 basé sur le feedback de la Béta 1
<li>Fin Octobre   - Mode Haute Résistance
<li>Mi-Novembre   - Test de la Release Candidate
<li>Fin Novembre  - Lancement Enquête Customer Acceptance
<li>Mi-Décembre   - Version Finale
<li>Mi-Décembre   - Module Support J2EE 
</li></ul>
</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/index.html' target='new'>détails complets 4.0</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='s210'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Liste Documentation pour l'EDI NetBeans 4.0 Béta</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' ><b>Guides Rapides</b>

<p><a href="https://netbeans.org/kb/archive/index.html">Guide 
de Démarrage Rapide EDI NetBeans 4.0</a> - Vous donne un aperçu rapide 
de l'EDI en vous guidant durant la création d'une simple application. Ce 
document prends moins de 20 minutes.

<p>Guide 
Rapide EDI NetBeans 4.0 Béta pour les Applications Web - Vous explique 
les bases de l'utilisation de l'EDI NetBeans pour créer un simple module web.

<p>
Guide Rapide de Développement J2ME MIDP pour l'EDI NetBeans 4.0  - 
Vous explique les bases de l'utilisation de l'EDI NetBeans 4.0 pour créer une 
application pour la Plateforme Java 2 Édition Micro (plateforme J2ME)
Micro Edition  (J2ME platform), Mobile Information Device Profile (MIDP). 

<p><b>Guides d'Import et de Migration</b>

<p>
Importer des Codes Sources Java Existants dans l'EDI NetBeans 4.0 Béta - 
Explique comment vous pouvez importer des applications de bureau existantes 
dans l'EDI NetBeans 4.0.

<p>
Importer des Applications Web Existantes dans l'EDI NetBeans 4.0 Béta - 
Explique comment vous pouvez importer des modules web existants dans l'EDI 
NetBeans 4.0.

<p><a
href="https://netbeans.org/kb/archiveindex.html">Import
de Code Source J2ME MIDP Existant dans l'EDI NetBeans 4.0 Béta</a> - Explique 
comment vous pouvez importer des codes sources de la plateforme J2ME dans 
l'EDI NetBeans 4.0 Béta.

<p>Passer de 
l'EDI NetBeans 3.6 vers la Béta 4.0 - Vous aide pour la transition de 
vos applications et de la configuration de l'EDI depuis l'EDI NetBeans 3.6 vers 
l'EDI NetBeans 4.0 Béta.

<p><b>Tutoriels et Autres Articles</b>

<p>
Configuration Avancée du Projet Libre - vous montre comment configurer 
un projet libre pour intégrer completement votre EDI avec le processus de 
construction de votre entreprise.
S'y trouvent des informations sur la façon de lier une *target* de Ant avec les 
commandes de l'EDI et sur la façon d'écrire les targets nécéssaires pour 
déboguer votre application.

<p><a
href="https://netbeans.org/kb/archiveindex.html">
Tutoriel Pile ou Face pour l'EDI NetBeans 4.0 Beta </a> - 
Explique comment concevoir une application web qui stoque des données en utilisant 
un composant JavaBeans, traite les données en utilisant une servlette, et affiche 
les données en utilisant la technologie JavaServer Pages. Ce tutoriel peut être 
terminé en 30 minutes.

<p><a
href="https://netbeans.org/kb/archiveindex.html">Tutoriel 
Compagnie de Minuit pour l'EDI NetBeans 4.0 Beta </a> - Montre comment utiliser 
l'EDI NetBeans pour construire, déployer et exécuter une application web 
qui contient des pages JSP et des servlettes et qui utilisent des tags de la 
bibliothèque de tag JSTL. Vous montré également comment utiliser le moniteur 
HTTP pour voir les requêtes et réponses entre le serveur et le browser web.</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/archiveindex.html
' target='new'>La liste en ligne</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='s211'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans Devient Groovy</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >Depuis le 1er Septembre, la version CVS du module supporte le scripting utilisant 
le langage <a
href="http://groovy.codehaus.org/" Target="_Blank">groovy</a>. Il vous suffit de 
rapatrier le module de scripting de CVS: 
cvs -d :pserver:anoncvs@cvs.netbeans.org:/cvs co scripting standard et d'invoquer 
ant -f scripting/build.xml all-scripting pour générer les quelques fichiers 
nbm dans des sous-répertoires, et vous pouvez les installer dans les versions 
Béta ou développement de l'EDI NetBeans 4.0.</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' >[site web du module de scripting]</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='s212'></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' ><b><a href="http://plugins.netbeans.org/">MagicDraw UML
8.0</a></b> - Le nouvel MagicDraw UML 8.0 présente une image visuelle des
applications existantes via ses nouvelles fonctionnalités: 
Reverse Engineering du code Java en diagramme de séquence. MagicDraw UML 8.0 
importe également un modèle UML depuis n'import quelle source _ un import XMI 
ou une opération de reverse engineering_ et l'affiche visuellement.
Un nouveau moteur de layout de diagramme sophistiqué avec sept options de layout 
permet de garder automatiquement la cohérence des diagrammes générés pour un 
look & feel professionel.

<p><b><a
href="http://plugins.netbeans.org/">turbosql</a></b> -
Toujours basculer de la console à l'EDI peut être vite ennuyant lorsqu'on 
développe du logiciel. En utilisant turbosql, vous pouvez contrôler Postgresql 
depuis NetBeans rapidement et visuellement, en ensuite améliorer la productivité
du développeur. Les fonctionnalités de création, modification, suppression et 
navigation des bases de données et tables.</font></td>
      <td><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'><td colspan='4'>&nbsp;</td></tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <td><font face='Verdana, sans-serif, helvetica, arial' >[<a href='https://netbeans.org/catalogue' target='new'>catalogue de modules</a>]</font>&nbsp;</td>
      <td align='right'><font face='Verdana, sans-serif, helvetica, arial' >&nbsp;</font></td>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <TD  colspan='2' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <TD  aligm='right' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      </table><img src='/images_www/pixel.gif' width='1' height='4' bolder='0'><table border='0' cellpadding='0' cellspacing='0' width='98%'>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='TOP' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'>&nbsp;</td>
      <TD  VALIGN='TOP' class='tabler' align='right' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <td class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      <td colspan='2'><a name='s213'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Dans la Presse</b></font><br>&nbsp;<br><img src='/images_www/marketing_newsletter/3.jpg' widht='100' height='106' border='0' alt='Press - 2k' align='left' vspace='2' hspace='10'><font face='Verdana, sans-serif, helvetica, arial' >Nouvelles :

<p>Sortie 
de la version Béta 1 de l'EDI NetBeans 4.0 - NetBeans.org
<br/>L'EDI NetBeans 4.0 Béta exhibe quelques mise à jour importantes, y compris:
support pour Tiger (J2SE 5.0), un système de projet totalement réécrit
se basant sur Ant, et le refactoring Java.

<p><a
href="http://java.sun.com/developer/technicalArticles/JavaLP/netbeans40/">EDI 
NetBeans: Quoi de Neuf dans l'EDI NetBeans 4.0</a> - java.sun.com - 
Pour aider à déterminer si l'EDI NetBeans est fait pour vous, cet article fournit 
un aperçu de l'EDI NetBeans, renforçant les nouvelles fonctionnalités introduites 
dans l'EDI NetBeans 3.6, et les fonctionnalités à venir de l'EDI Netbeans 4.0. 
Cet article fournit également une comparaison entre l'EDI NetBeans et Eclipse.

<p><a
href="http://www.builderau.com.au/program/work/0,39024650,39130644,00.htm">
Développeurs Java reçoivent une avant-première de NetBeans </a> - Builder.AU - 
La version Béta de l'EDI NetBeans 4.0 montre où le développement cross-plateforme 
se situe.

<p>Autres Blogs :

<p><a href="http://weblogs.java.net/blog/campbell/archive/2004/09/netbeans_40_per.html">NetBeans 4.0: Suffisamment 
parfait pour le Paresseux et celui qui en redemande.</a>

<p><a
href="http://nwc.linuxpipeline.com/showArticle.jhtml?articleID=32100001">NetBeans
Livre Une Version Béta de 4.0</a> 

<p><a href="http://www.infoworld.com/article/04/08/26/HNide_1.html">Béta de 
l'EDI NetBeans disponible, s'attaque aux spécifications Java</a> 

<p>NetBeans 4.0 beta1
semble en effet prometteur

<p><a
href="http://blogs.sun.com/roller/page/swinger/20040903#netbeans_4_0_beta_is">NetBeans
 4.0 Beta est Cool!</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='https://netbeans.org/about/press/index.html' target='new'>archives de presse</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'></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>
