﻿<?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="MDT-UML2">
   <release projectid="modeling.mdt" version="4.1.0"/>
   <introduction>
     <html:div>
<html:p>
This document lays out the feature and API set for the
next release of the Eclipse UML2 API (MDT UML2)
Project, version 4.1.0. This project plan inherits from the Modeling
Project Plan, which should be referenced when consulting this
individual project plan.
</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 UML2 source code release, available as versions tagged "R4_1" in the project's git repository.</html:li>
<html:li>MDT UML2 SDK (includes runtime, sources, examples, and documentation) (downloadable and update site).</html:li>
<html:li>MDT UML2 runtime binary distribution (downloadable and update site).</html:li>
<html:li>MDT UML2 stand-alone binary distribution (downloadable).</html:li>
<html:li>MDT UML2 tests</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 day; that is, until the
final 4.3 release of the Platform, upon which MDT UML2 and other projects
will release simultaneously. As MDT UML2 is a dependency of numerous
other projects, MDT UML2 will deliver its milestones within one day of
the Eclipse Platform. It is anticipated that MDT UML2 will synchronize its
milestones with the Kepler milestone schedule.
         </html:div>
      </preamble>
	<milestone date="08/20/2012" milestone="M1" />
    <milestone date="10/01/2012" milestone="M2" />
    <milestone date="11/12/2012" milestone="M3" />
    <milestone date="12/17/2012" milestone="M4" />
    <milestone date="02/04/2013" milestone="M5" />
    <milestone date="03/18/2013" milestone="M6">
      <html:div>API Freeze</html:div>
    </milestone>
    <milestone date="05/06/2013" milestone="M7">
      <html:div>Feature Freeze</html:div>
    </milestone>
    <milestone date="05/20/2013" milestone="RC1" />
    <milestone date="05/27/2013" milestone="RC2" />
    <milestone date="06/03/2013" milestone="RC3" />
    <milestone date="06/10/2013" milestone="RC4" />
    <milestone date="06/26/2013" milestone="Kepler" />
      <postamble><html:div>
MDT UML2 will produce maintenance releases to align with the Juno SR
releases, that includes the Eclipse Platform 4.2.1 and 4.2.2 releases.
MDT UML2 may produce interim maintenance releases in addition to these in
order to satisfy clients requests.
<html:ul>
  <html:li>Friday, September 28, 2012 - MDT UML2 4.0.1 maintenance release (Juno Service Release 1)</html:li>
  <html:li>Friday, February 22, 2013 - MDT UML2 4.0.2 maintenance release (Juno Service Release 2)</html:li>
  <html:li>A list of issues indicated for the 4.0.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
        Unified Modeling Language (MDT UML2) project depends upon on the
        Platform and other projects, which are mostly "pure" Java. The 4.3
        release of the Eclipse Platform Project is written and compiled
        against versions 1.5 and 1.6 of the Java Platform APIs, and targeted to run on
        version 1.5 of the Java Runtime Environment, Standard Edition. MDT UML2
        will target the same Java version as EMF, which currently also requires
        Java 5. Eclipse Platform SDK 4.3 will be tested and validated on a
        number of reference platforms. MDT UML2 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 UML2
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 4.1: The MDT UML2 project
will be developed in parallel, and released simultaneously, with the
following projects. As stated above, each milestone release of the
MDT UML2 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 4.3</html:li>
    <html:li>Eclipse Modeling Framework (EMF) version 2.9</html:li>
 </html:ul>
Therefore, the MDT UML2 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="Community Support">
            <description>
                <html:div>
The MDT UML2 project has a proven track record of quality and reliability.
Service and support will take priority over new development work; commitments and schedules are subject to arbitrary change, slippage, or even deferral.
                </html:div>
            </description>
            <committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Community+Support&amp;classification=Modeling&amp;product=MDT.UML2&amp;component=Core&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;target_milestone=RC1&amp;target_milestone=RC2&amp;target_milestone=RC3&amp;target_milestone=RC4&amp;keywords_type=allwords&amp;keywords=plan&amp;field0-0-0=flagtypes.name&amp;type0-0-0=substring&amp;value0-0-0=kepler&amp;field0-1-0=flagtypes.name&amp;type0-1-0=notsubstring&amp;value0-1-0=kepler-" />
      		<proposed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Community+Support&amp;classification=Modeling&amp;product=MDT.UML2&amp;component=Core&amp;target_milestone=Kepler&amp;keywords_type=allwords&amp;keywords=plan&amp;field0-0-0=flagtypes.name&amp;type0-0-0=substring&amp;value0-0-0=kepler&amp;field0-1-0=flagtypes.name&amp;type0-1-0=notsubstring&amp;value0-1-0=kepler-" />
      		<deferred bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;status_whiteboard_type=substring&amp;status_whiteboard=Community+Support&amp;classification=Modeling&amp;product=MDT.UML2&amp;component=Core&amp;keywords_type=allwords&amp;keywords=plan&amp;field0-0-0=flagtypes.name&amp;type0-0-0=equals&amp;value0-0-0=kepler-" />
         </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>UML 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>