<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<?xml-stylesheet type="text/xsl" href="project-plan-render.xsl"?>
<plan xmlns="http://www.eclipse.org/project/plan" xmlns:html="http://www.w3.org/1999/xhtml">
  <release projectid="technology.dash.athena" version="1.0"/>
    <introduction>
    <html:p>The Dash Athena project currently does not produce an Eclipse plug-in and thus does not have
    a traditional release cycle. Dash currently produces tools for committers that are deployed
    on various eclipse.org servers. These deployments are done incrementally, often daily, whenever
    new functionality is needed. We roll these deployments up into monthly milestones for
    reporting.</html:p>
    <html:p>The Dash Athena project is divided into two parts: tooling and infrastructure. 
	Tooling code is currently located in the SOC project; build infrastructure is in the Dash project. 
    </html:p>
  </introduction>
  <release_deliverables>
    <html:p>The Dash project delivers server software running on eclipse.org servers, plus end-user tools for more easily getting started with building a project.
  	</html:p>
  </release_deliverables>
  <release_milestones>
    <milestone date="2008-11-24" milestone="M1"><html:p>November milestone</html:p></milestone>
    <milestone date="2009-02-16" milestone="M2"><html:p>February milestone</html:p></milestone>
    <milestone date="2009-05-25" milestone="M3"><html:p>May milestone</html:p></milestone>
    <milestone date="2009-08-31" milestone="M4"><html:p>August milestone</html:p></milestone>
    <postamble/>
  </release_milestones>
  <target_environments><html:p>The Common Builder runs on the build.eclipse.org server and requires Java 5.0 and Ant 1.7.</html:p>
    <html:p>Tooling requires Java 5.0 and Eclipse 3.4.</html:p>
    <internationalization>
       <html:p>
        None of the Dash Athena deliverables are internationalized.
        </html:p>
    </internationalization>
  </target_environments>
  <compatibility_with_previous_releases/>
  
  <themes_and_priorities>
    <preamble>
     <html:p>
The Dash project is not a traditional Eclipse project in that it is in
support of the Eclipse committers and members rather than in support of adopters and users.
Thus the Dash project has a somewhat different set of Themes and Priorities than those
defined by the Requirements Council.
     </html:p>
    </preamble>
    <theme name="Improve the Experience">
      <description>
       <html:p>
Building a project is a time-consuming process to set up and difficult to maintain. We plan to improve
both the user interface and the infrastructure to avoid that.</html:p> 
		<html:p>
		<html:ul>
			<html:li><html:a href="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;product=Dash&amp;component=Common+Builder&amp;order=bugs.target_milestone%2Cbugs.resolution&amp;bug_status=UNCONFIRMED&amp;bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED">Open Bugs</html:a></html:li>
			<html:li><html:a href="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;product=Dash&amp;component=Common+Builder&amp;order=bugs.target_milestone%2Cbugs.resolution&amp;target_milestone=Past&amp;target_milestone=M1&amp;target_milestone=M2&amp;target_milestone=M3&amp;target_milestone=M4&amp;target_milestone=M5&amp;target_milestone=M6&amp;target_milestone=M7&amp;target_milestone=RC">Committed Bugs</html:a></html:li>
			<html:li><html:a href="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;product=Dash&amp;component=Common+Builder&amp;order=bugs.target_milestone%2Cbugs.resolution&amp;target_milestone=---&amp;target_milestone=Future">Proposed Bugs</html:a></html:li>
			<html:li><html:a href="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;product=Dash&amp;component=Common+Builder&amp;order=bugs.target_milestone%2Cbugs.resolution&amp;bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED">Closed Bugs</html:a></html:li>
			<html:li><html:a href="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;product=Dash&amp;component=Common+Builder&amp;order=bugs.target_milestone%2Cbugs.resolution&amp;chfieldfrom=1w&amp;chfieldto=Now">Changed This Week</html:a></html:li>
		</html:ul>
		</html:p>
      </description>
      <committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;product=Dash&amp;component=Common+Builder&amp;order=bugs.target_milestone%2Cbugs.resolution&amp;target_milestone=Past&amp;target_milestone=M1&amp;target_milestone=M2&amp;target_milestone=M3&amp;target_milestone=M4&amp;target_milestone=M5&amp;target_milestone=M6&amp;target_milestone=M7&amp;target_milestone=RC"></committed>
      <proposed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;product=Dash&amp;component=Common+Builder&amp;order=bugs.target_milestone%2Cbugs.resolution&amp;target_milestone=---&amp;target_milestone=Future"></proposed>
    </theme>
  </themes_and_priorities>
  <appendix/>
</plan>
