<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'

	#*****************************************************************************
	#
	# /newsarchive.php of Java Workflow Tooling (JWT)
	#
	# Author: 		Christian Saad
	# created:		2008-11-13
	#
	# Description: The older news page of the Java Workflow Tooling project
	#
	#
	#****************************************************************************
	
	#
	# Begin: page-specific settings.  Change these. 
	$pageTitle 		= "Eclipse Java Workflow Tooling (JWT)";
	$pageKeywords	= "JWT , Java Workflow Tooling Project, Workflow Editor, Workflow Administration and Monitoring, Eclipse";
	$pageAuthor		= "Christian Saad";
	
	# Add page-specific Nav bars here
	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)

	# End: page-specific settings
	#
		
	# Paste your HTML content between the EOHTML markers!	
	$html = <<<EOHTML

	<div id="midcolumn">
		<h1>Java Workflow Tooling (JWT)</h1>
		
		<div class="homeitem3col">
			<h3>News archive</h3>
					<p>

				<li><strong>June, 13th 2012:</strong>
        			Workflow models can have a life after design time: as published documentation. The <a href="http://www.easysoa.org/2012/06/publishing-models-documentation-at-eclipse-juno-democamp-grenoble/">EasySOA</a> team <a href="http://www.slideshare.net/mdutoo/eclipse-democamp-2012ecmv05pub">illustrated as much</a> for JWT at the <a href="http://wiki.eclipse.org/Eclipse_DemoCamps_Juno_2012/Grenoble">Eclipse DemoCamp Grenoble 2012</a> using a prototype EMF to <a href="https://www.oasis-open.org/committees/cmis/">CMIS</a> export.
				</li>
				<li><strong>June, 3rd 2012:</strong>
				You couldn't miss it: Juno is finally out! And as usual, JWT is part of the release. Version 1.2 include a brand-new SVG export feature, Eclipse 4 support <a href="http://wiki.eclipse.org/JWT_NewNoteworthy_1_2">and more</a>!
				As always, to install, just navigate to the "SOA Development" category in the <a href="http://download.eclipse.org/releases/juno/">Juno update site</a> and select JWT.
				</li>

				<li><strong>June, 28th 2011:</strong>
				At the <a href="http://wiki.eclipse.org/Eclipse_DemoCamps_Indigo_2011/Grenoble">Eclipse DemoCamp Grenoble 2011</a>, we gave a glimpse of our ongoing work with the <a href="http://www.github.com/easysoa">EasySOA</a> community to allow for <a href="http://www.slideshare.net/mdutoo/eclipse-democamp-eclipse-to-easysoa-core">Collaborative SOA from Eclipse to EasySOA Core</a>.
				</li>
				<li><strong>June, 22nd 2011:</strong>
				Indigo is here! And with it, the brand new Java Workflow Tooling 1.1 with lots of bugfixes to improve your JWT experience.
				To install, just navigate to the "SOA Development" category in the Indigo update site and select JWT.   
				</li>
				<li><strong>November, 24th 2010:</strong>
				JWT-integrating <a href="http://wiki.scarbo.ow2.org/xwiki/bin/view/OW2+Scarbo+1/2+Release+notes">OW2 Scarbo 1.2</a> is out ! Presented at the <a href="http://www.ow2.org/view/Events2010AnnualConference/">OW2 Conference 2010</a>, it gathers improvements garnered in production environments, and builds on the newly enriched <a href="http://wiki.eclipse.org/JWT_Monitoring#Workflow_State_Model">JWT WorkflowService query API</a>.
				</li>
				<li><strong>July, 1st 2010:</strong>
				Java Workflow Tooling has graduated to version 1.0! The new version is available from the official update site.  
				</li>	

				  <li><strong>June, 24th 2010:</strong>
				  HELIOS! It's out and JWT is again included in the Helios repositories (can be found in the SOA category).
				  Also, the JWT project will graduate to 1.0 in the next days!  
				  </li>		
				  <li><strong>March, 24th 2010:</strong>
				  EclipseCon "Painless (?) Metamodel Evolution" presentation <a href="http://www.slideshare.net/mdutoo/eclipsecon2010-painless-metamodel-evolution">slides</a>
				  </li>		
					<li><strong>March, 17th 2010:</strong>
					Project leads Marc Dutoo and Christian Saad will be co-presenters at the EclipseCon 2010 <a href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1207">Painless (?) Metamodel Evolution</a>.
					</li>
					<li><strong>March, 17th 2010:</strong>
					The move review to include JWT in Eclipse SOA was successful.   
					</li>
					<li><strong>December, 21st 2009:</strong>
					JWT 0.7 has now been released. It is available from the update site and will also be integrated into SR2 of <a href="http://www.eclipse.org/galileo/">Eclipse Galileo</a>. <a href="download.php">Download it now !</a>
					</li>		
					<li><strong>October, 20th 2009:</strong>
					JWT Configuration profiles will be featured at the <a href="http://www.eclipsecon.org/summiteurope2009/">Eclipse Summit Europe 2009</a> in the <a href="http://www.eclipsecon.org/summiteurope2009/sessions?id=935">Aspect-Oriented Modeling</a> talk (<a href="http://following-flo.blogspot.com/2009/10/aspect-oriented-modeling.html">more</a>) on October 28th in Ludwigsburg. Meet us there !
					</li>
					<li><strong>June, 24th 2009:</strong>
						JWT 0.6 has been released. It is available in <a href="http://www.eclipse.org/galileo/">Eclipse 3.5 (Galileo)</a>, the new yearly Eclipse distribution, out this very day. <a href="download.php">Download it now !</a>
					</li>					
					<li><strong>April, 23rd 2009:</strong> JWT was presented at Eclipse Forum Europe 2009 in Mainz, Germany. 
					Please find the <a href="/jwt/press/efe09/ExecuteYourProcesses_EFE09_final.pdf">presentation</a> and the shown screencasts (
					<a href="/jwt/press/efe09/01_FromBPMN2JWT.swf">1</a>,
					<a href="/jwt/press/efe09/02_ViewsExport.swf">2</a>,
					<a href="/jwt/press/efe09/03_Simulate.swf">3</a>,
					<a href="/jwt/press/efe09/04_DeployExecute.swf">4</a>).
					</li>
					<li><strong>June, 2nd 2009:</strong> on June, the 24th, JWT will be available bundled in the yearly <a href="http://www.eclipse.org/galileo/">Eclipse 3.5 (Galileo)</a> release.
					<a href="http://www.eclipse.org/downloads/?tab=developer">Try it now</a> ! ( <a href="http://wiki.eclipse.org/JWT_NewNoteworthy_0_6">New features</a> )</a>
					</li>
					<li><strong>March, 10th 2009:</strong> We now switched to the new Nova design of Eclipse as discussed in the last project telco.
					Such a telco happens every three weeks. If you are interested, have a look at our <a href="http://wiki.eclipse.org/JWT_Meetings">Wiki</a>.</li>
					<li><strong>January, 22nd 2009:</strong> JWT will be presented at <a href="http://www.eclipsecon.org/2009/sessions?id=292">EclipseCon</a> as well as at <a href="http://it-republik.de/konferenzen/efe/sessions/?tid=1077">Eclipse Forum Europe</a>.
					</li>
					<li><strong>January, 21st 2009:</strong> JWT will be part of the upcoming Eclipse release Galileo. <a href="http://wiki.eclipse.org/Galileo">Learn more</a> about Galileo. 
					</li>
					<li><strong>November, 27th 2008:</strong> JWT welcomes it's new mentor John Graham. John agreed to assist us in the Eclipse process, automating building tasks, etc. 
					</li>
					<li><strong>October, 29th 2008:</strong> JWT 0.5.0 has been released. It can be downloaded <a href="http://wiki.eclipse.org/JWT_Downloads#Java_Workflow_Tooling_0.5.0">here</a>.
					</li>
					<li><strong>October, 22th 2008:</strong> The release review for JWT 0.5.0 is scheduled for October, 29th.
					</li>
					<li><strong>September, 25th 2008:</strong> We are currently preparing the next release (0.5.0) which will include several improvements on the Workflow Editor as well as the first transformations. 
					Probably available in a few days.				
					</li>				
					<li><strong>March, 4th 2008:</strong> The first version (0.4.0) of the Workflow Editor is finally available as an Eclipse plugin. 
					Check it out at the <a href="components/we/index.php">Workflow Editor</a>-page.				
					</li>
					<li>On <strong>October, 11th 2007</strong> one of the project leads held a presentation about the JWT project at the
					Eclipse Summit Europe 2007. Find the presented slides <a href="/jwt/press/ese07/EclipseSummitEurope2007_JWT_presentation.ppt">here</a>.
				    </li>
				</p>
				<br/>
		</div>	
		<hr class="clearer">	
	</div>
	<div id="rightcolumn">
	</div>

EOHTML;


	# Generate the web page
	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
?>
