<HTML>
<HEAD>

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

<title>NetBeans Edge - Numéro 22 - Avril 2004</title>
<meta NAME="description" CONTENT="The NetBeans Edge monthly newsletter, Numéro 22, 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 19-May 17:00 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 Modules</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> Catalogue de modules libres et commerciaux 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 membre fédéré<br></font> </td></tr><td><a href='http://services.netbeans.org/downloads/download.php?a=b&amp;p=1' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'>Nouveau! EDI NetBeans 3.6</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> Disponible en téléchargement<br></font> </td></tr><td><a href='http://developers.sun.com/prodtech/javatools/jsstandard/index.html' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'>Sun Java Studio Portal</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-22.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-22_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-22_pt.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-22_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 22</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='s186'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans Edge, Numéro 22</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >Participez !
<br/>
Par Steve Wilson, Directeur Engénieur, Sun Microsystems
<p>
La communauté NetBeans croit de façon exponentielle.
Durant les 6 derniers mois, le nombre de personnes inscrites
à nos listes de diffusion sont passées de 5.000 à 40.000!
Vu le grand nombre de nouveaux venus dans la communauté, j'ai pensé qu'il était
temps de parler de tous les moyens que vous avez pour mieux vous impliquer dans
ce qui se passe actuellement.
Il y a plusieures façons de participer aujourd'hui, et nous travaillons sur
d'autres options, quelque soit le temps que vous êtes prêts à investir.
<p>
Utilisez l'EDI et Faites-Le Savoir!
Notre but est d'avoir autant d'utilisateurs que possibles qui utilisent la
technologie produite à NetBeans.org. La façon la plus simple de faire partie
de la communauté est de faire savoir aux personnes que vous aimez la
technologie.
<p>
Parlons du Futut!
La plupart des personnes inscrites à nos listes de distribution sont inscrites
à la liste "announce" -- qui permet de ne communiquer que d'en un sens. De nous
vers vous. Cependant, il y a de nombreuses autres listes où les utilisateurs et
développeurs peuvent débattre sur de nombreux sujets.
Pour une liste des listes les plus intéressantes, vous pouvez vous rendre ici:
<p>
<a
href="https://netbeans.org/community/lists/top.html">https://netbeans.org/community/lists/top.html</a>
<p>
La liste "nbdiscuss" est une grande place où vous pouvez faire entendre votre
voix sur des sujets que vous aimeriez voir débattu avec la communauté.
Les discussions sur "nbusers" and "nbdev" ont provoqué récemment un énorme
impact sur la conception des fonctionnalités de NetBeans 4.0, comme le nouveau
système de projet. Faites entendre votre voix.
<p>
Plongez dedans!<br>
Si vous utilisez NetBeans, c'est que vous êtes un développeur Java.
L'EDI est conçu pour être modulaire, ce qui permet aux personnes d'ajouter
des caractéristiques et fonctionnalités sans devoir toucher au coeur de l'EDI.
Récemment, l'équipe développant le support d'Applications Web demanda de l'aide
pour implémenter une fonctionnalité pour tester la compilation des pages JSP.
Le développeur Illya Kysil a accepté de s'y lancé et a produit une première
version de ce module que les utilisateurs peuvent essayer. Merci Illya !
<p>
Et Ensuite?<br/>
Au cours des prochains mois, nous aimerions mettre en places plus de moyens
(et de meilleurs moyens) pour participer. Nous aimerions qu'il vous soit plus
facile de contribuer pour que chacun puisse en retirer une meilleure
expérience. Si vous avez des suggestions quant à la façon que nous pouvons
améliorer les choses, pourquoi ne feriez vous pas connaître vos idées sur
nbdiscuss ?</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;Steve Wilson</font><br><font class='smalltext'><i>Translated by: Vincent Brabant</i></font></td>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <TD  colspan='2' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <TD  aligm='right' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      </table><img src='/images_www/pixel.gif' width='1' height='4' bolder='0'><table border='0' cellpadding='0' cellspacing='0' width='98%'>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='TOP' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'>&nbsp;</td>
      <TD  VALIGN='TOP' class='tabler' align='right' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <td class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      <td colspan='2'><a name='s189'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans One</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >La toute première conférence de NetBeans prendra place à JavaOne.
