
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 30</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 # 30 - Apr 01, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3510">La plateforme Netbeans permet la conception de maisons intelligentes (Dzone)</a></h2>
						<p style="margin-left:8px;">
						Dans cet article de Netbeans Zone, Marek Kliś, un développeur de la plateforme Netbeans, présente une application de gestion de maison  développée sur la plateforme Netbeans. L'application contrôle la luminosité de la maison, les systèmes de rechauffement et de sécurité.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3511">NetBeans pour "Cloud and Beyond": une converstion avec Matt Thompson</a></h2>
						<p style="margin-left:8px;">
						Qu'est-ce qu'il y a de nouveau pour le projet Netbeans ? Retrouvez le contenu dans l'interview avec Matt Thompson, Directeur Sénior des outils pour développeur Cloud chez Sun. Matt discute pourquoi Netbeans continue d'intéresser Sun et que la communauté peut toujours espérer que Netbeans va continuer d'évoluer.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3513">Devenir Spécialiste Certifié Netbeans !</a></h2>
						<p style="margin-left:8px;">
						Quel est votre QI Netbeans ? Passez <b> l'examen "Sun Certified Specialist for Netbeans" </b> et prouvez que vous avez une forte connaissance de l'EDI Netbeans !
<br><br>
Créé pour les programmeurs avec une expérience dans l'utilisation de l'EDI Netbeans pour le développement d'applications bureau Java et Web , l'examen confirme que vous pouvez mettre en place et configurer des projets complexes dans l'EDI et utiliser ses outils pour concevoir, coder, tester , déboguer et profiler des applications. Prouvez votre connaissance et distinguez-vous. Enregistrez-vous pour être "Sun Certified for Netbeans" dès aujourd'hui !</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3504">Installer XDebug sur NetBeans 6.5 PHP</a></h2>
						<p style="margin-left:8px;">
						Une entrée de blog qui expose les étapes pour l'installation du support XDebug dans Netbeans 6.5 sur Windows Vista.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3505">Astuce technique: Scinder l'écran d'édition dans Netbeans</a></h2>
						<p style="margin-left:8px;">
						Une astuce du développeur David Salter: Comment implémenter la scission d'écran d'édition lorsque l'on travaille sur un seul fichier dans  Netbeans.</p>
					</div>
				<h1>Livres</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3512">Pré-commander le nouveau livre "NetBeans Platform 6.5 API" !</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2736&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='99' width='74' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						De l'auteur Heiko Bock, <b>The Definitive Guide to NetBeans Platform 6.5</b> est une présentation approfondie de la plateforme Netbeans et de tous les APIs essentiels. Plusieurs sujets dans le livre n'ont cependant pas été documenté,  ce qui le rend absolument nécessaire a être acquis par  tous les développeurs de la plateforme Netbeans. Pré-commandez dès aujourd'hui une copie!</p><br style="clear:both;"/>
					</div>
				<h1>Formation</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3506">Utiliser Hibernate avec l'API Java Persistence</a></h2>
						<p style="margin-left:8px;">
						Un tutoriel qui détaille l'utilisation du fournisseur de persistance Hibernate avec  JPA dans Netbeans 6.5</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3507">Tutoriel de la librairie Visual de NetBeans pour des applications Java</a></h2>
						<p style="margin-left:8px;">
						Apprendre à utiliser les principales fonctionnalités fournies par l'API Visual Library de Netbeans. Le tutoriel couvre l'installation de l'application, l'ajout des librairies, la création et l'activation des widgets.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3508">Détecter les périphériques et envoyer des fichiers via Bluetooth dans Java ME</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2740&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='88' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Cette astuce montre comment créer un MIDlet qui detectera les périphériques et services avec Bluetooth activé et permet alors à l'utilisateur d'envoyer une simple note aux péripheriques.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3509">Une application CRUD sur la plateforme Netbeans (Part 1)</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2739&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='33' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						La première partie d'une série qui intègre une base de données Mysql dans une application de la plateforme Netbeans via EclipseLink.</p><br style="clear:both;"/>
					</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-04-01_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>