<?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" xmlns="http://www.eclipse.org/project/plan" xmlns:html="http://www.w3.org/1999/xhtml" name="Project Name">
  <release projectid="modeling.mdt" version="0.7.0" />
  <introduction>
    <html:div>
      <html:p>
This document lays out the feature and API set for the first release of the 
Eclipse Business Process Model and Notation (MDT BPMN2) Project, version 0.7.0. 
This project plan inherits from the Modeling Project Plan, which should be 
referenced when consulting this individual project plan.
      </html:p>
      <html:p>
<html:i><html:b>Note</html:b> that, because the BPMN<html:sup>TM</html:sup> 2.0 
specification may not have been finalized by June 2010, APIs 
provided as part of the 0.7.0 release of <html:b>MDT BPMN2</html:b> are to be 
considered <html:b>provisional</html:b>.</html:i>
      </html:p>
    </html:div>
  </introduction>
  <release_deliverables>
    <html:div>
The release deliverables have the same form as is found in most Eclipse projects, namely:
        <html:ul>
        <html:li>MDT BPMN2 source code release, available as versions tagged "R0_7" in the project's CVS repository</html:li>
        <html:li>MDT BPMN2 SDK (includes runtime, sources, examples, and documentation) (downloadable and update site)</html:li>
        <html:li>MDT BPMN2 runtime binary distribution (downloadable and update site)</html:li>
        <html:li>MDT BPMN2 stand-alone binary distribution (downloadable)</html:li>
        <html:li>MDT BPMN2 tests (downloadable)</html:li>
      </html:ul>
    </html:div>
  </release_deliverables>
  <release_milestones>
    <preamble>
      <html:div>
Release milestone occurring at roughly 6 week intervals and follow the 
Platform milestone releases by approximately 1 week; that is, until the final 
3.6 release of the Platform, upon which MDT BPMN2 and other projects will 
release simultaneously. As MDT BPMN2 may become a dependency of numerous other 
projects, MDT BPMN2 will deliver its milestones within one week of the Eclipse 
Platform. It is anticipated that MDT BPMN2 will synchronize its milestones with 
the Helios milestone schedule.
      </html:div>
    </preamble>
    <milestone date="08/17/2009" milestone="M1" />
    <milestone date="09/28/2009" milestone="M2" />
    <milestone date="11/09/2009" milestone="M3" />
    <milestone date="12/14/2009" milestone="M4" />
    <milestone date="02/01/2010" milestone="M5" />
    <milestone date="03/15/2010" milestone="M6">
      <html:div>API Freeze</html:div>
    </milestone>
    <milestone date="05/03/2010" milestone="M7">
      <html:div>Feature Freeze</html:div>
    </milestone>
    <milestone date="05/17/2010" milestone="RC1" />
    <milestone date="05/24/2010" milestone="RC2" />
    <milestone date="05/31/2010" milestone="RC3" />
    <milestone date="06/07/2010" milestone="RC4" />
    <milestone date="06/14/2010" milestone="Final" />
    <milestone date="06/23/2010" milestone="0.7.0" />
    <postamble>
      <html:div>
As MDT BPMN2 is a new subproject of MDT, it will not produce maintenance 
releases to align with the Galileo SR releases.
      </html:div>
    </postamble>
  </release_milestones>
  <target_environments>
    <html:div>
In order to remain current, each Eclipse release targets reasonably current 
versions of the underlying operating environments. The Eclipse Business Process 
Model and Notation (MDT BPMN2) project depends upon on the Platform and other 
projects, which are mostly "pure" Java<html:sup>TM</html:sup>. The 3.6 release 
of the Eclipse Platform Project is written and compiled against version 1.4 of 
the Java Platform APIs, and targeted to run on version 1.4 of the Java Runtime 
Environment, Standard Edition. MDT BPMN2 will target the same Java version as 
EMF and UML2, which currently require Java 5. Eclipse Platform SDK 3.6 will be 
tested and validated on a number of reference platforms. MDT BPMN2 will be 
tested and validated against a subset of those listed for the platform.
    </html:div>
    <internationalization>
      <html:div>
The Eclipse Platform is designed as the basis for internationalized products. 
The user interface elements provided by the Eclipse SDK components, including 
dialogs and error messages, are externalized. The English strings are provided 
as the default resource bundles. As a result, the MDT BPMN2 project will 
provide English strings in its default bundles and be localized to a subset of 
those locales offered by the Platform. This plan will be updated to indicate 
which locales will be provided and the time frame for availability.
      </html:div>
    </internationalization>
  </target_environments>
  <compatibility_with_previous_releases />
  <themes_and_priorities>
    <preamble>
      <html:div>
A list of project requirements and agreed upon implementation time frames is 
found in this document. For the milestones listed in this document, a set of 
overall themes is used to indicate what major set of functionalities is to be 
concentrated on for each. These themes are presented below, while the 
requirements document and associated Bugzilla entries are left to those wanting 
more detailed information on each.
      </html:div>
    </preamble>
    <theme name="Compliance">
      <description>
        <html:div>
As an implementation of the OMG<html:sup>TM</html:sup>'s BPMN 2.0 
specification, the MDT BPMN2 project will maintain currency with the adopted 
and finalized specifications, as they become available.
        </html:div>
      </description>
      <committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;classification=Modeling&amp;product=MDT&amp;component=BPMN2&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&amp;status_whiteboard_type=casesubstring&amp;status_whiteboard=Compliance&amp;keywords_type=allwords&amp;keywords=plan&amp;field0-0-0=flagtypes.name&amp;type0-0-0=substring&amp;value0-0-0=helios&amp;field0-1-0=flagtypes.name&amp;type0-1-0=notsubstring&amp;value0-1-0=helios-" />
      <proposed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;classification=Modeling&amp;product=MDT&amp;component=BPMN2&amp;target_milestone=Helios&amp;status_whiteboard_type=casesubstring&amp;status_whiteboard=Compliance&amp;keywords_type=allwords&amp;keywords=plan&amp;field0-0-0=flagtypes.name&amp;type0-0-0=substring&amp;value0-0-0=helios&amp;field0-1-0=flagtypes.name&amp;type0-1-0=notsubstring&amp;value0-1-0=helios-" />
      <deferred bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;classification=Modeling&amp;product=MDT&amp;component=BPMN2&amp;status_whiteboard_type=casesubstring&amp;status_whiteboard=Compliance&amp;keywords_type=allwords&amp;keywords=plan&amp;field0-0-0=flagtypes.name&amp;type0-0-0=equals&amp;value0-0-0=helios-" />
    </theme>
  </themes_and_priorities>
  <appendix name="Legal Notices">
    <html:div>
      <html:ul>
        <html:li>Java is a trademark or a registered trademark of Sun Microsystems, Inc.</html:li>
        <html:li>BPMN and OMG are trademarks of the Object Management Group<html:sup>TM</html:sup>, Inc.</html:li>
        <html:li>All other products or company names are mentioned for identification purposes only, and may be trademarks or service marks of their respective owners.</html:li>
      </html:ul>
    </html:div>
  </appendix>
</plan>