<p>
Le mardi 29 Juin 2004, nous aurons un évênement compagnon de Java One qui
présentera le Projet NetBeans, et incluera une avant-première de la dernière
version, vous accompagnera à l'intérieur de la technologie NetBeans et
présentera également quelques parternaires cléfs de NetBeans.
<p>
Un des grands moments sera lorsque James Gosling parlera des Outils et du
futur. Et si vous avez déjà vu parler James, vous savez qu'il y aura de
belles surprises. Cela n'est certainement pas à manquer!
<p>
Pour ceux qui ont une entrée pour JavaOne, l'entrée à NetBeansOne est gratuite.
Pour ceux qui n'ont pas d'entrée pour JavaOne, l'entrée à NetBeansOne sera
également gratuite, mais ils auront également un pass pour le pavillon de
JavaOne comme bonus, ainsi qu'une remise de 200$ sur le prix d'entrée de
Java One.
<p>
This is great time hear from key Sun technical staff who manage the NetBeans
project, to learn about the technology and the roadmap. Additionally we'll be
featuring NetBeans partners that help make NetBeans a thriving ecosystem. Meet
you fellow NetBeans enthusiasts and learn those invaluable shared knowledge
tips.
<p>
Nous serons installé confortablement dans le cinéma Yerba Buena qui est
adjacent aux entrées du Centre de Convention Moscone. L'agenda prévu est le
suivant:
<table cellpadding="2" cellspacing="2">

<tr class="tablerbg">
<td class="smalltext"><B>Heure</b></td>
<td class="smalltext"><B>Titre</b></td>
<td class="smalltext"><B>Orateurs</b></td>
</tr>

<tr class="tablersh">
<td class="smalltext">9:00 AM</td>
<td class="smalltext">Inscription</td>
<td class="smalltext"> </td>

<tr>
<td class="smalltext">10:00 AM</td>
<td class="smalltext">Keynote: Le Futur des Outils de Développement Open
Source</td>
<td class="smalltext">James Gosling, Steve Wilson</td>
</tr>

<tr class="tablersh">
<td class="smalltext">11:00 AM</td>
<td class="smalltext">Miser sur la Technologie NetBeans</td>
<td class="smalltext">Ian Formanek, Tim Boudreau, Jesse Glick</td>
</tr>

<tr>
<td class="smalltext">12:00 PM</td>
<td class="smalltext">NetBeans Plug-in Development brownbag</td>
<td class="smalltext">Jesse Glick, Tim Boudreau</td>
</tr>

<tr class="tablersh">
<td class="smalltext">1:00 PM</td>
<td class="smalltext">NetBeans Solutions  I</td>
<td class="smalltext">Modérateur + Partenaires</td>
</tr>

<tr>
<td class="smalltext">2:00 PM</td>
<td class="smalltext">Concevoir des Applications Web avec NetBeans</td>
<td class="smalltext">Anna Von Klopp, Pavel Buzek, Chris Kutler</td>
</tr>

<tr class="tablersh">
<td class="smalltext">3:00 PM</td>
<td class="smalltext">NetBeans Solutions  II</td>
<td class="smalltext">Modérateur + Partenaires</td>
</tr>

<tr>
<td class="smalltext">4:00 PM</td>
<td class="smalltext">Concevoir des Applications Mobiles avec NetBeans</td>
<td class="smalltext">Martin Ryzl</td>
</tr>

<tr class="tablersh">
<td class="smalltext">5:00 PM</td>
<td class="smalltext">BOF: Développement Communauté NetBeans et Marketing</td>
<td class="smalltext">Zaheda Bhorat, Larry Baron, Robert Demmer</td>
</tr>

<tr>
<td class="smalltext">6:00-8:00 PM</td>
<td class="smalltext">Sun Tools Event</td>
<td class="smalltext">Raffraichissement, récompenses, démos et autres</td>
</tr>

</table>

<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;Larry Baron</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='s191'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Offre Couplée EDI NetBeans 3.6 Multilingue</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >La version multilingue de l'EDI NetBeans 3.6 Chinoise et Japonaise est
maintenant <a href="http://services.netbeans.org/downloads/download.php?a=b&amp;p=1">disponible pour un
téléchargement immédiat</a>.

<p>Les documents suivants ont également été traduits en
Chinois et Japonais pour vous aidez à démarrer:

<p>Installation Guide: <a
href="https://netbeans.org/community/releases/36/install_zh_CN.html">Chinese</a>,
<a href="https://netbeans.org/community/releases/36/install_ja.html">Japanese</a>

<br>Release Notes: <a
href="https://netbeans.org/community/releases/36/relnotes_zh_CN.html">Chinese</a>,
<a href="https://netbeans.org/community/releases/36/relnotes_ja.html">Japanese</a>

<br>What's New in NetBeans 3.6? <a
href="https://netbeans.org/community/releases/36/Whats_New_zh_CN.html">Chinese</a>,
<a href="https://netbeans.org/community/releases/36/Whats_New_ja.html">Japanese</a>

