
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 31</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 # 31 - Apr 10, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3542">Un étudiant expose sur la plateforme Netbeans</a></h2>
						<p style="margin-left:8px;">
						Plusieurs développeurs étudiants rapportent que la plateforme Netbeans est un excellent sujet pour leurs dissertations au collège. Dans cet interview de Netbeans Zone, l'étudiant allemand Fionn Ziegler donne les détails sur sa dissertation relative à la programmation modulaire pour les plateformes  distribuées et plusieurs avantages de cette approche.</p>
					</div>
				<h1>Nouvelles de projet</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3546">Un nouveau coordinateur pour "Community Docs Contribution": Kristian Rink</a></h2>
						<p style="margin-left:8px;">
						Kristian Rink est le nouveau coordinateur de contribution pour le programme des docs de la communauté Netbeans.Allemand , Kristian a été un participant actif dans le programme et un évangeliste. Il succède alors à Varun Nischal.<i> L'équipe de Netbeans remercie beaucoup Varun pour son remarquable travail de gestion du programme. Nous souhaitons la bienvenu à Kristian dans son nouveau rôle !</i></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3547">Publier votre application  de la plateforme Netbeans !</a></h2>
						<p style="margin-left:8px;">
						La page des séquence vidéos sur la plateforme Netbeans a considérablement grossie car les développeurs trouvent de la valeur en publiant leurs applications sur celle-ci. Si vous avez une application interessante qui utilise la plateforme Netbeans et vous voulez inclure une séquence dans votre présentation ? Ecrire à "news at platform dot netbeans dot org" avec ls détails de votre application.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3548">Aidez-nous à améliorer Netbeans - Prendre part à l'enquête sur Netbeans</a></h2>
						<p style="margin-left:8px;">
						Nous voulons mieux apprendre sur vous et ce que vous faites avec Netbeans ! Prenez part à notre nouvelle enquête et donnez-nous vos perspective sur Netbeans : ce qui marche et ce qui ne marche pas ; comment vous utilisez Netbeans et comment Netbeans pourrait mieux vous servir dans le futur. Vos remarques sont très importantes pour nous et nous aideront à fournir Netbeans de la meilleure qualité !</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3549">NetBeans 6.7 Milestone 3 est maintenant disponible en téléchargement!</a></h2>
						<p style="margin-left:8px;">
						L'équipe de Netbeans a le plaisir d'annoncer la disponibilité de Netbeans 6.7 en Milestone 3 (M3). Les highlights de la versions incluent les intégrations avec <a href="http://kenai.com/">le projet Kenai</a>, GlassFish et Hudson; les améliorations de Maven, PHP, de la Platforme, Profiler, C/C++ , etc. Apprendre plus sur les <a href="http://wiki.netbeans.org/NewAndNoteWorthy">nouveautés et éléments remarquables </a> dans cette version, et faites-nous <a href="https://netbeans.org/community/lists/top.html">des remarques</a>!</p>
					</div>
				<h1>Formation</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3541">Installation des plugins Grails dans l'EDI NetBeans</a></h2>
						<p style="margin-left:8px;">
						Le développeur MrHaki met en exergue les étapes pour le téléchargement et l'installation du plugin Grails dans l'EDI Netbeans.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3543">Comment fonctionne l'assistant de Netbeans ?</a></h2>
						<p style="margin-left:8px;">
						Les mises en page de la boîte de dialogue consistante est l'une des promesses de la plateforme Netbeans. Une façon de le faire est par le biais de l'API Wizard qui permet à vos applications d'avoir une apparence standard. Ce nouveau tutoriel décrit comment l'API est utilisé.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3544">Webinaire à la demande: MySQL, NetBeans et les services web Java RESTful</a></h2>
						<p style="margin-left:8px;">
						Ce webinaire à la demande montre l'efficacité de la dernière version de l'EDI Netbeans pour développer les services web RESTful et les clients déployés sur GlassFish avec Mysql. La présentation fournit un aperçu du processus de conception autour d'un exemple "RESTful Pet Catalog service" utilisant JAX-RS, alors montre comment construire deux exemples de clients pour le service "Pet Catalog", un utilisant le framework Dojo AJAX et un autre utilisant JavaFX.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3545">Débogage des projets C/C++</a></h2>
						<p style="margin-left:8px;">
						Un cours tutoriel qui démontre comment déboguer des projets C/C++ dans l'EDI Netbeans. L'intégration du gdb permet de mettre en place des points de contrôle et les vues, d'inspecter les appels de piles, les variables locales, les threads et les régistres, une vue des instructions assembleur dans la fenêtre de désassembleur.</p>
					</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> | <a href="https://netbeans.org/community/news/newsletter/index_zh_TW.html">Chinese - traditional</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/2009-04-10_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>