
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 20</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 # 20 - Nov 04, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2882">Transporter un système Sales dans la plateforme Netbeans</a></h2>
						<p style="margin-left:8px;">
						Dans cette interview Netbeans Zone, <a href="http://www.sepix.de/blogs/blogrittner/index.html">Aljoscha Rittner</a> explique comment il a transporté une application Swing dans la plate-forme, décrit les étapes par lesquelles il faut passer et les astuces pour les développeurs qui voudraient réaliser des projets similaires.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2887">Webinaire : Rapid Model Driven Development avec l'EDI NetBeans</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2089&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='100' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Joignez-vous aux experts de la technologie Netbeans et Intellium pour un webinaire à la demande et découvrez comment simplifier le développement d'applications et de services web avec Netbeans et la plateforme Model Driven Development d'Intellium Virtual Enterprise (VE), en élévant le niveau d'abstraction et en réduisant la complexité des technologies sous-jacentes.</p><br style="clear:both;"/>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2880">Mise à jour des bibliothèques Jersey/REST dans Netbeans 6.1</a></h2>
						<p style="margin-left:8px;">
						Jersey est l'implémentation de référence de JSR 311, la spécification pour la création des services web RESTful sur la plate-forme Java. Cette entrée de blog montre comment mettre à jour la bibliothèque Jersey dans Netbeans 6.1.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2881">Convertir les applications natives Rails en Grails: Le Domaine (Part 2)</a></h2>
						<p style="margin-left:8px;">
						Le second épisode dans la série d'Alex Kotchnev couvrant la migration en réel d'une application Rails vers Grails en utilisant l'EDI Netbeans. les deux parties traitent des objets de domaine, des contraintes de validation et du mappage dans la base de données Rails.</p>
					</div>
				<h1>Communauté</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2890">Portail fr.netbeans.org ressuscité!</a></h2>
						<p style="margin-left:8px;">
						Avec le 10ième anniversaire, la communauté des traducteurs francophones de NetBeans a le plaisir de vous annoncer le relooking de son portail! Encore un peu de patience avant d'avoir tout son contenu re-actualisé mais nous sommes sur la bonne voie. Jetez un coup d'œil sur l'avant-première sur <a href="http://fr.netbeans.org">fr.netbeans.org</a>!</p>
					</div>
				<h1>Nouvelles de projet</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2886">Importer les projets Eclipse dans l'EDI Netbeans</a></h2>
						<p style="margin-left:8px;">
						Netbeans 6.5 dispose d'un assistant amélioré d'importation de projets Eclipse qui vous permet d'utiliser Netbeans pour travailler sur les projets Java Desktop et les applications web créés avec Eclipse et MyEclipse. Ce tutoriel donne un aperçu des fonctionnalités d'importation d'Eclipse dans l'EDI Netbeans.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2888">Netbeans 6.5 RC2 est disponible dans les langues de la communauté</a></h2>
						<p style="margin-left:8px;">
						Netbeans 6.5 RC2 peut être téléchargée dans six langues de la communauté - allemand, français, espagnol, italien, polonais et albanais. Même si l'EDI n'est pas encore <b>complètement traduit</b> dans ces langues, la plate-forme Netbeans est disponible et les utilisateurs peuvent y développer des applications RCP Netbeans. Visitez le blog de Netbeans en français <a href="http://blogs.sun.com/netbeansfr"> netbeans_fr </a> ou le blog de <a href="http://blogs.sun.com/katakai/entry/netbeans_6_5_rc2_community"> Masaki Katakai</a> pour plus d'informations.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2889">Télécharger la version Candidate 2 de Netbeans 6.5 !</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2087&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;'/>
						La seconde version Candidate de Netbeans 6.5 est maintenant disponible en téléchargement. Des téléchargements complets de cette version <b>multilangue</b> sont aussi disponibles en japonais, chinois simplifié et portugais brésilien. La version définitive de Netbeans 6.5 est prévue pour novembre 2008. Téléchargez cette version candidate et faites part de vos remarques dans notre <a href="http://qa.netbeans.org/processes/cat/65/ca_survey.html"> sondage d'adoption de la communauté sur la 6.5 </a>!</p><br style="clear:both;"/>
					</div>
				<h1>Formation</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2883">Astuce Technique:Un Netbeans plus rapide</a></h2>
						<p style="margin-left:8px;">
						Boostez votre EDI Netbeans avec une astuce d'<a href="http://emmanueloga.wordpress.com/">Emmanuel Oga</a>.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2884">Insertions, Mises à jours et suppression efficaces</a></h2>
						<p style="margin-left:8px;">
						Ce tutoriel vous montre comment utiliser l'EDI Netbeans et  les composants JSF 1.2 (Woodstock) pour développer une application web qui peut créer, renvoyer, mettre à jour et supprimer des lignes dans une base de données. L'application fournit une liste déroulante de données maîtres synchronisées avec un tableau détail.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2885">Séquences vidéo: le Top 10 des API de NetBeans (1ère partie)</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2091&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;'/>
						La première partie d'une série de séquences vidéo sur les API de la plateforme Netbeans. La série est utile à ceux qui débutent dans les API Netbeans et à ceux cherchant à comprendre le fonctionnement d'une application comme Netbeans. La 1ère partie couvre essentiellement les problèmes de développement Swing résolus par la plate-forme Netbeans, le conteneur du moteur d'exécution et l'API Module System.</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-04_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>