<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
  <title>The AspectJ project at Eclipse.org: User Resources</title>
  <link rel="stylesheet" href="aspectj_style.css" type="text/css" />
</head>
<body>
<div id="container">
<?php require("banner.html"); ?>
<div id="main">
  <!-- ================ Page specific content starts here ================ -->

<h1>aspectj: user resources</h1>

 <!-- =============== ASPECTJ-USERS ==================== -->

<h2>Users Mailing List</h2>

	<dl>
		<dt><a target="_top" href="https://dev.eclipse.org/mailman/listinfo/aspectj-users">
	    	aspectj-users at eclipse.org</a> and 
	    	<a target="_top" href="http://dev.eclipse.org/mhonarc/lists/aspectj-users/maillist.html">
	    	archive</a>
	    	(<a href="http://www.eclipse.org/search/search.cgi?ul=%2Fmhonarc%2Flists%2Faspectj-users">
	    	search</a>).
	    </dt>
		<dd>Supports discussion among AspectJ users and developers on topics such 
	    	as language design, new features, and best usage practices.
	    </dd>

		<dt><a href="http://dev.eclipse.org/viewcvs/indextech.cgi/~checkout~/aspectj-home/archives/users.zip">
	    	users@aspectj.org  ZIP archive (deprecated mailing list)</a>
	    </dt>
		<dd>These archives contain user discussion from August 1999 - December 
	    	2002.
    	</dd>
	</dl>
 

  <!-- =============== ASPECTJ-ANNOUNCE ==================== -->

<h2>Announcement Mailing List</h2>

	<dl>
		<dt>
			<a target="_top" href="https://dev.eclipse.org/mailman/listinfo/aspectj-announce">
		    aspectj-announce at eclipse.org</a> and
		    <a target="_top" href="http://dev.eclipse.org/mhonarc/lists/aspectj-announce/maillist.html">
		    archive</a>
		    (<a href="http://www.eclipse.org/search/search.cgi?ul=%2Fmhonarc%2Flists%2Faspectj-announce">
		    search</a>)
		</dt>
		<dd>
			Used only to announce new releases and other important events. This is 
	    	a low traffic list, receiving on average one message every two weeks.		
    	</dd>

		<dt>
		    <a href="http://dev.eclipse.org/viewcvs/indextech.cgi/~checkout~/aspectj-home/archives/announce.zip">
		    announce@aspectj.org ZIP archive (deprecated mailing list)</a>		
		</dt>
		<dd>
		    These archives contain announcement discussion from August 1999 - 
		    December 2002.
		</dd>
	</dl>

  <!-- =============== BUGZILLA ==================== -->

<h2>Bug Reports &amp; Enhancement Requests</h2>

	<dl>
		<dt><a href="https://bugs.eclipse.org/bugs/buglist.cgi?product=AspectJ&bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_severity=enhancement">
	    	Requested and planned enhancements</a>
		</dt>
		<dd>The list of enhancement requests for AspectJ on bugzilla.
		</dd>

		<dt>
		    <a href="https://bugs.eclipse.org/bugs/enter_bug.cgi?product=AspectJ&bug_severity=enhancement">Submit 
		    a request for a new AspectJ feature</a>
		</dt>
		<dd>	    	Submit new Bugzilla feature requests for AspectJ.
		</dd>

		<dt><a href="http://dev.eclipse.org/bugs/query.cgi?product=AspectJ">View 
	    	AspectJ bug reports</a>
		</dt>
		<dd> Query the Bugzilla database for AspectJ bug reports and feature 
	    	requests.
		</dd>

		<dt><a href="http://dev.eclipse.org/bugs/enter_bug.cgi?product=AspectJ">Submit 
	    	a new AspectJ bug report</a>
		</dt>
		<dd>Submit new Bugzilla reports and feature requests according to the
	    	<a href="http://dev.eclipse.org/bugs/bugwritinghelp.html">Bug Writing 
	    	Guidelines</a>.
		</dd>
	</dl>

  <!-- =============== TEACHING ==================== -->

<h2>Courses</h2>

	<dl>
		<dt><a href="teaching.php">AOSD courses</a>
		</dt>
		<dd>A list of organisations and individuals teaching AOSD and/or AOP (not
	    	necessarily AspectJ) as all or part of a course.
		</dd>
	</dl>
 
  <!-- ================ End of page specific content ===================== -->
</div>
</div>
</body>
</html>