<?xml version="1.0" encoding="UTF-8"?>
<!--
 * Copyright 2001-2009 The Apache Software Foundation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */ -->
<!DOCTYPE document PUBLIC "-//APACHE//DTD Documentation V1.2//EN" "http://forrest.apache.org/dtd/document-v12.dtd">
<document>
  <properties>
    <title>Mailing Lists Guidelines</title>
  </properties>
  <body>
  
  <anchor id="guidelines"/>
  <section name="Mailing List Guidelines">
    <p>Every volunteer project obtains its strength from the people involved in it. Mailing lists provide a simple and effective communication mechanism. 
    </p>
    <p>You are welcome to join any of our mailing lists (or all of them if you wish). You can choose to lurk, or actively participate. It's up to you. 
    </p>
    <p>Before you join these lists, you should make sure that you read and follow the guidelines below. 
    </p>
    <p><strong>Do your best to respect the charter of the mailing list</strong><br/>There are three types of lists that you can join: 
    </p>
    <ul>
      <li>The <a href="#juddi-user">User</a> list is where you should send questions and comments about configuration, setup, usage and other "user" types of questions.</li> 
      <li>The <a href="#juddi-dev">Developer</a> list is where you should should send questions and comments about the actual software source code and general "development" types of questions.</li> 
      <li>The <a href="#juddi-cvs">Commit</a> list is used for tracking committer activity in the project's CVS repository. This list is used for informational purposes only.  Please do not post messages to this list.  Questions regarding activity on this list should be posted on the <a href="#juddi-dev">Developer</a> list.</li> 
    </ul>
    <p><strong>Join the lists that are appropriate for your discussion</strong><br/>Please make sure that you are joining the list that is appropriate for the topic or 
      product that you would like to discuss.
    </p>
    <p><strong>Do not abuse resources in order to get help</strong><br/>Asking your configuration or user type of question on the developers list because you think that 
      you will get help more quickly by going directly to the developers instead of to the user base is not very nice. Chances are that doing this will 
      actually prevent people from answering your question because it is clear that you are trying to abuse resources.
    </p>
    <p><strong>Avoid sending HTML or "Stylized" email to the list</strong><br/>Do your best to ensure that you are not sending HTML or "Stylized" email to the list. If 
      you are using Outlook or Outlook Express or Eudora, chances are that you are sending HTML email by default. There is usually a setting that will allow you to 
      send "Plain Text" email. If you are using Microsoft products to send email, there are several bugs in the software that prevent you from turning off the sending 
      of HTML email.
    </p> 
    <p><strong>Watch where you are sending email</strong><br/>The majority of our mailing lists have set the Reply-To to go back to the list. That means that when you 
      Reply to a message, it will go to the list and not to the original author directly. The reason is because it helps facilitate discussion on 
      the list for everyone to benefit from. Be careful of this as sometimes you may intend to reply to a message directly to someone instead of 
      the entire list.
    </p>
    <p><strong>Do not crosspost messages</strong><br/>In other words, pick a mailing list and send your messages to that mailing list only. Do not send your messages 
      to multiple mailing lists. The reason is that people may be subscribed to one list and not to the other. Therefore, some people may only see 
      half of the conversation.
    </p>
  </section>

  </body>
</document>
