<?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="technology.jwt" version="1.0"></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 is currently working towards its graduation release. Till then we won't have milestones for a single release, but have smaller releases instead. Graduation release is planned together with the Helios 2010 release.</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>
	</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.</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?action=wrap&amp;bug_file_loc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_id=&amp;bug_status=RESOLVED&amp;bug_status=CLOSED&amp;bugidtype=include&amp;chfieldfrom=&amp;chfieldto=Now&amp;chfieldvalue=&amp;classification=Technology&amp;email1=&amp;email2=&amp;emailtype1=substring&amp;emailtype2=substring&amp;field0-0-0=noop&amp;keywords=&amp;keywords_type=allwords&amp;long_desc=&amp;long_desc_type=allwordssubstr&amp;product=JWT&amp;short_desc=&amp;short_desc_type=allwordssubstr&amp;status_whiteboard=&amp;status_whiteboard_type=allwordssubstr&amp;type0-0-0=noop&amp;value0-0-0=&amp;votes=&amp;=&amp;component=WE&amp;version=0.5.0"></committed>
        <proposed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?action=wrap&amp;bug_file_loc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_id=&amp;bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED&amp;bug_status=VERIFIED&amp;bugidtype=include&amp;chfieldfrom=&amp;chfieldto=Now&amp;chfieldvalue=&amp;classification=Technology&amp;email1=&amp;email2=&amp;emailtype1=substring&amp;emailtype2=substring&amp;field0-0-0=noop&amp;keywords=&amp;keywords_type=allwords&amp;long_desc=&amp;long_desc_type=allwordssubstr&amp;product=JWT&amp;short_desc=&amp;short_desc_type=allwordssubstr&amp;status_whiteboard=&amp;status_whiteboard_type=allwordssubstr&amp;type0-0-0=noop&amp;value0-0-0=&amp;votes=&amp;=&amp;component=WE&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?action=wrap&amp;bug_file_loc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_id=&amp;bug_status=RESOLVED&amp;bug_status=CLOSED&amp;bugidtype=include&amp;chfieldfrom=&amp;chfieldto=Now&amp;chfieldvalue=&amp;classification=Technology&amp;email1=&amp;email2=&amp;emailtype1=substring&amp;emailtype2=substring&amp;field0-0-0=noop&amp;keywords=&amp;keywords_type=allwords&amp;long_desc=&amp;long_desc_type=allwordssubstr&amp;product=JWT&amp;short_desc=&amp;short_desc_type=allwordssubstr&amp;status_whiteboard=&amp;status_whiteboard_type=allwordssubstr&amp;type0-0-0=noop&amp;value0-0-0=&amp;votes=&amp;=&amp;version=0.6.0"></committed>
        <proposed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?action=wrap&amp;bug_file_loc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_id=&amp;bug_status=UNCONFIRMED&amp;bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED&amp;bug_status=VERIFIED&amp;bugidtype=include&amp;chfieldfrom=&amp;chfieldto=Now&amp;chfieldvalue=&amp;classification=Technology&amp;email1=&amp;email2=&amp;emailtype1=substring&amp;emailtype2=substring&amp;field0-0-0=noop&amp;keywords=&amp;keywords_type=allwords&amp;long_desc=&amp;long_desc_type=allwordssubstr&amp;product=JWT&amp;short_desc=&amp;short_desc_type=allwordssubstr&amp;status_whiteboard=&amp;status_whiteboard_type=allwordssubstr&amp;type0-0-0=noop&amp;value0-0-0=&amp;votes=&amp;=&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?action=wrap&amp;bug_file_loc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_id=&amp;bug_status=RESOLVED&amp;bug_status=CLOSED&amp;bugidtype=include&amp;chfieldfrom=&amp;chfieldto=Now&amp;chfieldvalue=&amp;classification=Technology&amp;email1=&amp;email2=&amp;emailtype1=substring&amp;emailtype2=substring&amp;field0-0-0=noop&amp;keywords=&amp;keywords_type=allwords&amp;long_desc=&amp;long_desc_type=allwordssubstr&amp;product=JWT&amp;short_desc=&amp;short_desc_type=allwordssubstr&amp;status_whiteboard=&amp;status_whiteboard_type=allwordssubstr&amp;type0-0-0=noop&amp;value0-0-0=&amp;votes=&amp;=&amp;version=0.7.0"></committed>
        <proposed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?action=wrap&amp;bug_file_loc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_id=&amp;bug_status=UNCONFIRMED&amp;bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED&amp;bug_status=VERIFIED&amp;bugidtype=include&amp;chfieldfrom=&amp;chfieldto=Now&amp;chfieldvalue=&amp;classification=Technology&amp;email1=&amp;email2=&amp;emailtype1=substring&amp;emailtype2=substring&amp;field0-0-0=noop&amp;keywords=&amp;keywords_type=allwords&amp;long_desc=&amp;long_desc_type=allwordssubstr&amp;product=JWT&amp;short_desc=&amp;short_desc_type=allwordssubstr&amp;status_whiteboard=&amp;status_whiteboard_type=allwordssubstr&amp;type0-0-0=noop&amp;value0-0-0=&amp;votes=&amp;=&amp;version=0.7.0"></proposed>     
     </theme>
     <theme name="JWT Release 1.0 - JWT for Users">
     	<description>JWT 1.0 will be our graduation release. It will come 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>
     </theme>
   </themes_and_priorities>
</plan>

