
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 6</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 # 6 - Jul 24, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2334">Dix grandes fonctionnalités de Netbeans IDE</a></h2>
						<p style="margin-left:8px;">
						Le membre de la communauté Zach Elko étale une liste de dix fonctionnalités indispensables de Netbeans IDE et l'illustre avec un superbe projet C++.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2332">Bonne idée: Java et Groovy avec NetBeans 6.5 jalon 1</a></h2>
						<p style="margin-left:8px;">
						Ce blog décrit les bénéfices de l'utilisation de Netbeans IDE pour mixer Groovy et Java, un processus complètement intuitif et sans aucun souci sur l'élaboration des scripts et le management de librairie.</p>
					</div>
				<h1>Communauté</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2339">Créer une communauté  NetBeans Docs</a></h2>
						<p style="margin-left:8px;">
						Dans cet article, le Directeur de NetBeans Community Docs  James Branam écrit sur le lancement du programme community docs, ses members et leurs récentes réalisations, et ce qu'il prévoit faire à l'avenir.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2340">Ibon Urrutia - crée des applications mobiles  avec TagsMe, aucune connaissance de Java n'est requise</a></h2>
						<p style="margin-left:8px;">
						TagsME est une plateforme de dévéloppement d'application pour téléphone portable. L'éditeur graphique de TagsMe, crée avec la plateforme NetBeans par Ibon Urrutia  un dévéloppeur java et membre de la "Dream Team", ne demande aucune connaissance de Java pour commencer par créer des applications mobiles.</p>
					</div>
				<h1>Nouvelles de projet</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2330">Aidez à tester l'importateur de projet  Eclipse pour NetBeans 6.5 jalon 1</a></h2>
						<p style="margin-left:8px;">
						Suite à plusieurs demandes, l'importateur de projet Eclipse a été amélioré et fait partie maintenant de la distribution standard dans  l' EDI NetBeans 6.5 jalon 1. Si vous travaillez dans une équipe qui utilise deux IDE et si vous avez des collègues qui utilisent Eclipse, nous vous encourageons à essayer d'importer des projets eclipse. Vous pouvez faire part de vos remarques de la manière suivante:
<ul>
<a href="https://netbeans.org/community/issues.html">Reporter un problème</a> avec IZ en selectionnant le composant 'ide' puis le sous-composant 'eclipse project import'.<br>Ou écrire à <a href="https://netbeans.org/community/lists/top.html#top">nbusers alias</a> avec "Eclipse Project Importer" comme sujet.</ul></p>
					</div>
				<h1>Formation</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2331">NetBeans comme EDI de developpement avec Mysql</a></h2>
						<p style="margin-left:8px;">
						Kaj Arno, Veep de la communauté Mysql, publie sur les avantages de l'utilisation de Netbeans IDE pour apprendre Mysql et coder sous Mysql.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2333">Groovy dans NetBeans - Renommage surplace</a></h2>
						<p style="margin-left:8px;">
						Le blog de Martin Adamek est un excellent endroit pour en savoir plus sur les mises à jour du support Groovy pour Netbeans IDE 6.5.
Dans cette entrée de blog ( et un peu plus à venir) il donne un resumé des fonctionnalités interessantes disponibles dans l'EDI.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2335">Installer & Configurer le support de Ruby dans l'EDI NetBeans</a></h2>
						<p style="margin-left:8px;">
						Apprennez à télécharger, installer et configurer le support de Ruby pour l'EDI NetBeans 6.1 .</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2336">Créer & Consommer  un  Web Service RESTful avec des composants jMaki</a></h2>
						<p style="margin-left:8px;">
						Vous pouvez réutiliser un client RESTful stubs dans plusieurs applications web en enveloppant le stub dans un composant jMaki, aussi appelé widget jMaki. Ce tutoriel vous montre comment créer et consommer un composant jMaki créée à partir de projets Web services RESTful dans l'EDI de NetBeans.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2338">Formes, Liaison et Animation dans JavaFX et NetBeans</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1515&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;'/>
						JavaFX rend le travail avec les graphiques et les animations vraiment faciles. Grâce au nouveau plugin NetBeans, vous pouvez créer des graphiques interactivement. Dans cette petite démonstration de Josh Marinacci, apprennez les bases de la création des formes et de la liaison à des variables, ainsi qu'à concevoir une simple animation de rollover.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2337">Quel est votre signe? - Introduction au JavaServer Faces Framework</a></h2>
						<p style="margin-left:8px;">
						Ce tutoriel, le premier de la serie, démontre les fondamentaux de l'utilisation de  JavaServer Faces (JSF) framework pour coder les applications web dans l'EDI NetBeans. Vous créez une application web nommée jAstrologer qui prend le nom de l'utilisateur et sa date de naissance et lui retourne des informations comme le signe du zodiaque de l'utilisateur, sa pierre porte-bonheur et son horoscope.</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-07-24_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>