<!--
  ~ Licensed to the Apache Software Foundation (ASF) under one
  ~ or more contributor license agreements. See the NOTICE file
  ~ distributed with this work for additional information
  ~ regarding copyright ownership. The ASF licenses this file
  ~ to you 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 html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta name="generator" content=
"HTML Tidy for Windows (vers 14 June 2007), see www.w3.org" />
<meta http-equiv="content-type" content="" />
<title>Guidelines</title>
<link href="css/axis-docs.css" rel="stylesheet" type="text/css"
media="all" />
</head>
<body>
<h2>Release Process</h2>
<p>Click to read our <a href="release-process.html">Release Process
Guidelines</a>.</p>
<h2>Mail Guidelines</h2>
<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><b>Before you join these lists, you should make sure that you
read and follow the information below.</b></p>
<p>We ask that you do your best to respect the charter of the
appropriate mailing list. There are generally two types of lists
that you can join.</p>
<ul>
<li>The "User" list is where you should send questions and comments
about configuration, setup, usage and other "user" type of
questions.</li>
<li>The "Developer" list is where you should send questions and
comments about the actual software source code and general
"development" type of questions.</li>
</ul>
<p><b>Summary : Prefix each message subject with
"[Axis2]"</b><br />
You may already know that Axis 1.x is still going parallel with
Axis 2.0. So for everyone's convenience, prefix the subject of
<b>every mail</b> about Axis 2.0 with [Axis2].</p>
<p><b>Summary: Join the lists that are appropriate for your
discussion.</b><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><b>Summary: Do not abuse resources in order to get
help.</b><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><b>Summary: Do your best to ensure that you are not sending HTML
or "Stylelized" email to the list.</b><br />
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. Please read this page as well.</p>
<p><b>Summary: Watch where you are sending email.</b><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><b>Summary: Do not crosspost messages.</b><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>
<p></p>
</body>
</html>
