<HTML>

<HEAD>
<TITLE>Listes de diffusion et forums</title>
<META NAME="description" CONTENT="Listes de diffusion et forums NetBeans&nbsp;: abonnement, d&eacute;sabonnement, acc&egrave;s aux archives">
<meta http-equiv="content-language" CONTENT="fr">
<META HTTP-EQUIV="content-type" CONTENT="text/html; charset=UTF-8">
<link rel="stylesheet" type="text/css" HREF="../../netbeans.css">
</HEAD>


<body>
<h1>Listes de diffusion NetBeans</h1>

<p>Aide sur l'EDI, discussions entre d&eacute;veloppeurs au sujet des fonctionnalit&eacute;s des prochaines versions, 
les listes de diffusions sont con&ccedil;ues pour r&eacute;pondre &agrave; toutes vos attentes.  
Pour plus d'informations sur l'abonnement, le d&eacute;sabonnement, l'acc&egrave;s aux archives ou les diff&eacute;rentes 
listes de diffusion, cliquez sur les liens ci-dessous.


<div style="float:left;margin-right:10px">
<a href="#which">Quelles sont les autres listes susceptibles de m'int&eacute;resser&nbsp;?</a><BR>
<a href="#subandunsub">Abonnement et D&eacute;sabonnement d'une liste de distribution</a><BR>
<a href="#etiquette">D&eacute;ontologie sur les listes</a><BR>
</div>
<div style="float:left;margin-right:10px">
<a href="#forums">Forums et groupes de discussion</a><BR>
<a href="#trouble">D&eacute;pannage</a><BR>
<a href="http://wiki.netbeans.org/NetBeansUserFAQ#section-NetBeansUserFAQ-MailingLists">FAQs (en anglais)</a><BR>
</div>
<p><br clear="all"></p>

<a name="which"><h2>Quelles sont les autres listes susceptibles de m'int&eacute;resser&nbsp;?</h2></a>

<h3 class="tips">Nouveaux venus</h3>
<p>
    Pour obtenir de l'aide concernant l'utilisation de l'EDI NetBeans, 
    vous devez au minimum vous abonner aux principales <a href="top.html#top">listes d'utilisateurs et d'int&eacute;r&ecirc;t 
    g&eacute;n&eacute;ral</a>&nbsp;: <b>nbannounce</b> et <b>nbusers</b>.
</p>
<UL>
  <li>Si vous souhaitez d&eacute;velopper des applications NetBeans, abonnez-vous aux listes <b>nbdev</b> et <b>dev@openide</b>. Vous pouvez &eacute;galement vous abonner &agrave; d'autres <a href="top.html#dev">listes de d&eacute;veloppement</a>.  Si vous &ecirc;tes un d&eacute;veloppeur confirm&eacute;, vous pouvez &eacute;galement vous abonner aux <a href="other.html">listes du processus de g&eacute;n&eacute;ration</a>.
  </li>

  <li>Si vous d&eacute;veloppez des applications associ&eacute;es &agrave; une interface utilisateur ou si vous vous int&eacute;ressez aux questions de convivialit&eacute;, abonnez-vous &agrave; la <a href="top.html#dev">liste de convivialit&eacute;</a>, <b>nbui</b>.
  </li>

  <li>Des <b>listes sp&eacute;cifiques aux modules</b> sont &eacute;galement disponibles. Ces listes traitent d'un module ou d'un projet NetBeans en particulier. Elles sont g&eacute;n&eacute;ralement plus restreintes et beaucoup plus sp&eacute;cialis&eacute;es.  Il est recommand&eacute; de demander l'avis pr&eacute;alable des autres d&eacute;veloppeurs sur la liste <a href="top.html#dev">nbdev</a> si vous souhaitez vous sp&eacute;cialiser sur un module sp&eacute;cifique.
  </li>

  <li>Les membres de la communaut&eacute; peuvent &eacute;galement acc&eacute;der &agrave; des listes traitant des offres d'emploi li&eacute;es &agrave; NetBeans, du site Web netbeans.org et des NetBeans Evangelists. Pour plus d'informations, consultez les <a href="top.html#community">listes de la communaut&eacute;</a>.
  </li>

  <li>Vous pouvez &eacute;galement contacter des d&eacute;veloppeurs Java fran&ccedil;ais, russes, japonais ou chinois. Pour plus d'informations, consultez les <a href="top.html#localised">listes class&eacute;es par langue</a>.
  </li>

  <li>
    Pour plus d'informations sur les sites sp&eacute;cialis&eacute;s dans les discussions sur les licences, consultez la <a href="../../about/legal/license.html">page de licence</a>.
  </li>

