<?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-09" milestone="M2"><html:p>February milestone</html:p></milestone>
    <milestone date="2009-03-09" milestone="M3"><html:p>March milestone</html:p></milestone>
    <milestone date="2009-05-18" milestone="M4"><html:p>May 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:ol>
			<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.status_whiteboard%2Cbugs.resolution&amp;status_whiteboard=m&amp;status_whiteboard_type=substring">Committed Bugs, Ordered by Milestone</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.status_whiteboard%2Cbugs.resolution&amp;status_whiteboard=m&amp;status_whiteboard_type=notregexp">Proposed Bugs, Ordered by Milestone</html:a></html:li>
		</html:ol>
		</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.status_whiteboard%2Cbugs.resolution&amp;status_whiteboard=m&amp;status_whiteboard_type=substring"></committed>
	  <proposed  bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;product=Dash&amp;component=Common+Builder&amp;order=bugs.status_whiteboard%2Cbugs.resolution&amp;status_whiteboard=m&amp;status_whiteboard_type=notregexp"></proposed>
    </theme>
  </themes_and_priorities>
  <appendix/>
</plan>
