<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<?xml-stylesheet type="text/xsl" href="http://www.eclipse.org/projects/project-plan.xsl"?>
<plan plan-format="1.0">
  <release projectid="technology.dash" version="1.0"/>
    <introduction><![CDATA[
    The Dash 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.
    <p>
    The Dash project is divided into two parts: Dash and Dash-prime. Dash is the open source
    project and Dash-prime is the closed, internal-to-the-Foundation, code base. Even though
    the Dash-prime code base is closed, the planning, discussions, and bug activities are open.
    Thus this project plan covers both Dash and Dash-prime.
    ]]>
  </introduction>
  <release_deliverables><![CDATA[
    The Dash project deliver server software running on eclipse.org servers (Commits Explorer and Ganymatic).
    The Dash-prime team is also responsible for an internal Foundation application deployed on eclipse.org servers (Portal).
  ]]></release_deliverables>
  <release_milestones>
    <!-- <preamble><![CDATA[      
    ]]></preamble> -->
    <milestone date="4/30/2008" milestone="M1" bugzilla=""><![CDATA[ April milestone ]]></milestone>
    <milestone date="5/31/2008" milestone="M2" bugzilla=""><![CDATA[ May milestone ]]></milestone>
    <milestone date="6/30/2008" milestone="M3" bugzilla=""><![CDATA[ June milestone ]]></milestone>
    <milestone date="7/31/2008" milestone="M4" bugzilla=""><![CDATA[ July milestone ]]></milestone>
    <!-- <postamble><![CDATA[
    ]]></postamble> -->
  </release_milestones>
  <target_environments><![CDATA[
    Ganymatic runs on the build.eclipse.org server and requires Java 5.0 and Ant 1.7.
    <p>
    Commits Explorer runs on the dash.eclipse.org server and requires a current version
    of Apache, PHP, Perl, and MySQL.
    <p>
    Foundation Portal runs on the portal.eclipse.org server and requires a current version
    of Apache, PHP, and MySQL.
  ]]>  <internationalization><![CDATA[
    None of the Dash deliverables are internationalized.
    ]]></internationalization>
  </target_environments>
  <compatibility_with_previous_releases><![CDATA[
    
  ]]></compatibility_with_previous_releases>
  <themes_and_priorities>
    <preamble><![CDATA[
The Dash project is not a traditional Eclipse project in that it is in
support of the Eclipse committers and member 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.
    ]]></preamble>
    <theme name="Clean the Graffiti">
      <description>