</UL>

<P><a name="subandunsub"><h2>Abonnement et D&eacute;sabonnement d'une liste de diffusion</h2>

<h3>S'abonner</h3>
Suivez le lien vers la pages des <a href="top.html">principales listes de diffusion(en anglais)</a> et cliquez sur le button 
"Subscribe" (s'abonner)
<h3>Se d&eacute;sabonner</h3>
Suivez le lien vers la pages des <a href="top.html">principales listes de diffusion(en anglais)</a> et cliquez sur le button 
"Unsuscribe" (se d&eacute;sabonner). Chacune des pages de liste contient un lien de d&eacute;sabonnement, en regard du lien d'abonnement.
<h3><a name="trouble"> Si vous ne parvenez pas &agrave; vous d&eacute;sabonner&nbsp;:</h3>
<ol>
<li><b>N'envoyez pas de message de d&eacute;sabonnement ou de message d'aide sur la liste dont vous souhaitez vous d&eacute;sabonner.</b>
<li>Pour obtenir de l'aide, consultez la page de <a href="http://wiki.netbeans.org/wiki/view/NetBeansUserFAQ#section-NetBeansUserFAQ-MailingLists">FAQ sur les listes de distribution</a> ou la page d&eacute;crivant la <a href="unsubscribe.html">proc&eacute;dure de d&eacute;sabonnement</a>.
<li>Si vous ne parvenez toujours pas &agrave; vous d&eacute;sabonner, contactez le propri&eacute;taire de la liste. Pour plus d'informations, reportez-vous &agrave; la page de <a href="http://wiki.netbeans.org/wiki/view/NetBeansUserFAQ#section-NetBeansUserFAQ-MailingLists">FAQ</a>.
</ol>

<P><h2><a name="etiquette">D&eacute;ontologie sur les listes</a></h2>

<p>Tous les membres sont invit&eacute;s &agrave; apporter leur contribution. Toutefois, les listes principales &eacute;tant 
tr&egrave;s fr&eacute;quent&eacute;es, la pertinence et la formulation des messages se r&eacute;v&egrave;lent des facteurs 
d'int&eacute;gration d&eacute;terminants.  <I>Merci</I> de vous conformer aux r&egrave;gles de conduite &eacute;l&eacute;mentaires 
lors de l'envoi de vos messages.  Quelques conseils&nbsp;:

<UL>
<LI>N'envoyez pas le m&ecirc;me message sur plusieurs listes&nbsp;; choisissez la liste ad&eacute;quate, puis envoyez votre message.
Si vous n'avez pas fait le bon choix, les membres vous en avertiront et vous indiqueront une autre liste.

<LI>Pour commencer une discussion, envoyez un message. Lorsque vous r&eacute;pondez &agrave; un message, ne changez pas son objet, 
car votre r&eacute;ponse serait redirig&eacute;e au mauvais endroit par le programme de visualisation de messages de listes de 
diffusion.

<LI>Consultez le guide r&eacute;dig&eacute; par Eric Raymond &nbsp;: <a href="http://www.catb.org/~esr/faqs/smart-questions.html">
    De la bonne mani&egrave;re de poser les questions</a>.

<LI>R&eacute;duisez la quantit&eacute; de texte cit&eacute; dans vos r&eacute;ponses.  Essayez d'inclure uniquement le passage sur 
lequel porte votre r&eacute;ponse.  L'envoi d'une r&eacute;ponse suivie de l'int&eacute;gralit&eacute; du message d'origine est une 
pratique &agrave; proscrire.

<LI>De m&ecirc;me, si vous r&eacute;pondez point par point &agrave; un message en incluant plusieurs passages du texte d'origine 
suivis &agrave; chaque fois de votre r&eacute;ponse, veillez &agrave; ce que ces r&eacute;ponses soient clairement identifiables.
Si vous incorporez 40&nbsp;lignes du texte d'origine suivies d'une r&eacute;ponse d'une seule ligne, puis d'un autre passage de 
40&nbsp;lignes du texte d'origine, il devient tr&egrave;s difficile d'identifier votre r&eacute;ponse.  Si vous devez incorporer 
une citation de 40&nbsp;lignes, vous pouvez par exemple passer une ligne avant de r&eacute;diger votre r&eacute;ponse. Vous pouvez 
ensuite passer deux autres lignes avant d'ins&eacute;rer une autre citation.

<LI>N'utilisez pas de mise en forme pour vos messages. La police, la taille, la couleur et autres mises en forme du texte risquent 
de nuire compl&egrave;tement &agrave; la lisibilit&eacute; de vos messages.  Dans la mesure du possible, utilisez du texte brut.  
Lorsque aucun style n'est appliqu&eacute; au texte, la mise en forme est g&eacute;r&eacute;e par les programmes de visualisation de 
messages de listes de diffusion utilis&eacute;s par chacun des membres, garantissant ainsi son aspect et sa lisibilit&eacute;.

<LI>De m&ecirc;me, n'envoyez pas de pages HTML.  Cette consigne vise notamment &agrave; garantir la lisibilit&eacute;, la taille et 
la s&eacute;curit&eacute; des messages.  Pour plus d'informations sur ce type de probl&egrave;me et sur les autres probl&egrave;mes
li&eacute;s &agrave; l'utilisation des pages HTML, ainsi que des instructions sur la d&eacute;sactivation de ce format d'e-mail sur 
la plupart des clients de messagerie, consultez la page <A HREF="http://kb.mozillazine.org/Plain_text_e-mail_%28Thunderbird%29">http://kb.mozillazine.org/Plain_text_e-mail_%28Thunderbird%29</A>.

<P>L'envoi de pages HTML sous forme de <I>pi&egrave;ce jointe</I> est en revanche tout &agrave; fait acceptable.

</UL>

<h4>Remarque concernant les filtres de messagerie</h4>
<p>
Certaines listes &eacute;tant tr&egrave;s fr&eacute;quent&eacute;es, certaines conventions ont &eacute;t&eacute; adopt&eacute;es 
afin de faciliter le tri et le filtrage des donn&eacute;es.  Le logiciel de liste de diffusion ajoute automatiquement un 
pr&eacute;fixe compos&eacute; du nom de la liste de diffusion aux champs d'objet des listes NetBeans. Par exemple, l'objet des
messages envoy&eacute;s sur la liste nbdev est syst&eacute;matiquement pr&eacute;c&eacute;d&eacute; de la cha&icirc;ne <B>[nbdev]</B>.
Il est &eacute;galement fr&eacute;quent de voir appara&icirc;tre un libell&eacute; (par exemple, [Stable3.1 Release]) dans le champ d'objet. Ce libell&eacute; est ajout&eacute; par certains abonn&eacute;s afin d'indiquer les sujets connexes.  Ce type de convention est bien &eacute;videmment laiss&eacute; &agrave; l'appr&eacute;ciation de chacun.
</p>
<a name="forums"><h2>Forums et groupes de discussion</h2></a>

<h3>Acc&egrave;s aux forums</h3>

<p>Pour les membres pr&eacute;f&eacute;rant les forums de discussion aux listes de diffusion, tous les messages des listes de 
diffusion NetBeans sont archiv&eacute;s sur un forum enti&egrave;rement fonctionnel. Archiv&eacute;s sous la forme d'e-mails 
accessibles dans les pages de recherche et de consultation, les messages envoy&eacute;s sur les listes de diffusion sont 
automatiquement publi&eacute;s sur les forums et vice versa.</p>

<ol>    
<h3><li>Forum.NetBeans.org</h3>
<p>Nous recommendons le site officiel des forums, <a href="http://forums.netbeans.org/">NetBeans Community Forums</a>,
qui en synchronisation avec les listes des diffusion de NetBeans les plus utilisées.
<p><b>Remarque:</b> Votre mot de passe de <a href="http://forums.netbeans.org/topic1180.html">netbeans.org 
ne fonctionnera pour </a> les forums des communauté de NetBeans. 
<a href="http://forums.netbeans.org/profile.php?mode=register">Enregistrez-vous ici</a> afin de pouvoir poster une entrée sur forum.netbeans.org.
</p>
</li>

<h3><li>Forums NetBeans sur Nabble.com</h3>

<p>Nabble.com aussi héberge <a href="http://www.nabble.com/Netbeans.org-f2602.html">plusieurs Forums NetBeans </a>
  qui sont en synchronization avec nos listes de diffusions.</p>
  <p>Vous devez vous <a href="http://www.nabble.com/user/Register.jtp">inscrire sur Nabble</a> pour utiliser ce service. 
  Les messages envoy&eacute;s sur le forum sont surveill&eacute;s, sauf si vous &ecirc;tes connect&eacute;s &agrave; la liste des 
  non-abonn&eacute;s autoris&eacute;s &agrave; envoyer des messages. Pour d&eacute;sactiver la surveillance de vos messages et 
  faciliter la t&acirc;che des mod&eacute;rateurs, effectuez une demande aupr&egrave;s du propri&eacute;taire de la liste.
<P><B>Remarque&nbsp;:</B>L'h&eacute;bergement des forums est g&eacute;r&eacute; par l'interm&eacute;diaire du service d'h&eacute;bergement gratuit de 
forums publics <a href="http://www.nabble.com/">Nabble</a>.

<h3><li>Acc&egrave;s &agrave; Usenet / NNTP</h3>

<p>
Pour les utilisateurs pr&eacute;f&eacute;rant le syst&egrave;me USENET aux listes de diffusion, les principales listes sont 
reli&eacute;es aux articles du r&eacute;seau&nbsp;: les messages envoy&eacute;s sont automatiquement publi&eacute;s sur les 
groupes de discussion et vice versa.  Entrez l'adresse <A HREF="news://news.gmane.org/">news.gmane.org</A> dans votre lecteur de 
nouvelles.</p>
<p>
En raisons des conventions Gmane, les noms des groupes ne correspondent pas exactement aux noms des listes de diffusion.
Ils sont toutefois tr&egrave;s similaires.  Recherchez les groupes &quot;netbeans&quot; &agrave; l'aide de votre client 
(par exemple, <code>gmane.comp.java.ide.netbeans.users</code>).</p>
<p>
Pour envoyer un message sur les listes via NNTP, vous devez r&eacute;pondre &agrave; la demande d'autorisation envoy&eacute;e 
par GMane.  Les messages envoy&eacute;s via NNTP sont surveill&eacute;s, sauf si vous &ecirc;tes connect&eacute;s &agrave; la liste
des non-abonn&eacute;s autoris&eacute;s &agrave; envoyer des messages. Pour d&eacute;sactiver la surveillance de vos messages et 
faciliter la t&acirc;che des mod&eacute;rateurs, effectuez une demande aupr&egrave;s du propri&eacute;taire de la liste.

<P><B>Remarque&nbsp;:</B>La gestion des listes de distribution s'effectue par l'interm&eacute;diaire de la passerelle NNTP gratuite
<A HREF="http://www.gmane.org/">Gmane</A>.

</ol>

<P><BR></BODY>

</HTML>