<br>GUI Building in NetBeans IDE 3.6: <a
href="https://netbeans.org/kb/archive/index.html">Chinese</a>,
<a href="https://netbeans.org/kb/archive/index.html">Japanese</a>

<br>NetBeans IDE 3.6 Quick Start Guide: <a
href="https://netbeans.org/kb/archive/index.html">Chinese</a>,
<a href="https://netbeans.org/kb/archive/index.html">Japanese</a>

<brUsing NetBeans 3.6: <a
href="https://netbeans.org/kb/archive/index.html">Chinese</a>,
<a href="https://netbeans.org/kb/archive/index.html">Japanese</a>

<p>Vous pouvez également vous <a
href="mailto:nbdiscuss_zh-subscribe@netbeans.org">inscrire</a> à une liste de
discussion en chinois: nbdiscuss_zh@netbeans.org
</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='s187'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Catalogue de Modules</b></font><br>&nbsp;<br><img src='/images_www/marketing_newsletter/36.gif' widht='100' height='100' border='0' alt='Catalogue - 7k' align='left' vspace='2' hspace='10'><font face='Verdana, sans-serif, helvetica, arial' ><b>nbxsl</b> - XML
<p><a href="http://www.japisoft.com/nbxslt/">JAPISoft</a> a sorti nbxsl
v1.0 qui est un nouveau module pour l'édition de XSLT
avec un résultat rapide et évaluation XPath. Voyez <a
href="http://plugins.netbeans.org/">ici</a> pour
plus d'informations, ainsi qu'une lien pour une évaluation gratuite.</p>

<b>RefactorIt</b>
<p>RefactorIT 2.0 RC2 (build 1.9.15) est maintenant disponible. 2.0
RC2 fonctionne maintenant biens sous l'EDI NetBeans 3.6. Voici ce qui a de
nouveau:
<ul><li>4 tout nouveau Mesures de Qualités (Metrics): DIP, DCYC, EP, LSP
(où, chaque Mesuse a un interval recommandé et leur violation sont
coloriées de façon appropriées dans le tableau de résultat)</li>
<li>option "Freeze" a été rajoutée à la fonction Draw Dependencies</li>
<li>pleins d'autres rustines (bug fixes) et améliorations</li></ul>

Pour plus d'informations sur RefactorIT 2.0 RC2 veuillez visiter notre <a
href="https://netbeans.org/community/news/index.html#448">page </a> sur
NetBeans.org ou <a
href="http://www.refactorit.com">www.refactorit.com</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><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='s188'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Nouveaux Articles</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >Le tutoriel d'Application Web Minuit
<a href="https://netbeans.org/kb/articles/midnight_fr.html"></a>
explique l'utilisation d'une servlette Front Controller et une vue
composite dans laquelle une page est créée avec la technologie JavaServer Pages
(JSP). Les pages JSP de cette application utilise la JavaServer Pages Standard
Tag Library (JSTL).
Pour le tutoriel, vous pouvez utilisee l'EDI NetBeans 3.5 ou 3.6 et le J2SE
1.3 ou 1.4.

<p>Concevoir des Modules Web Avec NetBeans: Transition de 3.5 à 3.6 -
Cet article aborde les nouvelles fonctionnalités de NetBeans 3.6
pour la conception des modules web.
Il discutera des modifications sur des fonctionnalités qui existaient
auparavant et qui peuvent affecter la façon dont vous travaillez.
Finalement, il dresse une liste de bogues connus et fournit quelques
solutions.</p>

<p>Guide Rapide de Démarrage pour Module We - Ce document vous
emmenne dans les bases du développement, test, et debogage d'un
module web en créant une simple application de pile ou face.
Ce document est conçu pour que vous puissiez apprendre le plus vite
possible.</p>

<p><a
href="https://netbeans.org/community/releases/36/J2ME_Support_fr.html">
Ajout Support Plateforme J2ME à l'EDI NetBeans</a> -
Mettre à jout l'EDI NetBeans avec les Modules de Mobilité pour que
NetBeans intègre le support pour le développement et le test
d'applications pour les appareils mobiles qui utilisent la plateforme Java 2,
Micro Edition (J2ME).

<p><a href="https://netbeans.org/kb/articles/j2me_tutorial_fr.html">
Tutoriel Modules Mobilité</a> -
Le tutoriel de Modules de Mobilité vous guide à travers le processus de
création et débogage d'une application MIDP/CLDC, ou "MIDLet", en utilisant
les Modules de Mobilité et l'EDI NetBeans. Cliquez sur le lien suivant pour
ouvrir le tutoriel:
</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/kb.html
' target='new'>plus d'articles</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>
