
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 33</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 # 33 - Aug 06, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4022">Tapestry 5, NetBeans 6.7, Maven et Jetty : réellement!</a></h2>
						<p style="margin-left:8px;">
						La Dream Team Alex Kotchnev vous montre dans son blog comment installer en quelques étapes les classes et la recharge des exemples Tapestry 5 avec Netbeans. Apache Tapestry est un framework open-source d'application web qu'Alex utilise avec le serveur web Jetty. Apprendre plus dans ce blog</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4023">Développer des applications base de données en utilisant MySQL Connector/C++</a></h2>
						<p style="margin-left:8px;">
						Ce tutoriel vous montrera les étapes essentielles pour développer et installer le nouveau pilote MySQL Connector/C++, avec des exemples simples pour connecter, insérer et retourner des données à partir d'une base de données MySQL. Les développeurs d'application découvrant MySQL Connector/C++ mais connaissant bien la programmation C++ et la base de données MySQL sont les plus concernés par ce tutoriel.</p>
					</div>
				<h1>Calendrier</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4024">De nouvelles applications excitantes Java Desktop et Swing</a></h2>
						<p style="margin-left:8px;">
						JavaOne 2009 à San Francisco, du 2 au 5 juin, a beaucoup à offrir aux développeurs Java Desktop. Apprendre des experts comment développer avec la plate-forme Netbeans pour gagner du temps et préserver ses nerfs ! Plusieurs conférencier de JavaOne recommandent Netbeans IDE pour la création, la conception et l'optimisation des applications Java Swing. <a href="https://netbeans.org/servlets/NewsItemView?newsItemID=1381"> Consulter ces sessions </a> dans le catalogue des sessions.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4025">Profitez de vos applications mobiles</a></h2>
						<p style="margin-left:8px;">
						Une application Java est encore la meilleure manière de rechercher des millions de mobiles et appareils embarqués. Rejoignez-nous à JavaOne 2009, du 2 au 5 juin, lorsque nous allons travailler avec cinq développeurs pour obtenir leur application mobile publiés commercialement ! Si vous êtes un développeur mobile vous trouverez <a href="https://netbeans.org/servlets/NewsItemView?newsItemID=1382"> de nombreuses sessions sur Netbeans IDE pour Java ME et JavaFX </a> dans le catalogue des sessions.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4026">Devenir un expert en Web et applications d'entreprise</a></h2>
						<p style="margin-left:8px;">
						Qui crée une application web ou une application d'entreprise a besoin de certaines connaissances dans diverses technologies : la conférence JavaOne 2009, du 2 au 5 juin à San Francisco est l'endroit idéal pour apprendre des experts comment ces technologies peuvent interagir pour fournir une solution unique. Ici nous vous montrons quelques <a href="https://netbeans.org/servlets/NewsItemView?newsItemID=1380"> sessions qui pourraient intéresser les développeurs d'applications web </a> comme vous.</p>
					</div>
				<h1>Communauté</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4021">NetBeans Connecte  les développeurs à CommunityOne 2009</a></h2>
						<p style="margin-left:8px;">
						CommunityOne 2009  à San Francisco est votre seule chance pour apprendre les dernières technologies Web 2.0 gratuitement ! Si vous voulez approfondir le sujet, vous pouvez vous inscrire pour une journée complète d'atelier à moitié prix. Jetez un coup d'oeil sur le catalogue de la session, <a href="https://netbeans.org/servlets/NewsItemView?newsItemID=1383"> il y a plusieurs trucs intéressants pour les utilisateurs de Netbeans </a>!</p>
					</div>
				<h1>Formation</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4018">Tutoriel sur le module d'assistant de Netbeans</a></h2>
						<p style="margin-left:8px;">
						Dans les applications de la plateforme Netbeans, plusieurs types d'assistants peuvent être créés. Ce tutoriel montre comment créer un assistant général qui apparait lorsque l'on clique sur le bouton de la barre d'outil.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4019">Guide utilisateur du débogueur JavaScript de Netbeans</a></h2>
						<p style="margin-left:8px;">
						Le débogueur JavaScript de Netbeans vous fournit un ensemble d'outils qui vous aide dans le processus d'inspection, de gestion et d'édition du code JavaScript. Vous pouvez l'utiliser pour détecter les erreurs ou les étapes de l'exécution et explorer l'état de votre application à n'importe quel moment.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4020">Passer des données binaires via un service web</a></h2>
						<p style="margin-left:8px;">
						Dans ce tutoriel avancé, vous apprendrez comment rendre disponible des données binaires (comme les images) via un service web. Vous allez aussi créer une application Java qui se connecte au service web pour afficher les images dans un album crée à partir des composants Swing.</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-08-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>