<?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="Galileo"/>
   <introduction>
     <html:div>
<html:p>
This document lays out the feature and API set for the
fourth release of the Eclipse Object Constraint Language (MDT OCL)
Project, version 1.3.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, depending on the nature of the anticipated OCL&#174; 2.1
revised specification from the OMG<html:sup>TM</html:sup>, <html:b>MDT OCL may require incompatible
API changes</html:b> and release as version <html:b>2.0.0</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 OCL source code release, available as versions tagged "R1_3" in the project's CVS repository.</html:li>
<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: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.5 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.
         </html:div>
      </preamble>
<milestone date="08/13/2008" milestone="M1"></milestone>
<milestone date="09/24/2008" milestone="M2"></milestone>
<milestone date="11/05/2008" milestone="M3"></milestone>
<milestone date="12/17/2008" milestone="M4"></milestone>
<milestone date="02/03/2009" milestone="M5"></milestone>
<milestone date="03/16/2009" milestone="M6"><html:div>API freeze</html:div></milestone>
<milestone date="05/04/2009" milestone="M7"><html:div>Feature Freeze</html:div></milestone>
<milestone date="05/18/2009" milestone="RC1"></milestone>
<milestone date="05/25/2009" milestone="RC2"></milestone>
<milestone date="06/01/2009" milestone="RC3"></milestone>
<milestone date="06/08/2009" milestone="RC4"></milestone>
<milestone date="06/15/2009" milestone="RC5"></milestone>
<milestone date="06/28/2009" milestone="1.3.0"></milestone>
      <postamble><html:div>
MDT OCL will produce maintenance releases to align with the Ganymede SR
releases, that includes the Eclipse Platform 3.4.1 and 3.4.2 releases.
MDT OCL may produce interim maintenance releases in addition to these in
order to satisfy clients requests.
<html:ul>
  <html:li>Friday, August 15, 2008 - MDT OCL 1.2.1 maintenance release</html:li>
  <html:li>Friday, September 26, 2008 - MDT OCL 1.2.2 maintenance release (Ganymede Service Release 1)</html:li>
  <html:li>Friday, February 27, 2009 - MDT OCL 1.2.3 maintenance release (Ganymede Service Release 2)</html:li>
  <html:li>A list of issues indicated for the 1.2.x maintenance stream can be found in
      bugzilla, or by using links on maintenance stream build pages.</html:li>
</html:ul> 
      </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<html:sup>TM</html:sup>. The 3.5
        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 OCL
        will target the same Java version as EMF and UML2, which currently require
        Java 5. Eclipse Platform SDK 3.5 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>
Compatibility of Release 1.3: The MDT OCL project
will be developed in parallel, and released simultaneously, with the
following projects. As stated above, each milestone release of the
MDT OCL project will be compatible with the
corresponding milestones for each of these projects, and delivered the
appropriate offset.
<html:ul>
    <html:li>Eclipse Platform SDK version 3.5</html:li>
    <html:li>Eclipse Modeling Framework (EMF) version 2.5</html:li>
    <html:li>Model Development Tools (MDT) UML2 version 2.3</html:li>
</html:ul>
Therefore, the MDT OCL initial release will be
compatible with these versions and will publish binary and source
compatibilities with migration guides on subsequent releases.
       </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="Release Currency">
            <description>
                <html:div>
The MDT OCL project will maintain currency with its
dependencies, in particular advances in the EMF and MDT UML2 projects.
Additionally, as an implementation of the OMG's OCL 2.0 specification,
the MDT OCL project will maintain currency with the revised 2.1
specification.
                </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=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;field0-0-0=flagtypes.name&amp;type0-0-0=equals&amp;value0-0-0=galileo%2B">
            </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=1.3.0&amp;field0-0-0=flagtypes.name&amp;type0-0-0=equals&amp;value0-0-0=galileo%2B">
            </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=galileo-">
            </deferred>
        </theme>
        <theme name="Extensibility">
            <description>
                <html:div>
The Object Constraint Language is re-used and extended
by other language specifications, in particular the OMG MOF&#174; Query/View/Transformation
family of languages.  This theme addresses the need for extensibility
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=Extensibility&amp;classification=Modeling&amp;product=MDT.OCL&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;field0-0-0=flagtypes.name&amp;type0-0-0=equals&amp;value0-0-0=galileo%2B">
            </committed>
            <proposed
                bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Extensibility&amp;classification=Modeling&amp;product=MDT.OCL&amp;target_milestone=1.3.0&amp;field0-0-0=flagtypes.name&amp;type0-0-0=equals&amp;value0-0-0=galileo%2B">
            </proposed>
            <deferred
                bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Extensibility&amp;classification=Modeling&amp;product=MDT.OCL&amp;field0-0-0=flagtypes.name&amp;type0-0-0=equals&amp;value0-0-0=galileo-">
            </deferred>
        </theme>
        <theme name="Appealing to a Broader Community">
            <description>
                <html:div>
There are a few fairly routine capabilities which, historically, MDT OCL has not
supplied because of its narrow focus on parsing and evaluating OCL text.  User
demand shows the value of providing the EMF.Edit plug-ins, for example, as well
as a more flexible feature structure.
                </html:div>
            </description>
            <committed
                bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Broad+Appeal&amp;classification=Modeling&amp;product=MDT.OCL&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;field0-0-0=flagtypes.name&amp;type0-0-0=equals&amp;value0-0-0=galileo%2B">
            </committed>
            <proposed
                bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Broad+Appeal&amp;classification=Modeling&amp;product=MDT.OCL&amp;target_milestone=1.3.0&amp;field0-0-0=flagtypes.name&amp;type0-0-0=equals&amp;value0-0-0=galileo%2B">
            </proposed>
            <deferred
                bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Broad+Appeal&amp;classification=Modeling&amp;product=MDT.OCL&amp;field0-0-0=flagtypes.name&amp;type0-0-0=equals&amp;value0-0-0=galileo-">
            </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<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>
