<?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'
	$pageTitle 		= "SMILA - Project Plan";
	$pageKeywords	= "SMILA, Unified Information Access Architecture, unstructured information management, information logistics, semantic web, framework, platform, eclipse";
	$pageAuthor		= "Igor Novakovic";

	# Paste your HTML content between the EOHTML markers!	
	$html = <<<EOHTML

	<div id="midcolumn">
		<h1>Project Plan - Archive</h1>
		<div class="homeitem3col">
			<h3>SMILA Version 0.9</h3>
			<p>
			This release was published on October, 27th 2011.
			</p>
			<ul>
				<li>Cluster readiness (RESTful APIs)</li>
				<li>New asynchronous workflows</li>
				<li>BPEL Designer on RAP (proof of concept)</li>
			</ul>
			<h3>SMILA Version 0.8</h3>
			<p>
			This release was published on May, 2nd 2011.
			</p>
			<ul>
				<li>BPEL editor extensions</li>
				<li>Simplification of data model</li>
			</ul>
		</div>
		<div class="homeitem3col">
			<h3>SMILA Version 0.7</h3>
			<p>
			This release was published on March 17th 2010.
			</p>
			<ul>
				<li>Web Service API support</li>
				<li>Solr integration (access to Apache Solr' REST API)</li>
			</ul>
		</div>
		<div class="homeitem3col">
			<h3>SMILA Version 0.5 M3</h3>
			<p>
			This milestone was published on July 31st 2009.
			</p>
			<ul>
				<li>Bulk operations (increasing the data throughput)</li>
				<li>More connectors (XML, Job file)</li>
				<li>Alternative binary storage implementation (based on JPA)</li>
			</ul>
		</div>
		<div class="homeitem3col">
			<h3>SMILA Version 0.5 M2</h3>
			<p>
			This milestone was published on May 29th 2009.
			</p>
			<ul>
				<li>Simple compound management</li>
				<li>More connectors (RSS & Atom)</li>
			</ul>
		</div>
		<div class="homeitem3col">
			<h3>SMILA Version 0.5 M1</h3>
			<p>
			This milestone was published on March 23rd 2009.
			</p>
			<ul>
				<li>Basic architecture settled and implemented</li>
				<li>Simple search application available</li>
				<li>Diverse connectors (File System, Web, DB)</li>
				<li>Incremental update</li>
				<li>Conception and implementation of search APIs</li>
				<li>Implementation of the security concept</li>
				<li>Ontology Service (introduction of semantic layer)</li>
			</ul>
		</div>
	</div>
	  
EOHTML;

	include('rightColumn.php');
	$html .= $rightColumn;

	# Generate the web page
	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
?>
