
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 21</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" >
<meta name="keywords" content="NetBeans, IDE, Platform, free, open source, developer" >
</head>
<body>
<style>
body {
		margin:5px 15px 5px 15px;
		font-size: 11px;
		font-family: Verdana, "Verdana CE",  Arial, "Arial CE", "Lucida Grande CE", lucida, "Helvetica CE", sans-serif;
		background-color:#e3eaf1;
		text-align:center;
}

#letter {width:533px;margin-left:auto;margin-right:auto;}
#head {background-image:url("http://services.netbeans.org/appl2/shared_images/head.png");width:533px;height:70px;background-repeat:none;}
#issue-date {padding-top:50px;text-align:center; color:white;}
#footer {background-image:url("http://services.netbeans.org/appl2/shared_images/footer.png"); width:533px;height:28px;background-repeat:none;}
#footer-text {padding-top:5px;color:#6a6b6d;text-align:center;}
#content {border-right:3px solid #747d9e;border-left:3px solid #747d9e; background-color:white; text-align:left; color:#6a6b6d; padding:13px 20px 13px 13px; }
#letter h1 {font-size: 14px; font-weight:normal; margin:3px 0px 5px 0px; padding:0px;color: #EE6B00; border-bottom:1px solid silver;}
#letter h2 {color:#2C3C79;font-size: 13px; font-weight:normal;margin:0px 0px 2px 0px;padding:0px; border:0px;}
#letter p {padding: 0px;margin:0px; text-align:justify;}
#letter a:link, a:visited { color: #045491; font-weight : normal; text-decoration: none;}
#letter a:link:hover, a:visited:hover  { color: #045491; font-normal : bold; text-decoration : underline;}
.item {margin-left:8px; margin-bottom:9px;}
.bold {font-weight:bold;}
#letter a.orange {color: #EE6B00;}
.align-right {text-align:right;}
.align-center {text-align:center;}
.edited {margin:15px -20px 0px -13px;padding-top:8px;text-align:center;}
.edge-top {background-color: #f0f7ff;padding:7px 12px 7px 7px;margin-bottom:10px; border:1px solid #747d9e;}
</style>


<div id="letter">
	<div id="head">
		<div id="issue-date" class="bold">
				Numéro # 21 - Nov 14, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2921">Script NetBeans en Ruby</a></h2>
						<p style="margin-left:8px;">
						Est-il possible d'écrire des extensions de l'EDI Netbeans Ruby en Ruby ? Les documents de Martin Krauskopf donnent un résumé des possibilités existantes dans l'entrée de blog suivante.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2922">Développer/Exécuter/Déboguer une application Rails en utilisant l'EDI Netbeans NetBeans IDE & GlassFish v3 Prelude</a></h2>
						<p style="margin-left:8px;">
						GlassFish v3 Prelude est maintenant disponible. La vidéo de Arun Gupta montre comment développer/exécuter/déboguer une application Rails en utilisant l'EDI Netbeans et GlassFish v3 Prelude.</p>
					</div>
				<h1>Calendrier</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2928">Camp de démo NetBeans à Munich - 18 novembre</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2122&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='93' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Pour célébrer le 10ème anniversaire du projet Netbeans et la sortie de la version Netbeans 6.5, le Groupe des Utilisateurs de Netbeans de Munich tiendra son premier "Camp de démo Netbeans" . Le camp se focalisera sur Netbeans en tant que plate-forme Client Riche et comprendra des démos intéressantes. L'inscription est gratuite.</p><br style="clear:both;"/>
					</div>
				<h1>Communauté</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2927">Tester sa connaissance Java et gagner un des 100 livres offerts!</a></h2>
						<p style="margin-left:8px;">
						Prenez part au Quiz de SDN et évaluez votre connaissance de Java. Rejoignez ou connectez-vous à Sun Developer Network(SDN) et répondez correctement aux questions du quiz. Vous serez peut-être parmie les gagants d'une copie  de "<b>Hello World(s)—From Code to Culture: A 10-Year Celebration of Java Technology</b>".</p>
					</div>
				<h1>Nouvelles de projet</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2929">NetBeans disponible en téléchargement via des serveurs miroirs à travers le monde !</a></h2>
						<p style="margin-left:8px;">
						Bonjour le téléchargement rapide de Netbeans !
Grâce au réseau de serveurs miroirs à travers le monde (USA, Brésil,
Grande-Bretagne, Hollande, Taiwan et Japon), les utilisateurs peuvent
maintenant télécharger rapidement Netbeans à partir des sites de
téléchargement haut débit proches de chez eux. Nous attendons
toujours plus de miroirs, spécialement en Autralie, Chine, Inde et Russie. Si vous detenez ou administrez un site haut-débit et voulez héberger des binaires de Netbans, <a href="https://netbeans.org/about/contact_form.html?to=1">contactez-nous</a> pour en discuter les détails.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2930">NetBeans 6.5 obtient un large score de la part de la communauté</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2120&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='90' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						La communauté Netbeans dit que NetBeans 6.5 est prêt pour FCS ! 92% des participants à notre enquête NetCAT ont approuvé le projet, avec cependant des recommandations pour corriger certains bugs. (Les patchs seront intégrés dans le package Patch1.)
Merci à tous les participants à l'enquête et à l'équipe NetCAT 6.5 pour
leur aide immense lors de la phase de stabilisation de la 6.5 !</p><br style="clear:both;"/>
					</div>
				<h1>Formation</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2923">Astuce technique : Résoudre des Références pour compiler les projets JNLP avec Netbeans 6.x</a></h2>
						<p style="margin-left:8px;">
						Cette astuce technique de la communauté de Lockhart donne les étapes pour résoudre les problèmes de référence lorsque l'on compile les projets JNPL dans l'EDI Netbeans.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2924">Créer et importer un composant JavaBeans dans l'EDI Netbeans (Part 1)</a></h2>
						<p style="margin-left:8px;">
						Obtenir une présentation simple pour créer et utiliser des composants JavaBean dans l'EDI Netbeans.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2925">Les APIs Top 10 de NetBeans (Part 2 & 3)</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2125&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='33' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Deuxième partie et <a
href="https://channelsun.sun.com/category/playlist?id=81">trois</a>
d'une série de vidéos sur les APIs de la plateforme Netbeans. Dans cette deuxième partie, apprenez comment l'API LookUp est similaire ou différent de la classe ServiceLoader de JDK 6, et voyez l'API Window System en action dans la partie trois.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2926">Journal sur l'essentiel de MySQL (Dzone)</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2124&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='110' width='85' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Essayez MySQL dans l'EDI Netbeans ? Vérifiez les nouvelles cartes de référence de DZone qui fournit de nombreux trucs et astuces pour MySQL.</p><br style="clear:both;"/>
					</div>
	<div class="edited">
	Ce numéro vous a été envoyé par: Jeremie Bertolino<br/>Si vous ne désirez plus recevoir cette lettre d'information, <a href="https://netbeans.org/community/lists/top.html">des-inscrivez vous ici</a>
	</div>
	<div class="edited">
        Langues disponibles<br>
        <a href="https://netbeans.org/community/news/newsletter/index.html">English</a> | <a href="https://netbeans.org/community/news/newsletter/index_pt_BR.html">Brazilian Portuguese</a> | <a href="https://netbeans.org/community/news/newsletter/index_fr.html">French</a> | <a href="https://netbeans.org/community/news/newsletter/index_zh_CN.html">Chinese - simplified</a>
        </div>
	</div>
	<div id="footer">
		<div id="footer-text">
				Cette lettre d'information est aussi accessible à cette adresse  <a href="https://netbeans.org/community/news/newsletter/2008-11-14_fr.html">www.netbeans.org</a>,
				<a href="https://netbeans.org/community/news/newsletter/archive_fr.html">Archives des lettres d'information</a>
		</div>
	</div>

</body>
</html>