
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 17</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 # 17 - Oct 17, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2799">Q&R avec Alexandre Soumbatov sur son projet d'éditeur PL/SQL gagnant du trophée en argent</a></h2>
						<p style="margin-left:8px;">
						Le début est un charme pour le développeur Alexandre Soumbatov qui a gagné un trophée en argent dans le concours Innovators Grant pour son éditeur PL/SQL. Dans cet entretien, il parle de la façon dont il a utilisé l'EDI Netbeans pour son tout premier concours.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2793">Hello JavaServer Faces World avec l'EDI Netbeans & GlassFish</a></h2>
						<p style="margin-left:8px;">
						Apprendre à créer une application Java Server Faces en utilisant Netbeans 6.1 dans cette entrée de Arun Gupta. Cette application aussi démontre un nombre de concepts simple JSF.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2794">Ajouter des Centres de mise à jour aux applications RCP de Netbeans</a></h2>
						<p style="margin-left:8px;">
						Vous désirez ajouter des centres de mise à jour dans votre application de la plate-forme Netbeans? Amit Kumar Saha montre dans cette entrée de blog comment y parvenir.</p>
					</div>
				<h1>Communauté</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2800">Flux radio: Ce que le support JavaFX dans Netbeans 6.5 peut apporter aux développeurs</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2000&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='33' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						David Strupl, leader technique pour JavaFX dans l'EDI Netbeans, parle de ce que les développeurs peuvent attendre du prochain support pour JavaFX dans Netbeans 6.5.</p><br style="clear:both;"/>
					</div>
				<h1>Nouvelles de projet</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2802">Lancement de la célébration du 10ème Anniversaire de Netbeans la semaine prochaine !</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1998&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='100' width='68' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Netbeans a 10 ans ! A partir du lundi 20 octobre, venez nous rejoindre pour une longue semaine de rétrospective illustrée par certains des projets qui ont contribué au succès de Netbeans et avec leurs auteurs. La célébration sera l'occasion de lancer un décathlon ainsi qu'un noouveau contenu qui va encore rehausser l'évolution du projet Netbeans. Nous vous invitons à vous joindre à nous la semaine prochaine pendant la célébration de cette étape remarquable de l'EDI.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2801">Devenir un Testeur Beta pour l'examen de la Certification Netbeans !</a></h2>
						<p style="margin-left:8px;">
						Êtes-vous un programmeur qui développe des application Java bureau et Java web en utilisant l'EDI Netbeans ? Si c'est le cas, ceci est votre chance de participer à la création de l'examen de certification Sun Certified Specialist NetBeans IDE Beta! Aidez-nous à "tester le test" et accumulez ainsi des points pour la certification officielle ! L'examen bêta est GRATUIT et disponible à travers le monde entier dans tous les centres de test Prometric autorisés.</p>
					</div>
				<h1>Formation</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2795">Astuce technique : Attacher la source pour les librairies</a></h2>
						<p style="margin-left:8px;">
						Le contributeur de la Communauté Docs Ruben Laguna vous détaille trois étapes rapides pour attacher le code source pour les fichiers JAR externes. Ici, le module Library Wrapper de Netbeans.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2796">Utilisation de Fragments de Page dans les applications web</a></h2>
						<p style="margin-left:8px;">
						Dans ce tutoriel, créez une application web avec deux fragments de page : l'information d'en-tête d'application et les liens pour la navigation entre deux pages.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2797">Demo:  Utiliser le support JPA avec EclipsLink dabs l'EDI Netbeans</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2003&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='33' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Un tutoriel sur la manipulation du support de l'API de Persistance Java en utilisant EclipseLink dans l'EDI Netbeans. Cette demo est divisée en deux parties; la première montre le support EclipseLink en utilisant les indications de l'éditeur et le refactoring; la seconde décrit la création de classes entité à partir d'une base de données.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2798">Installation de l'EDI Netbeans, JDK 6 & JavaFX sur les Macs 32-bit</a></h2>
						<p style="margin-left:8px;">
						Comment installer le SoyLatte JDK 6 et JavaFX sur Intel Macs avec Mac OS X 10.4 et CPU 32-bit, mais aussi configurer l'EDI Netbeans en tant qu'outil.</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>
        </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-10-17_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>