<?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="Helios"/>
   <introduction>
     <html:div>
<html:p>
This document lays out the feature and API set for the
fifth release of the Eclipse Object Constraint Language (MDT OCL)
Project, versions 3.0.0.
</html:p>
<html:p>
<html:i><html:b>Note</html:b> that, since the 
<html:a href="http://www.omg.org/cgi-bin/doc?ptc/10-02-01.pdf">OMG OCL 2.2</html:a>
standard suffers from significant ambiguities and conflicts making a compliant implementation impossible,
<html:b>MDT OCL 3.0.0</html:b> release is best endeavours to establish a coherent interpretation
of the OMG OCL 2.2 and to prototype resolutions for the OMG OCL 2.3 standards.</html:i>
</html:p>
<html:p>
</html:p>
<html:p>
<html:i>
A guide aimed to help users to migrate from MDT OCL 1.3.0 releases to MDT OCL 3.0.0 release
will be provided.
</html:i>
</html:p>
     </html:div>
   </introduction>
   <release_deliverables>
     <html:div>
The release deliverables for the MDT OCL 3.0 release has the same form as 
is found in most Eclipse projects, namely:
<html:ul>
<html:li>MDT OCL SDK (includes runtime, sources, examples, and documentation) (downloadable and update site).</html:li>
<html:li>MDT OCL runtime binary distribution (downloadable and update site).</html:li>
<html:li>MDT OCL stand-alone binary distribution (downloadable).</html:li>
<html:li>MDT OCL tests (downloadable)</html:li>
<html:li>MDT OCL examples (downloadable)</html:li>
</html:ul>
MDT OCL 3.0.0 source code will be available as versions tagged "R3_0" in the project's CVS repository.
     </html:div>
   </release_deliverables>
   <release_milestones>
      <preamble>
         <html:div>
Release milestones 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 OCL and other projects
will release simultaneously. As MDT OCL is a dependency of numerous
other projects, MDT OCL will deliver its milestones within one week of
the Eclipse Platform. It is anticipated that MDT OCL will synchronize its
milestones with the Galileo milestone schedule. MDT OCL 3.0.0 will
be following the same schedule below.
         </html:div>
      </preamble>
<milestone date="08/17/2009" milestone="M1"></milestone>
<milestone date="09/28/2009" milestone="M2"></milestone>
<milestone date="11/09/2009" milestone="M3"></milestone>
<milestone date="12/14/2009" milestone="M4"></milestone>
<milestone date="02/01/2010" milestone="M5"></milestone>
<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>
<milestone date="05/24/2010" milestone="RC2"></milestone>
<milestone date="05/31/2010" milestone="RC3"></milestone>
<milestone date="06/07/2010" milestone="RC4"></milestone>
<milestone date="06/14/2010" milestone="RC5"></milestone>
<milestone date="06/23/2010" milestone="Helios"></milestone>
      <postamble><html:div>
MDT OCL may produce interim maintenance releases in addition to these in
order to satisfy clients requests.
      </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
        Object Constraint Language (MDT OCL) project depends upon on the
        Platform and other projects, which are mostly "pure" Java. The 3.6
        release of the Eclipse Platform Project is written and compiled
        against version 5.0 of the Java Platform APIs, and targeted to run on
        version 5.0 of the Java Runtime Environment, Standard Edition. MDT OCL
        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 OCL 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 OCL
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>
       <html:div>
The MDT OCL 3.0 project
will be developed in parallel, and released simultaneously, with the
following projects. 
<html:ul>
    <html:li>Eclipse Platform SDK version 3.6</html:li>
    <html:li>Eclipse Modeling Framework (EMF) version 2.6</html:li>
    <html:li>Model Development Tools (MDT) UML2 version 3.1</html:li>
</html:ul>
<html:p>
As described above, the MDT OCL 3.0.0 release is not fully backwards compatible with the MDT OCL 1.2 
and 1.3 releases.
</html:p>
<html:p>
<html:i>
A guide aimed to help users to migrate from MDT OCL 1.3 releases to MDT OCL 3.0.0 release
will be provided.
</html:i>
</html:p>
       </html:div>
   </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>
This theme addresses issues related to the OMG OCL 2.2 standard adoption. The bugs related to the inherited deviations
of the MDT OCL implementation from the OCL 2.0 standard (and consequently, OCL 2.2) also appear here.
                </html:div>
            </description>
            <committed
                bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Compliance&amp;classification=Modeling&amp;product=MDT.OCL&amp;target_milestone=3.0.0&amp;field0-0-0=flagtypes.name&amp;type0-0-0=equals&amp;value0-0-0=helios%2B&amp;bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED">
            </committed>
            <proposed
                bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Compliance&amp;classification=Modeling&amp;product=MDT.OCL&amp;target_milestone=3.0.0&amp;field0-0-0=flagtypes.name&amp;type0-0-0=equals&amp;value0-0-0=helios%2B&amp;bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED">
            </proposed>
            <deferred
                bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Compliance&amp;classification=Modeling&amp;product=MDT.OCL&amp;field0-0-0=flagtypes.name&amp;type0-0-0=equals&amp;value0-0-0=helios-">
            </deferred>
        </theme>
        <theme name="Release Currency">
            <description>
                <html:div>
The MDT OCL project will maintain currency with its
dependencies, in particular with the EMF and MDT UML2 projects. OCL grammar will be migrated to LPG v2.
                </html:div>
            </description>
            <committed
                bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Release+Currency&amp;classification=Modeling&amp;product=MDT.OCL&amp;target_milestone=3.0.0&amp;target_milestone=1.4.0&amp;field0-0-0=flagtypes.name&amp;type0-0-0=equals&amp;value0-0-0=helios%2B&amp;bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED">
            </committed>
            <proposed
                bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Release+Currency&amp;classification=Modeling&amp;product=MDT.OCL&amp;target_milestone=3.0.0&amp;target_milestone=1.4.0&amp;field0-0-0=flagtypes.name&amp;type0-0-0=equals&amp;value0-0-0=helios%2B&amp;bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED">
            </proposed>
            <deferred
                bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Release+Currency&amp;classification=Modeling&amp;product=MDT.OCL&amp;field0-0-0=flagtypes.name&amp;type0-0-0=equals&amp;value0-0-0=helios-">
            </deferred>
        </theme>
        <theme name="Usability">
            <description>
                <html:div>
This theme addresses the need for extensibility and usability improvements
of the MDT OCL language implementation and APIs.
                </html:div>
            </description>
            <committed
                bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Usability&amp;classification=Modeling&amp;product=MDT.OCL&amp;target_milestone=3.0.0&amp;field0-0-0=flagtypes.name&amp;type0-0-0=equals&amp;value0-0-0=helios%2B&amp;bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED">
            </committed>
            <proposed
                bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Usability&amp;classification=Modeling&amp;product=MDT.OCL&amp;target_milestone=3.0.0&amp;field0-0-0=flagtypes.name&amp;type0-0-0=equals&amp;value0-0-0=helios%2B&amp;bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED">
            </proposed>
            <deferred
                bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Usability&amp;classification=Modeling&amp;product=MDT.OCL&amp;field0-0-0=flagtypes.name&amp;type0-0-0=equals&amp;value0-0-0=helios-">
            </deferred>
        </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>OCL and OMG are trademarks or registered trademark of the Object Management Group, 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>