
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 25</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 # 25 - Jan 21, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Nouvelles de projet</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3202">NetBeans remporte le prix Produit 2009 de Developer.com !</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2408&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='74' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						NetBeans est en selle pour l'année 2009 avec CINQ victoires dans le prix Produit 2009 de Developper.com ! Netbeans a reçu le plus de voix pour ravir la plus haute marche dans ces catégories: <b> Outils Java, outils Open Source, Plateforme de développement, utilitaires de développement et  les outils sans fil/Mobile</b>.<br><br>Un grand "Merci"  à la communauté et aux supporteurs de Netbeans pour leur soutien !</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3201">Portal Pack 3.0 Beta maintenant disponible</a></h2>
						<p style="margin-left:8px;">
						Les binaires de Portal Pack 3.0 Beta sont maintenant disponibles en téléchargement. Cette version est dépourvue de la plupart des bogues,les améliorations dans le déploiement de répertoire et le support de débogage pour Liferay Portal Server s'exécutant sur Tomcat.Les serveurs de portail suivants sont maintenant supportés :
<ul>
<li>Projet WebSynergy
<li>Liferay Portal Server 5.1.x et antérieur
<li>Sun Java System Portal Server 7.1/7.2
<li>Conteneur de Portlet OpenPortal 
</ul></p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3194">PHPUnit  dans l'EDI NetBeans</a></h2>
						<p style="margin-left:8px;">
						Le support PHPUnit est presque achevé dans l'EDI Netbeans. Cette entrée de  blog de l'équipe PHP montre aux utilisateurs comment lancer le test de leurs sources PHP.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3195">Convertisseur de température Python dans Netbeans Python EA</a></h2>
						<p style="margin-left:8px;">
						Le rédacteur technique NetBeans James Branam a exploré le support Early Access Python dans l'EDI NetBeans. Une récente vague de froid à Prague a été source d'inspiration pour un nouveau tutorial: comment développer une application Python simple qui convertit les lectures de température.</p>
					</div>
				<h1>Calendrier</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3200">S'inscrire pour un webinaire : MySQL, NetBeans & Rails ( 27 janvier )</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2410&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='66' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Apprendre à combiner l'EDI Netbeans et le framework Ruby-on-Rails pour déployer les applications basées sur MySQL sur GlassFish dans un webinaire gratuit et en live le mardi 27 janvier.<br><br>
Contenu: <b> Développer des applications basées MySQL avec Netbeans et JRuby-on-Rails</b><br><br>
Horaire: <b>10:00 am PDT, 1:00 pm EDT, 18:00 GMT</b> <i>(La présentation prendra approximativement 45 minutes suivie de question/Réponse.)</i></ul></p><br style="clear:both;"/>
					</div>
				<h1>Formation</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3196">Créer, importer et configurer les projets Java</a></h2>
						<p style="margin-left:8px;">
						Apprendre à configurer les projets Java standard et web Java dans l'EDI Netbeans. Ce tutoriel couvre également la configuration du JDK, le classpath et les sous-projets; activation/désactivation incrémentale de la compilation, le partage des librairies de projet, la personalisation du script de contruction et la mise en place des configurations de l'exécution.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3197">Séquences vidéo : Comment organiser les projets dans l'EDI Netbeans</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2413&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;'/>
						Travailler sur plusieurs projets en même temps sur l'EDI Netbeans et le besoin de connaitre comment naviguer entre des groupes ? Cette rapide( et silencieuse) démonstration de Lukas Hasik vous montre comment organiser les projets et mouvoir facilement entre eux.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3198">Créer une application Ajax avec Script.aculo.us</a></h2>
						<p style="margin-left:8px;">
						Le tutorial montre comment utiliser la librairie JavaScript script.aculo.us pour créer une application Ajax dans l'EDI Netbeans 6.5.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3199">Améliorer ses compétences en programmation JavaFX (Avec Passion!)</a></h2>
						<p style="margin-left:8px;">
						S'inscrire pour la première session du nouveau cours JavaPassion : 15 semaines de programmation JavaFX. Le cours en ligne gratuit commence le 30 janvier. Pour s'inscrire, simplement envoyer un mel vide à : <i>javafxprogramming-subscribe@googlegroups.com</i></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> | <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-01-21_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>