
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 1</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 # 1 - Jun 20, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Articles</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2129">Avoir vos plugins dans le gestionnaire de plugins de Netbeans</a></h2>
						<p style="margin-left:8px;">
						<p style="margin-left:8px;">
						Avez-vous peut être des plugins sur le portail de plugin pour Netbeans. Saviez-vous qu'il est maintenant possible de les avoir automatiquement dans le manager de plugin de l'EDI Netbeans ? Premièrement, vous devrez avoir des plugins vérifiés comme expliqué sur une entrée sur ce blog par Geertjan Wielenga.</p></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2131">Vérifier les projets sur Java.net en utilisant NetBeans</a></h2>
						<p style="margin-left:8px;">
						<p style="margin-left:8px;">
Ce tutorial fournit un guide visual pour l'utilisation de CVS dans Netbeans pour la vérification des projets hébergés sur Java.net.
</p></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2134">Gestionnaire de base de données Epictetus (Construit à l'aide de la plateforme NetBeans)</a></h2>
						<p style="margin-left:8px;">
						<p style="margin-left:8px;">
						Konstantin Chikarev est interviewé sur Javalobby au sujet du nouveau gestionnaire de base de données qui a été développé à Moscou. 
						Apprenez pourquoi Chikarev choisit la plateforme Netbeans et pourquoi Epictetus a été crée.
						</p></p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2128">Nouveau Blog: NetBeans pour PHP</a></h2>
						<p style="margin-left:8px;">
						<p style="margin-left:8px;">
						L'équipe à l'origine du développement du support de PHP dans l'EDI Netbeans a créé un nouveau blog. 
						Suivez le progrès de leur travail sur les fonctionnalités pour Netbeans 6.5. Et utilisez ce blog pour fournir des retours d'informations.</p></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2130">Utilisation de Beans Binding pour rechercher dans une table</a></h2>
						<p style="margin-left:8px;">
						</a></h2>
						<p style="margin-left:8px;">
						Le rédacteur technique de Netbeans Patrick Keegan est prolifique sur blog au sujet de beans binding (JSR-295). Dans cette entrée, il explique comment vous pouvez rechercher des enregistrements dans une base de données pour une application bureau en utilisant les mécanismes qui existe dans Swing et dans la librairie Beans Binding.
                        </p></p>
					</div>
				<h1>Calendrier</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2138">NetBeans worldTour à  Jazoon 08 (23 juin, Zurich)</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1305&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='60' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						<p style="margin-left:8px;">
                
Rendez-vous à Jazoon  pour avoir la chance de voir les nouveautés de Netbeans. Les membres de l'équipe Netbeans vont démontrer comment Netbeans supporte les langages de scripting en vogue, contruit les Applications Rich Internet et les applications pour		les téléphones mobiles et les PDAs, et comment reutiliser un code existant à partir de la plateforme Netbeans pour créer rapidement vos propres applications bureau. Inscrivez-vous dès aujourd'hui pour Jazoon 08 afin d'être en connectés aux	 autres membres de la communauté,intérargir avec l'équipe Netbeans, rencontrer les éclairés de Java et se faire des amis!
</p>
<br style="clear:both;"/></p><br style="clear:both;"/>
					</div>
				<h1>Communauté</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2135">Les 80 lauréats  de Java EE Programming (with Passion!)</a></h2>
						<p style="margin-left:8px;">
						<p style="margin-left:8px;">
						Félicitations pour les 80 lauréats du cours en ligne  "Java EE Programming (with Passion!)" de Sang Shin qui a pris fin en mai. Ces lauréats sont les apprenants qui ont soumis tous les 22 devoirs durant le cours. Ici sont quelques uns de ce que les nouveaux programmeurs J2EE ont dit au sujet du cours qui est maintenant à son 13ème cycle:<br><br>
<i>"Ce cours est une grande et utile initiative !! J'ai appris beaucoup sur les fondamentaux de J2ee, 
excellent pour les débutants." - Maciek Opala, Pologne</i><br><br>
<i>"Encore, merci beaucoup pour avoir offert ce programme.Ca été un excellent programme de cours, avec de véritables 
défiantes et intéressantes leçons. Il est certain que vous mettez beaucoup de labeur pour cela. Merci beaucoup ce service que tu offres!" - LB Corney, USA</i></p></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2136">Varun Nischal - Recherches les blogs contenant des tutoriaux très intéressants sur NetBeans</a></h2>
						<p style="margin-left:8px;">
						<p style="margin-left:8px;">
Récemment, nous avions annoncé que le programme de documentations de la Communauté Netbeans avait eu un nouveau coordonnateur. Lire plus sur Varun Nischal, comment il contribue à la communauté et pourquoi les grandes entrées de blog sur Netbeans le rendent heureux. Et si vous avez une quelconque entrée de blog interessant sur Netbeans il faut s'attendre à entendre Varun!
</p></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2137">Nouvelle équipe dirigeante de Netbeans élue</a></h2>
						<p style="margin-left:8px;">
						<p style="margin-left:8px;">
Les membres de Netbeans Dream Team Wade Chandler et Tom Wheeler ont été élus pour un second mandat à la gouvernance de Netbeans ! Le troisième membre et le nominé de Sun Microsystems à la gouvernance seront annoncés très prochainement. Félicitations à Wade et Tom et à tous nos autres braves nominés!
</p></p>
					</div>
				<h1>Formation</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2132">Améliorations du débogueur dans l'EDI NetBeans</a></h2>
						<p style="margin-left:8px;">
						<p style="margin-left:8px;">
						Expression Stepping et Heap Walking sont les deux majeures améliorations dans l'EDI Netbeans.
						Ce document offre un bref résumé de la façon dont ses fonctions pourraient servir pour le débogage des projets.						
						</p></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2133">Visite guidée de ClearCase pour Netbeans IDE 6.1</a></h2>
						<p style="margin-left:8px;">
						<p style="margin-left:8px;">
						Avec Netbeans IDE 6.1 vous pouvez maintenant améliorer les tâches de versioning  en utilisant Rational ClearCase.
                        Acquerir les étapes de base à l'utilisation de ClearCase dans l'EDI Netb4eans et une introduction à quelques éléments des nouvelles fonctionnalités 
                        incluses dans l'EDI depuis la version 6.0.
					</p></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_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-06-20_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>