<HTML>

<HEAD>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">

<TITLE>Mailing list e forum</title>
<META NAME="description" CONTENT="Mailing list e forum di NetBeans, come iscriversi, annullare l'iscrizione e sfogliare gli archivi">
<meta http-equiv="content-language" CONTENT="it">
<link rel="stylesheet" type="text/css" HREF="../../netbeans.css">
</HEAD>

<body>
<h1>Mailing list di NetBeans</h1>

<p>Le mailing list rappresentano il riferimento principale sia per gli utenti che cercano assistenza per l'utilizzo dell'ambiente di sviluppo integrato (IDE) sia per gli sviluppatori che desiderano discutere le caratteristiche della nuova versione.  Per iscriverti, annullare l'iscrizione, sfogliare gli archivi e ottenere informazioni sulle singole mailing list, fai clic sul link corrispondente tra quelli riportati di seguito.

<p><h3>Primi passi per i nuovi utenti</h3>

<UL>
<LI><p>
    Se desideri ottenere assistenza per l'utilizzo di NetBeans IDE, ti consigliamo di iscriverti almeno a <b>nbannounce</b> e <b>nbusers</b>, le principali <a href="top.html#top">mailing list di utenti e di interesse specifico</a>.
</P></LI>

</UL>

<P><h3>Altre mailing list a cui dovresti iscriverti</h3>

<p>
<ul>
  <li>Se sei interessato allo sviluppo di NetBeans, puoi iscriverti a <b>nbdev</b>, <b>dev@openide</b> ed eventualmente anche ad altre <a href="top.html#dev">mailing list per sviluppatori</a>.  Se sei già coinvolto nello sviluppo, potrebbero interessarti invece le <a href="other.html">mailing list per la creazione di build</a>.
  </li>

  <li>Se stai sviluppando un'applicazione con un'interfaccia utente o sei interessato alle problematiche di usabilità, puoi iscriverti a <b>nbui</b>, la <a href="top.html#dev">mailing list sull'usabilità</a>.
  </li>

  <li>Sono disponibili altre <b>mailing list specifiche per modulo</b>, ad esempio mailing list ospitate su o relative a uno specifico modulo o progetto di NetBeans. Si tratta di mailing list di dimensioni più ridotte e chiaramente di natura molto più specializzata.  Se desideri concentrarti soprattutto su un determinato modulo, puoi richiedere informazioni in merito in <a href="top.html#dev">nbdev</a>.
  </li>

  <li>Mettiamo inoltre a disposizione mailing list per i membri della comunità interessati alle offerte di lavoro associate a NetBeans, a contribuire al contenuto del sito Web netbeans.org e alla promozione di NetBeans. Fai clic su <a href="top.html#community">mailing list specifiche per comunità</a>.
  </li>

  <li>Sono inoltre disponibili <a href="top.html#localised">mailing list con informazioni in diverse lingue</a>, ad esempio in francese, russo, giapponese o cinese.
  </li>

  <li>
    Per i link di discussione sulle licenze, visita la <a href="../../about/legal/license.html">pagina relativa alle licenze</a>.
  </li>

</UL>
</P>

<P><h2>Forum e newsgroup</h2>

<ul>

<li><P><b>Accesso ai forum</b>

<p>Oltre alle mailing list, sono disponibili anche forum di discussione. Tutti i messaggi delle mailing list vengono archiviati in un forum perfettamente funzionale. Sfoglia e cerca tra i messaggi di posta elettronica archiviati: i messaggi inviati alle mailing list vengono pubblicati nel forum e viceversa. Facendo clic su questo <a href="http://www.nabble.com/Netbeans.org-f2602.html">link </a> troverai l'elenco di tutti i forum ospitati su Nabble.com.

<p>Per poter usare il servizio dovrai <a href="http://www.nabble.com/user/Register.jtp">registrarti su Nabble</a>. Inoltre, i messaggi inviati tramite il forum verranno moderati da Sun, a meno che tu non sia iscritto alla mailing list degli utenti non iscritti autorizzati a pubblicare messaggi. Per evitare che i tuoi messaggi vengano moderati e far risparmiare tempo ai moderatori, puoi inviare una richiesta al proprietario della mailing list per richiedere tale autorizzazione.

