
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 11</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 # 11 - Aug 28, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2557">Le Top 10  des fonctionnalités de la plateforme Netbeans 6.5</a></h2>
						<p style="margin-left:8px;">
						Geertjan Wielanga vous donne un aperçu du Top 10 des fonctionnalités de la plateforme Netbeans 6.5. La plateforme est l'infrastructure qui sous-tend Netbeans ainsi qu'un large éventail d'autres applications Swing modulaires, par conséquent cette entrée de blog n'est pas uniquement dédiée à l'EDI Netbeans.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2556">Premier pas avec Prado dans l'EDI Netbeans</a></h2>
						<p style="margin-left:8px;">
						PRADO (PHP Rapid Application Development, Object-oriented) est une structure de programmation évènementielle et basée composant pour le développement d'applications Web dans PHP 5. Lire plus sur comment Pisl crée une application Hello World basée sur la structure Prado dans Netbeans.</p>
					</div>
				<h1>Livres</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2558">Jaroslav Tulach et la conception pratique d'API</a></h2>
						<p style="margin-left:8px;">
						L'architecte en chef de l'API Jaroslav "Yarda" Tulach présente son nouveau livre et partage quelques aperçus concernant la conception d'API. Où pouvez-vous apprendre plus ? Vous pouvez avoir le premier chapitre, The Art of Building Modern Software (l'Art de construire un logiciel moderne) gratuit chez APress! Aussi, dans chaque épisode à venir dans le flux radio mensuel de Netbeans, Yarda partagera avec vous une nouvelle astuce pour construire un API.</p>
					</div>
				<h1>Communauté</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2559">Il choisit une communauté pour écrire un excellent logiciel</a></h2>
						<p style="margin-left:8px;">
						Le Dream Team, test de qualité, vérification de plug-in, modération de liste de diffusion - Comment les membres de la communauté et les ingénieurs de Netbeans peuvent-ils travailler ensemble et qu'est-ce que cela peut vous apporter?</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2561">Première version du programme de Documentation de la Communauté: 200 tutoriels</a></h2>
						<p style="margin-left:8px;">
						Le programme de Documentation de la Communauté a attiré plus de 80 enthousiastes de Netbeans pour fournir plus de 200 tutoriels, capture vidéos et autres matériels d'apprentissage écrits par la communauté pour la communauté. Ecouter les acteur de cette initiative s'exprimer à ce propos et comprendre comment tout ceci a commencé.</p>
					</div>
				<h1>Nouvelles de projet</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2560">Instructeur Java Russe ?</a></h2>
						<p style="margin-left:8px;">
						Êtes-vous un instructeur Java Russe ? Andrei Dmitriev a confectionné plusieurs diapositives disponibles pour qui veut enseigner Java (et Netbeans) en Russe. A les utiliser pendant les cours avec vos étudiants!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2562">La transcription</a></h2>
						<p style="margin-left:8px;">
						Que fait le mot-clé "tween" ? Pourquoi les concepteurs JavaFX préfèrent-ils l'héritage multiple aux interfaces ? Pouvez-vous combiner Swing et les composants graphiques dans JavaFX ? Lisez des réponses à ceux-ci et une large variété d'autres questions dans la transcription de cette récente session "Des questions aux experts" sur JavaFX Preview.</p>
					</div>
				<h1>Formation</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2553">Démo d'Hibernate pour Netbeans 6.1 et 6.5</a></h2>
						<p style="margin-left:8px;">
						Jeter un coup d'œil sur le support Hibernate de Netbeans dans cette séquence de vidéo. Nous commençons par la création de POJOs, le mappage de POJOs à la base de données en utilisant les fichiers de mappage, en affichant alors les données dans une application web JSF créée avec Visual Web Designer.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2554">Hello JavaServer Faces World avec Netbeans et GlassFish</a></h2>
						<p style="margin-left:8px;">
						Dans ce blog Arun Gupta montre comment créer une simple application Java Server Faces en utilisant Netbeans 6.1. Il couvre la création d'une application JSF, le peuplement d'un widget JSF avec un Managed Bean utilisant une unité de persistance avec les widgets JSF, les règles de navigation entre les pages multiples, les messages simples de validation d'erreur et l'injection de bean dans une autre classe.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2555">Astuce technique pour Netbeans 6.5 : Compiler et enregistrer</a></h2>
						<p style="margin-left:8px;">
						Cette séquence vidéo démontre la fonctionnalité "Compiler à l'enregistrement" qui a été introduite dans Netbeans 6.5. Gagner du temps en faisant des modifications incrémentielles pour votre application et faire une exécution-test de ces modifications sans reconstruire et redéployer toute l'application.</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-08-28_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>