
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 34</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 # 34 - Sep 17, 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=4168">Qu'est-ce qui est nouveau dans JDK 7 avec Danny Coward</a></h2>
						<p style="margin-left:8px;">
						Dans cette vidéo de la technologie Java, Danny Coward, chef architecte pour les logiciels client à Sun Microsystems, montre quelques fonctionnalités dans JDK7. Vous verrez les démonstrations et les exemple de code -- et dit aussi pourquoi en devenant violoniste de concert dans une symphonie locale lui permet de s'évader.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4169">Java EE 6 et NetBeans IDE 6.8</a></h2>
						<p style="margin-left:8px;">
						Le blog de Geertjan partage avec vous les nouvelles fonctionnalités de Java EE 6 dans le prochain  EDI Netbeans 6.8. La partie importante est sur le type de projet d'application web, depuis que les EJBs peuvent aussi être crées à l'intérieur d'applications web. Si vous choisissez le framework JSF, vous avez le choix entre les Facelets( par défaut) ou JSP comme langage de vos pages. Vous trouverez plus d'information sur le blog de Geertjan.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4170">Avoir les meilleurs exemples de projets dans l'EDI</a></h2>
						<p style="margin-left:8px;">
						Vous savez que vous pouvez ouvrir un exemple de projet à partir du menu Nouveau Projet - mais vous savez que vous pouvez charger également plus d'exemples maintenant dans l'EDI ? l'équipe de documentation de Netbeans a complètement mis à jour le catalogue d'exemple en ligne : Tous les exemples sont hébergés sur kenai.com. Parcourez la liste en ligne, téléchargez les projets zippés - ou les ouvrir directement dans l'EDI en utilisant l'outils d'intégration Kenai de Netbeans !</p>
					</div>
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4166">Devélopper des jeux 3-D Java avec JME et Netbeans</a></h2>
						<p style="margin-left:8px;">
						Ce tutoriel de la communauté de documentations montre comment installer l'EDI Netbeans pour commencer la création de jeux 3-D avec le framework jMonkeyEngine (jME 2.0).</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4167">La plateforme NetBeans : Prêt pour le départ!</a></h2>
						<p style="margin-left:8px;">
						Geertjan Wielenga fait un compte rendu de Genève, Suisse, où il a dispensé une formation pour la certification sur la plateforme Netbeans : l'équipe de développement du contrôle aérien suisse a prévu de migrer plusieurs applications sur la plateforme Netbeans ! Lire l'intégralité sur les applications à migrer et aussi sur la formation proprement dite.</p>
					</div>
				<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>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4162">Formation gratuite incluant GWT 1.7.0 et NetBeans 6.7.1</a></h2>
						<p style="margin-left:8px;">
						L'équipe de Sang Shin vient de mettre à jour la session courante sur la programmation Web 2.0 pour pouvoir travailler avec la dernière version 6.7.1 de l'EDI Netbeans
<a href="http://www.javapassion.com/handsonlabs/ajaxgwtintro/">GWT 1.7.0</a>, et le <a href="http://www.javapassion.com/handsonlabs/dojo_basics/"> toolkit Dojo 1.3.2</a>! 
Le lab contient également beaucoup de projets Netbeans basés GWT qui sont prêts à être ouverts et compilés. Le nouveau contenu fait partie de "<a href="http://www.javapassion.com/ajaxcodecamp/"> 18 semaines de cours gratuits sur la programmation Ajax et Web 2.0 (avec Passion!)</a>" en ligne -- Vous pouvez toujours rejoindre le groupe!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4164">Applications de la plateforme Netbeans: Visualiser des fichiers PDF sur les téléphones portables</a></h2>
						<p style="margin-left:8px;">
						Lire comment grâce à la plateforme Netbeans  un étudiant a pu développer une application complète comptant pour sa thèse à l'université: Jamorea Desktop est une application open source pour la prévisualisation et la gestion des fichiers PDF et leur transfert dans les équipement mobiles.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4165">Astuce technique:  Pliage de code personnalisé</a></h2>
						<p style="margin-left:8px;">
						Un astuce pour éliminer les bruits inutiles lorsque l'on travaille : vous savez aussi que vous pouvez plier les bloques de code dans l'éditeur Netbeans en cliquant sur le petit signe plus. Mais vous pouvez aussi définir des bloques personnalisés que vous voulez réduire en utilisant l'action de l'éditeur Surround-With.</p>
					</div>
				<h1>Calendrier</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4163">Webinair gratuit: Opter pour OpenOffice.org ( le 16 septembre)</a></h2>
						<p style="margin-left:8px;">
						Assitez au webinaire interactif sur OpenOffice le 16 septembre prochain ! l'équipe de OpenOffice.org démontre comment il est facile de faire une transition en douceur et fidèle en utilisant OpenOffice.org. Vous pouvez aussi avoir l'opportunité de poser des questions -- <a href="https://dct.sun.com/dct/forms/reg_us_2808_539_0.jsp"> Inscrivez-vous dès aujourd'hui </a>.</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-09-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>