
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 13</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 # 13 - Sep 15, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2630">Celsius v5 -  Tester le développement Mobile Hassle gratuitement & le transporter directement vers l'EDI Netbeans!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1801&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='100' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Sans quitter l'environnement Netbeans, apprendre à créer facilement des applications mobiles avec le plugin Celsius v5 de Mobile Distillery, un partenaire stratégique de Netbeans. Il supporte automatiquement différentes versions optimisées de vos applications à partir d'un seul code source pour plus de 1000 périphériques Java et BREW. Celsius tire pleinement profit des outils de l'EDI et avec son API de haut niveau il permet aux développeurs Java, même s'ils ne sont pas des experts, d'exceller dans le développement mobile. Inscrivez-vous gratuitement pour les sessions de formation gratuite et avoir une idée sur l'expérience réelle du développement paramétrique (un mois plein de licence inclus)!</p><br style="clear:both;"/>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2624">Support PHP de NetBeans 6.5 & sNouvelles</a></h2>
						<p style="margin-left:8px;">
						Le développeur Toni Epple met le support PHP dans Netbeans 6.5 pour le test de création d'un projet avec sNews, un système de gestion de contenu léger.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2625">Test du support UML de NetBeans 6.5</a></h2>
						<p style="margin-left:8px;">
						L'expert Java EE Adam Bien donne sa première impression sur le plugin d'UML refactoré dans Netbeans 6.5 (disponible à partir du Centre de mise à jour - Update Center - de Netbeans 6.5)</p>
					</div>
				<h1>Calendrier</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2631">Camp sur l'intégration continue Netbeans - Munich (19 septembre)</a></h2>
						<p style="margin-left:8px;">
						L'intégration continue facilite le travail en équipe, et aujourd'hui les développeurs utilisent des outils comme Hudson et CruiseControl pour automatiser les procédures de compilation et de test. Rejoindre les utilisateurs Netbeans à Heimstetten (près de Munich) pour un camp ouvert durant lequel seront discuter les bonnes pratiques, les outils intéressants et le développement en équipe.
<i>(Le site web est en Allemand.)</i></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2632">Voir Netbeans à JavaZone 2008 - Oslo (du 17 au 18 septembre)</a></h2>
						<p style="margin-left:8px;">
						JavaZone est la plus grande rencontre de développeurs en Scandinavie. Rejoindre les ingénieurs Netbeans Karol Harezlak et Lukas Hasik pour une présentation sur l'état actuel et futur du développement JavaME. Autres sessions récommandées incluses : 
<a href="http://javazone.no/incogito/session/JRuby+Sm%C3%B6rg%C3%A5sbord.html">JRuby Smörgåsbord</a> 
avec Ola Bini et Charles Nutter, les sessions JavaFX par <a href="http://javazone.no/incogito/session/Adding+Animation+and+Media+to+JavaFX+and+Java+Applications.html">Raghavan N. Srinivas</a> et <a href="http://javazone.no/incogito/session/Project+Hydrazine%3A+JavaFX+Open+Cloud+Computing+Platform.html">Bernard Traversat</a>.</p>
					</div>
				<h1>Nouvelles de projet</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2633">Patch3 pour l'EDI NetBeans 6.1</a></h2>
						<p style="margin-left:8px;">
						Un nouveau patch est disponible pour l'EDI Netbeans 6. La mise à jour inclus les correctifs dans les modules pour BPEL, C/C++, Application Composite, base de données, Edition de fichiers, Générateur d'interface graphique, GlassFish, la Plateforme de l'EDI, Java, Java EE, Persistance Java, Développement de plug-in Java, Plateforme, Services Web RESTful, SOA, Librairie TAX, WSDL, Services Web, Outils de productivité XML, Support XML, Schema et XLS.
<br>
La version est disponible en Anglais, Japonais, Chinois simplifié, Portugais brésilien et est téléchargeable en utilisant le gestionnaire de plugins de l'EDI Netbeans.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2634">Nouveau support BlueJ Multilangue dans l'EDI Netbeans 6.1</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1795&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;'/>
						Disponible à partir du centre de mise à jour Netbeans : Une nouvelle version plurilingue  complète du plug-in BlueJ pour Netbeans 6.1. Le plug-in remplace celle basée Netbeans BlueJ Edition 5.5 et assure une transition douce pour les utilisateurs de BlueJ afin de tirer profit des grandes fonctionnalités de Netbeans. Télécharger le plug-in en Anglais, Japonais, Chinois simplifié et Portugais Brésilien.</p><br style="clear:both;"/>
					</div>
				<h1>Formation</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2626">Astuce technique: Créer des propriétés JavaBeans en utilisant des codes prédéfinis</a></h2>
						<p style="margin-left:8px;">
						Les codes prédéfinis personnalisés permettent d'insérer les codes prédéfinis facilement en utilisant les raccourcis claviers. le Netbeans Dream Team Wade Chandler montre trois bouts de code de programme prêts-à-utiliser pour la création des propriétés JavaBeans.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2627">Services Web RESTful et Comet</a></h2>
						<p style="margin-left:8px;">
						Les utilisateurs peuvent interagir à distance avec une application web Comet. Apprendre à construire une telle application avec Dojo, les technologies Java EE et GlassFish.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2628">Simple analyseur d'interface utilisateur graphique utilisant StringTokenizer</a></h2>
						<p style="margin-left:8px;">
						Apprendre comment créer un plugin Netbeans qui s'ouvre dans la même fenêtre que le plugin. Pour ajouter la fonctionnalité à l'interface utilisateur graphique, l'utilisateur implémente un petit analyseur en utilisant la classe StringTokenizer.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2629">Création d'une zone de texte auto-complétion Ajax avec Dynamic Faces</a></h2>
						<p style="margin-left:8px;">
						Créer, récupérer, mettre à jour et supprimer des lignes dans Netbeans IDE 6.5. Ce tutoriel utilise le composant zone de texte de Woodstock JSF 1.2 avec la fonctionnalité Ajax fournie par la librairie de composant du projet Dynamic Faces.</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-09-15_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>