<P><B>Nota:</B> SourceCast (l'applicazione che ospita netbeans.org) attualmente non include il supporto per i forum, pertanto questo servizio viene fornito attraverso il servizio di forum pubblici ospitati gratuitamente su <a href="http://www.nabble.com/">Nabble</a>.

<li><P><b>Accesso Usenet/NNTP</b>

<p>
In alternativa, per gli utenti che preferiscono le news USENET alle mailing list, tutte le mailing list principali sono collegate alle news: i messaggi inviati alle mailing list vengono inoltrati ai newsgroup e viceversa.  È sufficiente impostare l'indirizzo <A HREF="news://news.gmane.org/">news.gmane.org</A> nel lettore di news. Per via delle convenzioni Gmane, i nomi dei newsgroup non sono esattamente identici a quelli delle mailing list, comunque sono molto simili.  Per cercare i newsgroup di NetBeans, puoi utilizzare un client, ad esempio <code>gmane.comp.java.ide.netbeans.users</code>.

<p>Per inviare messaggi alle mailing list tramite NNTP, devi rispondere alla richiesta di autorizzazione inviata da GMane.  Inoltre, i messaggi inviati tramite NNTP verranno moderati da Sun, a meno che tu non sia iscritto alla mailing list degli utenti non iscritti autorizzati a pubblicare messaggi. Per evitare che i tuoi messaggi vengano moderati e far risparmiare tempo ai moderatori, puoi inviare una richiesta al proprietario della mailing list per richiedere tale autorizzazione.

<P><B>Nota:</B> SourceCast (l'applicazione che ospita netbeans.org) attualmente non include il supporto per NNTP, pertanto questo servizio viene fornito attraverso il gateway mailing list a NNTP gratuito <A HREF="http://www.gmane.org/">Gmane</A>.
</ul>


<P><h2>Annullamento dell'iscrizione a una mailing list</h2>

<p>
I link per l'annullamento dell'iscrizione sono disponibili in ogni pagina delle mailing list sopra riportata, accanto a quelli per l'iscrizione.  In caso di problemi:

<ul>
<li><b>Non inviare un messaggio contenente &quot;Annullamento dell'iscrizione&quot; o &quot;Richiesta di assistenza&quot; alla mailing list per cui desideri annullare l'iscrizione.</b>
<li>Per informazioni, vedi le pagine delle <a href="http://wiki.netbeans.org/wiki/view/NetBeansUserFAQ#section-NetBeansUserFAQ-MailingLists">domande frequenti sulle mailing list</a> e delle <a href="unsubscribe.html">procedure di annullamento dell'iscrizione</a>.
<li>Se non riesci ad annullare l'iscrizione, rivolgiti al proprietario della mailing list. Troverai informazioni dettagliate in merito nelle <a href="http://wiki.netbeans.org/wiki/view/NetBeansUserFAQ#section-NetBeansUserFAQ-MailingLists">domande frequenti</a>.
</ul>

<P><h2><a name="etiquette">Norme di utilizzo delle mailing list</a></h2>

<p>Il contributo degli utenti è sempre apprezzato, tuttavia le mailing list principali sono molto grandi, pertanto ti consigliamo di scrivere con attenzione i messaggi da inviare, in modo da ottenere con certezza una risposta.  Quando si inviano messaggi è infatti <I>essenziale</I> attenersi alle comuni norme di utilizzo delle mailing list.  Alcuni suggerimenti:

<OL>
<LI>Non inviare lo stesso messaggio a più mailing list. Scegline una e invia il messaggio solo a tale mailing list.  Se non è la mailing list adeguata, un altro utente te lo farà notare e ti suggerirà un'alternativa.

<LI>Non rispondere a un messaggio cambiandone completamente l'oggetto, poiché i lettori di posta elettronica visualizzeranno la tua risposta nel posto sbagliato. Se desideri iniziare un nuova discussione, invia un nuovo messaggio.

<LI>Leggi la guida di Eric Raymond su <a href="http://www.catb.org/~esr/faqs/smart-questions.html">come formulare domande correttamente</a>.

<LI>Nella risposta taglia il testo originale.  Includi solo la parte del testo originale strettamente correlata alla risposta.  Ti sconsigliamo di rispondere con una sola riga seguita dall'intero testo del messaggio originale.

<LI>Analogamente, se stai rispondendo punto per punto, includendo il testo originale seguito dalla risposta, assicurati di segnalare in modo chiaro le risposte. Se il testo originale di ogni domanda citata è costituito da quaranta righe, mentre le risposte sono di una sola riga, risulterà difficile trovare le risposte.  Se includi le quaranta righe complete del testo citato, lascia una riga vuota prima della risposta e due righe vuote prima di inserire nuovamente il testo originale.

<LI>Non utilizzare stili di testo nel messaggio di posta elettronica. Il tipo, la dimensione e il colore del carattere potrebbero rendere il messaggio illeggibile per gli altri utenti.  Ti consigliamo pertanto di utilizzare testo normale.  Se eviti di utilizzare stili di testo, lo stile verrà automaticamente assegnato dai lettori di posta elettronica dei diversi utenti e la leggibilità del tuo messaggio sarà garantita.

<LI>Per lo stesso motivo, è preferibile evitare di inviare messaggi in formato HTML.  La leggibilità, la dimensione e la sicurezza dei messaggi sono solo alcune delle ragioni per cui è preferibile non inviare messaggi di posta elettronica in formato HTML.  Nel sito <A HREF="http://kb.mozillazine.org/Plain_text_e-mail_%28Thunderbird%29">http://kb.mozillazine.org/Plain_text_e-mail_%28Thunderbird%29</A> troverai una descrizione completa di queste e di altre problematiche nonché le istruzioni per la disattivazione del formato HTML per i messaggi di posta elettronica nei client di posta più utilizzati.

<P>Gli <I>allegati</I> in formato HTML non presentano invece alcun problema.

</OL>

<P><h2>Note sui filtri di posta</h2>
A causa degli elevati volumi di messaggi presenti nelle mailing list, vengono utilizzate alcune convenzioni di ordinamento e applicazione di filtri.  Il software della mailing list aggiunge automaticamente come prefisso il nome della mailing list al campo Oggetto di tutte le mailing list di NetBeans: ad esempio, l'oggetto dei messaggi della mailing list nbdev è preceduto dal prefisso <B>[nbdev]</B>.

<P>Anche gli iscritti a una mailing list utilizzano spesso etichette in base all'argomento per il campo Oggetto, ad esempio [Versione stabile 3.1], in modo da tenere traccia di discussioni diverse ma correlate.  Ciò dipende chiaramente dalle preferenze di ogni singolo utente.


<P><BR></BODY>

</HTML>
