
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 15</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 # 15 - Oct 06, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2736">Intégrater Java EE 5, JBPM, JBoss Seam, Netbeans et Glassfish V2</a></h2>
						<p style="margin-left:8px;">
						jBPM est un moteur de gestion de flux de travaux JBoss qui vous permet de contrôler les processus en répondant aux évènements des déclencheurs et exécutant des tâches. Ce blog montre comment importer l'exemple d'application JBoss "todo" comme un projet NetBeans et comment l'exécuter sur le serveur web Glassfish v2.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2737">L'IDE NetBeans pour PHP: travailler avec les propriétés variables de classe</a></h2>
						<p style="margin-left:8px;">
						Sur cette capture d'écran, Petr Pisl nous montre une simple application pour démontrer comment le support de PHP de l'EDI NetBeans 6.5 manipule les variables de propriété de classe, et vous découvrirez aussi les fonctionnalités de l'éditeur. Basculer en mode plein écran pour voir plus de détails.</p>
					</div>
				<h1>Calendrier</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2740">S'incrire pour les journées NetBeans à Sao Paulo, Brésil - 1er Octobre</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1924&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='77' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Bienvenue aux journées Sun Tech  à Sao Paulo, Brésil. Nous rejoindre le 1er Octobre pour un tour d'horizon complet de NetBeans! L'inscription pour les journées Netbeans sont gratuites, vous auriez pas besoin de vous inscrire pour les journées Sun Tech auxquelles vous participez.</p><br style="clear:both;"/>
					</div>
				<h1>Communauté</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2738">Présentation de la coummunauté linguistique de la semaine : Chinois</a></h2>
						<p style="margin-left:8px;">
						Les développeurs NetBeans sont des groupes d'individus, travaillant dans de multiples langages de programmation et parlant même plusieurs dialectes. Où est-ce que les utilisateurs de part le monde s'échangent les astuces de programmation et s'entraident?
Découvrir dans les semaines à venir certains de ces portails,forums,listes de diffusions dédiées des langues étrangères les plus populaires ou relatifs à l'usage de l'EDI NetBeans et de la plateforme NetBeans. Cette semaine, nous avons compilé une liste de sites privilégiant les développeurs parlant chinois.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2739">Ted Neward, Tim Boudreau, et Geertjan Wielenga parlent de la plateforme NetBeans</a></h2>
						<p style="margin-left:8px;">
						Ted Neward interviewe Tim Boudreau et Geertjan Wielenga sur la plateforme NetBeans. Dans la partie 1, ils nous présentent le développement de plugin qui se révèle "ridiculement facile". Cliquer sur la seconde icône de pré-visualisation pour voir la partie 2 et apprendre plus  sur comment créer une application Swing  sur la plateforme NetBeans, et le livre qu'ils ont co-écrit avec Jaroslav Tulach, titré "Rich Client Programming: Plugging into the NetBeans Platform".</p>
					</div>
				<h1>Formation</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2732">Astuce technique : sauvegarde des modèles de code</a></h2>
						<p style="margin-left:8px;">
						NetBeans vous permet de définir des modèles personnalisés qui insère des blocs de code. Vous pouvez ensuite taper l'abréviation appropriée et il s'étend sur le bout de code actuel. Dans cette astuce technique, Kristian Rink vous montre comment vous pouvez restaurer vos modèles personnalisés dans différentes installation de l'EDI.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2733">Sécuriser une application Web dans l'EDI NetBeans 6.5</a></h2>
						<p style="margin-left:8px;">
						Ce document fait un parcours des bases d'ajout de sécurité à une application qui est déployée aussi bien sur un serveur Tomcat qu'un serveur Sun Java System Application. Vous apprenez comment configurer l'authentification de sécurité en utilisant une fenêtre de connexion et en créant des utilisateurs avec des rôles de sécurité sur le serveur web.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2734">Introduction aux fonctionnalités d'Ajax dans l'EDI NetBeans 6.5</a></h2>
						<p style="margin-left:8px;">
						Cette présentation Ajax démontre certaines fonctionnalités dans l'EDI NetBeans qui vous permettent de programmer rapidement et efficacement quand vous travaillez avec des technologies relatif Ajax.Pendant que vous apprenez la fonctionnalité de bas-niveau d'Ajax, vous construisez une simple application qui emploie la technique de l'auto-complétion dans une zone de texte.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2735">Créer une simple application JavaFX avec l'EDI NetBeans</a></h2>
						<p style="margin-left:8px;">
						Ce tutoriel fait un tour rapide de développement d'application JavaFX en utilisant l'EDI NetBeans 6.1. A la fin de ce tutoriel, vous sauriez comment créer, pré-visualiser, exécuter et déployer une application JavaFX en utilisant l'EDI NetBeans.</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-06_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>