
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 3</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 # 3 - Jul 01, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2206">Fournir le support RichFaces pour l'EDI Netbeans</a></h2>
						<p style="margin-left:8px;">
						<p style="margin-left: 8px;">
					
Wouter vab Reeven relate une visite de Geertjan Wielenga et ses premières contributions pour
<a href="http://nbrichfacessupport.dev.java.net/"> le projet NetBeans RichFaces Support</a>.</p></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2207">Build traduit de la plateforme NetBeans 6.1</a></h2>
						<p style="margin-left:8px;">
						<p style="margin-left: 8px;">
Masaki Katakai fournit les étapes pour la compilation des fichiers jar traduits de la plateforme Netbeans pour votre environnement de développement.
</p></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2208">Ubuntu, PHP, NetBeans - Partie I</a></h2>
						<p style="margin-left:8px;">
						<p style="margin-left: 8px;">
Petr Pisl de l'équipe Netbeans PHP démontre le processus d'installation de l'environnement  PHP sur Ubuntu 8.04.
</p></p>
					</div>
				<h1>Communauté</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2204">Attirer les Philippines vers la plateforme NetBeans</a></h2>
						<p style="margin-left:8px;">
						<p style="margin-left: 8px;">
Des instructeurs de part toutes les Philippines ont participé en deux jours à la session de formation certifiante sur la plateforme Netbeans de juin. Ils ont appris tout sur la plateforme Netbeans, couvert les principaux concepts, ainsi que participer aux différents exerices pratiques. En tant qu'instructeurs eux-mêmes, ils vont transmettre leur savoir aux autres étudiants !</p></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2205">Recap des évènements : NetBeans Deep Dive à  Manille, Philippines</a></h2>
						<p style="margin-left:8px;">
						<p style="margin-left: 8px;">
680 personnes ont assisté à la récente session Netbeans Deep Dive à Manille. Sang Shin, Tim Boudreau et Geertjan Wielenga ont fait découvrir à l'audience les fonctionnalités les plus intéressantes de la 6.1, et ont mis en avant le fait que l'EDI Netbeans est le meilleur instrument pour de développement web et des applications bureau.
</p></p>
					</div>
				<h1>Nouvelles de projet</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2212">Joindre NetCAT & aidez à faire de NetBeans 6.5 un roc!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1386&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='83' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						<p style="margin-left: 8px;">
Aimez-vous la qualité de Netbeans et voudriez-vous la garder pour les futurs utilisateurs ? Ou bien pensez-vous que l'EDI Netbeans a encore des défauts à éliminer ? Quelque soit votre motivation vous pouvez donner plus à votre EDI favorit en testant la prochaine version de Netbeans 6.5. Si vous avez au moins deux heures de temps libres par semaine entre Juillet et Août, inscrivez vous pour NetCat 6.5!</p></p><br style="clear:both;"/>
					</div>
				<h1>Formation</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2209">Les fonctionnalités d'Editeur JavaScript dans l'EDI NetBeans</a></h2>
						<p style="margin-left:8px;">
						<p style="margin-left: 8px;">
L'EDI NetBeans 6.1 fournit les fonctionnalités d'un éditeur avancées de code JavaScript qui est conçu pour supporter déja Java, Ruby et les autres langages. Ce guide donne une vue d'ensemble des fonctionnalités comme la coloration syntaxique, les marques d'occurrence,le renommage instantané, le refactoring et bien plus encore.</p></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2210">Créer des rapports avec iReport de JasperSoft</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1388&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;'/>
						<p style="margin-left: 8px;">
Giulio Toffoli, Architecte et foundateur du projet iReport,  vous montre à travers une démonstration comment créer un rapport en utilisant l'EDI Netbeans et le plugin iReport. Guilio a aussi récemment decidé de migrer le projet iReport sur la plateforme Netbeans. Ecoutez son avis sur le sujet et pourquoi Netbeans était le meilleur choix.</p></p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2211">Guide d'installation de la plateforme d'émulation Netbeans CDC</a></h2>
						<p style="margin-left:8px;">
						<p style="margin-left: 8px;">
NetBeans Mobility supporte le développement JavaME CDC, mais il manque la plateforme CDC intégrée. 
Voir les étapes pour télécharger, installer le kit de développement pour CDC et les autres kits populaires de développement pour CDC
</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_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-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>