<div class="wiki-content maincontent"><p>We are a community based open source project and we really welcome and value your <a shape="rect" href="contributing.xml">Contributions</a>. We have various ways of getting help via the <a shape="rect" href="discussion-forums.xml">Discussion Forums</a> or <a shape="rect" href="mailing-lists.xml">Mailing Lists</a>. </p>

<p>Here are a few tips to help us to help you</p>

<ul><li>which version of ActiveMQ are you using? (and if you are using a SNAPSHOT, which date?)</li><li>are you using queues or topics and are you using persistent or non persistent messaging?</li><li>details of your environment can help too such as
	<ul><li>operating system</li><li>JVM version (1.6, 1.5, or 1.4)</li><li>application server; spring, tomcat, J2EE etc?</li></ul>
	</li><li>remember you can always get full <a shape="rect" href="support.xml#Support-CommercialSupport">commercial support</a> if you want a dedicated support team.</li></ul></div>

