
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 32</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 # 32 - Aug 05, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Nouvelles de projet</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4017">Télécharger Netbeans IDE 6.8 Milestone 1</a></h2>
						<p style="margin-left:8px;">
						L'équipe de Netbeans a le plaisir d'annoncer la sortie de Netbeans IDE 6.8 Milestone 1. Les fonctionnalités remarquables de la version se composent d'un navigateur intégré, d'un support pour Java EE 6 et Jira, une amélioration de PHP, Maven, Ruby and C/C++. Visitez la page <a href="http://wiki.netbeans.org/NewAndNoteworthyNB68"><b> Nouvelles et prouesses de Netbeans 6.8 </b></a> pour plus de détails sur les fonctionnalités et les améliorations. La version finale de Netbeans 6.8 est prête pour automne 2009</p>
					</div>
				<h1>Communauté</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4015">Plugin - CronJob 1.0.2: Démarrage et arrêt de travaux</a></h2>
						<p style="margin-left:8px;">
						Un autre plugin intéressant de Aljoscha Rittner (son dernier module était <a href="http://www.sepix.de/blogs/blogrittner/blog/archive/2009/july/15/plugin_netbeans_tutorial_builder_screen_capture_und_crop_tool/index.html"> le concepteur de tutoriel Netbeans </a>).Ce nouveau plugin : permet aux utilisateurs de définir des CronJobs, des tâches de démarrage et d'arrêt pour les cibles Ant. Le code source du plugin est disponible à partir de Kenai.com. Voir les captures d'écran et lire plus d'informations sur le <a href="http://www.sepix.de/blogs/blogrittner/blog/archive/2009/august/03/plugin_cronjob_102_startup_und_shutdown_jobs/index.html">blog</a> d'Aljoscha. <i>(En Allemand.)</i></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4016">NetBeans Podcast de retour avec Episode #50!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=3267&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='88' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Le posdcast Netbeans est de retour! Télécharger et écouter l'épisode 50 pour les nouvelles provenant de l'équipe Netbeans. Les sujets incluent une présentation de l'intégration du projet Kenai dans l'EDI Netbeans, les astuces de conception d'API de Jarda, l'énigme de Netbeans ! Jeter un coup d'oeil sur l'<a href="https://netbeans.org/servlets/NewsItemView?newsItemID=1410">agenda</a>  et écouter.</p><br style="clear:both;"/>
					</div>
				<h1>Formation</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4012">Premiers pas avec JavaFX Mobile 1.2 EA pour Windows Mobile</a></h2>
						<p style="margin-left:8px;">
						Une séquence vidéo de Terrence Barr montre comment démarrer avec JavaFX Mobile 1.2 Early Access pour Windows Mobile. Il montre comment exécuter une application simple (Mosaic) sur le HTC Diamond, incluant l'utilisation de fonctionnalités déployées via USB.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4013">Développer des clients service web JAX-WS.</a></h2>
						<p style="margin-left:8px;">
						Dans ce tutoriel, apprenez à utiliser les facilités du service web fournies par Netbeans pour analyser un service web de vérificateur orthographique et développer un client web qui interagit avec lui.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4014">Connecter une arborescence Dojo Tree à un  ArrayList en utilisant JSON</a></h2>
						<p style="margin-left:8px;">
						Ce tutoriel montre comment ajouter et connecter un widget Dojo Tree à un ArrayList en utilisant JSON.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4010">Intégration de JSLint plus ferme dans NetBeans</a></h2>
						<p style="margin-left:8px;">
						Bonne nouvelle pour les utilisateurs de l'outil de qualité de code JavaScript JSLint : Ari Shamash et Dominic Mitchell ont une nouvelle version de jslint4java qui s'intègre encore mieux dans Netbeans. La nouvelle version non seulement liste les problèmes détectés mais permet aux utilisateurs de parcourir la ligne affectée dans le fichier JavaScript avec un click dans la fenêtre de sortie.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4011">Combien de miles encore à parcourir ? Un cadre expérience</a></h2>
						<p style="margin-left:8px;">
						Lancez-vous ! Utilisation de JRuby, Ruby-on-Rails, GlassFish, NetBeans, MySQL, et les graphiques YUI, Arun Gupta a développé une application qui fournit un système de localisation basique pour vos courses et génére les graphiques de progression. L'application est une expérience basée sur l'utilisation de différentes structures web. Plus d'informations sur le blog d'Arun.</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4009">Qui a traduit "The Definitive Guide to NetBeans Platform"?</a></h2>
						<p style="margin-left:8px;">
						Une toute nouvelle série a débuté sur <a href="http://netbeans.dzone.com/">NetBeans Zone</a>, engage-toi auprès des traducteurs Allemand-Anglais de "<a href="http://apress.com/book/view/9781430224174">The Definitive Guide to the NetBeans Platform</a>". Dans la première tranche, Stefan Flemming de Berlin!</p>
					</div>
	<div class="edited">
	Ce numéro vous a été envoyé par: Drabo Constantin<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-08-05_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>