<?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="Java Workflow Tooling (JWT)">
   <release projectid="soa.jwt" version="1.2"></release>
   <introduction>
     <html:div>Java Workflow Tooling (JWT) is a project with a set of plugins which allow the user to model, validate, analyze, deploy and monitor a workflow or business process. It is currently centered on the Workflow Editor (WE) and will soon have several other plugins concerning transformations and the actual execution.</html:div>
   </introduction>
   <release_deliverables>
     <html:div>All releases come with a release presentation describing the new features. Presentations on Eclipse conferences such as Eclipse Summit Europe or EclipseCon are planned as well as articles for international Eclipse magazines describing the details of each release.</html:div>
   </release_deliverables>
	<release_milestones>
      <preamble>
         <html:div>The JWT project has completed its graduation release. In the future we will focus on both stability increasing as well as feature releases. JWT will take part in the yearly Eclipse release trains.</html:div>
      </preamble>
      	<milestone date="10/29/2008" milestone="0.5"></milestone>
     	<milestone date="06/24/2009" milestone="0.6"></milestone>
     	<milestone date="12/18/2009" milestone="0.7"></milestone>
		<milestone date="06/20/2010" milestone="1.0"></milestone>
		<milestone date="06/22/2011" milestone="1.1"></milestone>
		<milestone date="06/27/2012" milestone="1.2"></milestone>
	</release_milestones>   
   <target_environments>
     <html:div>We are targeting all Eclipse users who wish to create their process models and have a unified toolset to model, analyze, deploy and monitor their processes and workflows. Since it is in Eclipse we aim to be compatible with all plattforms Eclipse is already compatible with. For the beginning we are working on compatibility with the process engines Nova Bonita 4.0 as well as JBoss jBPM, but the framework shall be very generic so that every other process engine can be used as well.</html:div>
     <internationalization>
          <html:div>The language support started with English, German and French language and now leverages all languages that are supported by the Babel framework.</html:div>
     </internationalization>
   </target_environments>
   <compatibility_with_previous_releases>
       <html:div>All releases shall be backwards compatible with the older releases. Since JWT 1.2 is a release focused on bug fixes
       and stability, no breaking API changes are to be expected.</html:div>
   </compatibility_with_previous_releases>
   <themes_and_priorities>
     <preamble>
         <html:div>We did not make a difference between different themes, but in the things that shall be achieved with each planned release.</html:div>
     </preamble>
     <theme name="JWT Release 0.5 - Stabilization and Openness">
        <description>JWT 0.5 sets the focus on extensions and improvements of the Workflow Editor (WE). First transformations to achieve compatibility with other standards such as BPMN or XPDL are also integrated in this release.</description>
        <committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;classification=SOA&amp;product=JWT&amp;component=WE&amp;version=0.5.0"></committed>
        <proposed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=UNCONFIRMED&amp;bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED&amp;bug_status=VERIFIED&amp;classification=SOA&amp;product=JWT&amp;version=0.5.0"></proposed>
     </theme>
     <theme name="JWT Release 0.6 - JWT in Galileo including JWT for SOA">
        <description>JWT 0.6 provides the user with much more extension possibilities. Additionally to the already integrated extension points in version 0.5, we will integrate a mechanism so that other users can extend and modify the metamodel with additional elements or properties from external plugins in order to make it much more interesting for other vendors.</description>
        <committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;classification=SOA&amp;product=JWT&amp;component=WE&amp;version=0.6.0"></committed>
        <proposed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=UNCONFIRMED&amp;bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED&amp;bug_status=VERIFIED&amp;classification=SOA&amp;product=JWT&amp;version=0.6.0"></proposed>     
     </theme>
     <theme name="JWT Release 0.7 - JWT - Views on a process model and execution">
     	<description>JWT 0.7 includes a new view mechanism to provide an easier mechanism for creating own views. We will also have more transformations in 0.7 and an initial version of the Desktop component. </description>
        <committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;classification=SOA&amp;product=JWT&amp;component=WE&amp;version=0.7.0"></committed>
        <proposed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=UNCONFIRMED&amp;bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED&amp;bug_status=VERIFIED&amp;classification=SOA&amp;product=JWT&amp;version=0.7.0"></proposed>     
     </theme>
     <theme name="JWT Release 1.0 - JWT for Users">
     	<description>JWT 1.0 is our graduation release. It comes with much more plugins to deploy a process on a workflow engine, an improved WAM, runtime, transformations as well as an improved workflow editor and several other bugfixes.</description>
        <committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;classification=SOA&amp;product=JWT&amp;component=WE&amp;version=1.0.0"></committed>
        <proposed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=UNCONFIRMED&amp;bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED&amp;bug_status=VERIFIED&amp;classification=SOA&amp;product=JWT&amp;version=1.0.0"></proposed>     
     </theme>
     <theme name="JWT Release 1.1 - Developer Experience">
     	<description>JWT 1.1 ships with Indigo and brings bugfixes and smaller changes such as refactorings in the meta model, delete &amp; queries in WAM API, custom properties available in transformations...</description>
        <committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;classification=SOA&amp;product=JWT&amp;component=WE&amp;version=1.1.0"></committed>
        <proposed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=UNCONFIRMED&amp;bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED&amp;bug_status=VERIFIED&amp;classification=SOA&amp;product=JWT&amp;version=1.1.0"></proposed>     
     </theme>
     <theme name="JWT Release 1.2 - Eclipse 4 Support, Editor usage improvements">
     	<description>JWT 1.2 ships with Juno with Eclipse 4.2 support and brings bugfixes and improvements to JWT Editor usage.</description>
        <committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?field0-0-0=target_milestone&amp;classification=SOA&amp;query_format=advanced&amp;bug_status=RESOLVED&amp;bug_status=CLOSED&amp;type0-0-0=regexp&amp;value0-0-0=1.2.*&amp;product=JWT"></committed>
        <proposed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=UNCONFIRMED&amp;bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED&amp;bug_status=VERIFIED&amp;classification=SOA&amp;product=JWT&amp;version=1.2.0"></proposed>     
     </theme>
     <theme name="JWT Release 1.3 - JWT for Business">
     	<description>JWT 1.3 will include a BPMN view, generic ECM (Entreprise Content Management) integration, a first version of the Desktop component and an annotation editor.</description>
        <committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;classification=SOA&amp;product=JWT&amp;component=WE&amp;version=1.3.0"></committed>
        <proposed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=UNCONFIRMED&amp;bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED&amp;bug_status=VERIFIED&amp;classification=SOA&amp;product=JWT&amp;version=1.3.0"></proposed>     
     </theme>
     <theme name="JWT Release 1.4 - JWT in the SOA Development Cycle">
     	<description>JWT 1.4 will bring closer integration to SOA development cycle and governance, both within Eclipse SOA and the EasySOA (http://www.easysoa.org) repository.</description>
        <committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=CLOSED&amp;classification=SOA&amp;product=JWT&amp;component=WE&amp;version=1.4.0"></committed>
        <proposed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=UNCONFIRMED&amp;bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED&amp;bug_status=VERIFIED&amp;classification=SOA&amp;product=JWT&amp;version=1.4.0"></proposed>     
     </theme>
    <theme name="Support for Eclipse 3.8 workbench">
          <description>
                We aim to support both Eclipse 3.8 and 4.2 platforms with the goal of completing the switch to
                4.2 in the next release. The 4.2 support is intended to provide a fully featured JWT platform although we expect
                minor issues, thereby making 3.8 the preferred platform for the 1.2 release. We will accept bug reports for either
                3.8 or 4.2 with a special focus on 4.2 compatibility issues.
          </description>
       </theme>
   </themes_and_priorities>
</plan>