Cleaning the Graffiti is reducing the backlog of small bugs against 
the Dash and Dash-prime tools. The goal is to have committers feel happy about the portal 
(it's doing what they want) and to believe that the portal team is 
responsive to their requests (it's going in the right direction). 
We want the Dash tools to be a benefit of Eclipse committership and not a burden.
      </description>
      <committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;short_desc_type=allwordssubstr&amp;short_desc=%5BClean+the+Graffiti%5D&amp;classification=Eclipse+Foundation&amp;product=Community&amp;component=Dashboard&amp;component=IPZilla&amp;component=Portal&amp;component=Process&amp;component=Website&amp;long_desc_type=allwordssubstr&amp;long_desc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_file_loc=&amp;status_whiteboard_type=allwordssubstr&amp;status_whiteboard=&amp;keywords_type=allwords&amp;keywords=&amp;priority=P1&amp;priority=P2&amp;priority=P3&amp;priority=P4&amp;emailtype1=substring&amp;email1=&amp;emailtype2=substring&amp;email2=&amp;bugidtype=include&amp;bug_id=&amp;votes=&amp;chfieldfrom=&amp;chfieldto=Now&amp;chfieldvalue=&amp;cmdtype=doit&amp;order=Reuse+same+sort+as+last+time&amp;field0-0-0=noop&amp;type0-0-0=noop&amp;value0-0-0="></committed>
      <proposed></proposed>
      <deferred bugzilla=""></deferred>
    </theme>
    <theme name="Manage Committers">
      <description>
Managing Committers is our theme for provide teams and team leaders tools 
to manage their committer populations: adding new committers, removing 
inactive committers, managing file permissions, etc.
	  </description>
      <committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;short_desc_type=allwordssubstr&amp;short_desc=%5BManage+Committers%5D&amp;classification=Eclipse+Foundation&amp;product=Community&amp;component=Dashboard&amp;component=IPZilla&amp;component=Portal&amp;component=Process&amp;component=Website&amp;long_desc_type=allwordssubstr&amp;long_desc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_file_loc=&amp;status_whiteboard_type=allwordssubstr&amp;status_whiteboard=&amp;keywords_type=allwords&amp;keywords=&amp;priority=P1&amp;priority=P2&amp;priority=P3&amp;priority=P4&amp;emailtype1=substring&amp;email1=&amp;emailtype2=substring&amp;email2=&amp;bugidtype=include&amp;bug_id=&amp;votes=&amp;chfieldfrom=&amp;chfieldto=Now&amp;chfieldvalue=&amp;cmdtype=doit&amp;order=Reuse+same+sort+as+last+time&amp;field0-0-0=noop&amp;type0-0-0=noop&amp;value0-0-0="></committed>
    </theme>
    <theme name="Make The Portal More Of A Home">
      <description>
The portal is very useful as it is. But it could be much more. It is currently 
mostly a workflow facilitator helping project members walk the development process 
etc. But given that most of the content is driven by a database or two, 
there are many more possibilities that would make it more attractive 
as a landing page for committers.
	  </description>
      <committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;short_desc_type=allwordssubstr&amp;short_desc=%5BMake+The+Portal+More+Of+A+Home%5D&amp;classification=Eclipse+Foundation&amp;product=Community&amp;component=Dashboard&amp;component=IPZilla&amp;component=Portal&amp;component=Process&amp;component=Website&amp;long_desc_type=allwordssubstr&amp;long_desc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_file_loc=&amp;status_whiteboard_type=allwordssubstr&amp;status_whiteboard=&amp;keywords_type=allwords&amp;keywords=&amp;priority=P1&amp;priority=P2&amp;priority=P3&amp;priority=P4&amp;emailtype1=substring&amp;email1=&amp;emailtype2=substring&amp;email2=&amp;bugidtype=include&amp;bug_id=&amp;votes=&amp;chfieldfrom=&amp;chfieldto=Now&amp;chfieldvalue=&amp;cmdtype=doit&amp;order=Reuse+same+sort+as+last+time&amp;field0-0-0=noop&amp;type0-0-0=noop&amp;value0-0-0="></committed>
    </theme>
    <theme name="Improve the Experience">
      <description>
As the portal handles more of the workflow for our committers
and members, it could become cluttered and slow. We plan to improve
both the user interface and the infrastructure to avoid that.
      </description>
      <committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;short_desc=%5BImprove+the+Experience%5D&amp;short_desc_type=allwordssubstr&amp;classification=Eclipse+Foundation&amp;product=Community&amp;component=Dashboard&amp;component=IPZilla&amp;component=Portal&amp;component=Process&amp;component=Website&amp;long_desc_type=allwordssubstr&amp;long_desc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_file_loc=&amp;status_whiteboard_type=allwordssubstr&amp;status_whiteboard=&amp;keywords_type=allwords&amp;keywords=&amp;priority=P1&amp;priority=P2&amp;priority=P3&amp;priority=P4&amp;emailtype1=substring&amp;email1=&amp;emailtype2=substring&amp;email2=&amp;bugidtype=include&amp;bug_id=&amp;votes=&amp;chfieldfrom=&amp;chfieldto=Now&amp;chfieldvalue=&amp;cmdtype=doit&amp;order=Reuse+same+sort+as+last+time&amp;field0-0-0=noop&amp;type0-0-0=noop&amp;value0-0-0="></committed>
    </theme>
    <theme name="Other">
      <description>
Features and bugs that we plan to address in the next three months that are not yet categorized into a theme.
	  </description>
      <proposed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;short_desc_type=allwordssubstr&amp;short_desc=&amp;classification=Eclipse+Foundation&amp;product=Community&amp;component=Dashboard&amp;component=IPZilla&amp;component=Portal&amp;component=Process&amp;target_milestone=April+08&amp;target_milestone=June+08&amp;target_milestone=May+08&amp;long_desc_type=allwordssubstr&amp;long_desc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_file_loc=&amp;status_whiteboard_type=allwordssubstr&amp;status_whiteboard=&amp;keywords_type=allwords&amp;keywords=&amp;priority=P1&amp;priority=P2&amp;priority=P3&amp;priority=P4&amp;emailtype1=substring&amp;email1=&amp;emailtype2=substring&amp;email2=&amp;bugidtype=include&amp;bug_id=&amp;votes=&amp;chfieldfrom=&amp;chfieldto=Now&amp;chfieldvalue=&amp;cmdtype=doit&amp;order=Reuse+same+sort+as+last+time&amp;field0-0-0=short_desc&amp;type0-0-0=notregexp&amp;value0-0-0=%5E%5C%5B%5BA-Z%5D"></proposed>
    </theme>
  </themes_and_priorities>
  <appendix name="Eclipse Monkey"><![CDATA[
    <p>The Dash project used to contain the Eclipse Monkey component.
    The Monkey committers became inactive and this component will either
    be archived (if there are no committers)
    or spun off as a separate project (if there are new committers).</p>
  ]]></appendix>  
</plan>
