
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 29</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 # 29 - Mar 26, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3475">NetBeans et les services Web</a></h2>
						<p style="margin-left:8px;">
						L'utilisateur Moz écrit que Netbeans est un outils puissant pour les services web et consacre cette entrée en créant un client service web en quelque clics.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3476">NetBeans 6.7 et Glassfish v3: Synergie pour un développement pragmatique JavaEE 6</a></h2>
						<p style="margin-left:8px;">
						Voir Adam Bien en action à CommunityOne East de Sun. "Aucune présentation, juste un code : à partir de rien pour une application Java EE /RIA maintenable, avec des astuces et les bonnes pratiques "</p>
					</div>
				<h1>Calendrier</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3481">Webinaire: Développer des applications Java + MySQL avec NetBeans, JRuby-on-Rails et GlassFish</a></h2>
						<p style="margin-left:8px;">
						Rejoindre Arun Gupta, le "GlassFish Guy" chez Sun Microsystems, pour ce webinaire technique durant lequel il montrera comment dompter la dernière version de Netbeans pour développer rapidement et aisement ,déployer des applications supportées par Mysql et GlassFish en utilisant le framework JRuby-on-Rails.
<br><br>
Quand : <b>jeudi, 26 mars, 2009</b>, 10:00 am PDT, 1:00 pm EDT, 17:00 GMT. <i>(Cette présentation durera approximativement 45 minutes suivie de Q&A (Question/Reponse).)</i></p>
					</div>
				<h1>Nouvelles de projet</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3482">Créer. Développer. Gagner. Reléver le défi de codage JavaFX !</a></h2>
						<p style="margin-left:8px;">
						Il n'y a aucune limite à l'imagination. Concevez et soumettez une nouvelle application en utilisant JavaFX et vous pourrez gagner 25000 USD! Le concours est ouvert aux développeurs professionnels et aux étudiants. Plus de détails  sur <a href="http://www.javafx.com/challenge/?intcmp=2678">JavaFX.com</a>, jetez aussi un coup d'oeil sur <a href="https://netbeans.org/features/javafx/index.html">NetBeans IDE pour JavaFX</a></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3483">Donner un coup de main au test de Netbeans 6.7 - Rejoignez NetCAT!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2707&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='83' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Faite un retour d'information sur l'utilisation de votre EDI favorit en aidant l'équipe de Netbeans pour le test de Netbeans 6.7. Inscrivez-vous pour le prochain cycle de NetCAT, le <i> programme de test de validation de la communauté Netbeans</i>. De quoi a-t-on besoin ? Quelques heures dans la semaine d'avril à mai. Rejoindre d'autres volontaires et aider à rendre la prochaine version au top niveau !</p><br style="clear:both;"/>
					</div>
				<h1>Formation</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3477">Option Recherche sur Twitter en PHP</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2713&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;'/>
						Une petite présentation pour créer une application de recherche sur Twitter qui affiche les résultats dans un graphique sur un interface utilisateur Yahoo.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3478">Tutoriel sur une application CRUD avec la plateforme Netbeans</a></h2>
						<p style="margin-left:8px;">
						Ce tutoriel montre comment intégrer une base de données MySQL dans une application de la plateforme Netbeans. A la fin, vous connaitrez une large éventail de fonctionnalités qui peuvent vous aider à créer des applications similaires.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3479">Déployer PHP sur un serveur web OpenSolaris</a></h2>
						<p style="margin-left:8px;">
						Ce tutoriel montre une alternative pour configurer PHP, MySQL, Apache et XDebug sur votre ordinateur. En lieu et place, déployez vos applications sur une image de serveur OpenSolaris avec le service web PHP préconfiguré dans un Virtual Box.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3480">Créer un service web RESTful et un client JavaFX</a></h2>
						<p style="margin-left:8px;">
						Apprendre comment utiliser l'EDI Netbeans avec GlassFish et MySQL pour créer un service web RESTful. Vous apprendrez aussi comment utiliser Netbeans avec JavaFX pour lancer un client JavaFX pour le service web.</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> | <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-03-26_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>