<?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, big data, bigdata";
	$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 1.3</h3>
			<p>
			This release was published on April, 15th 2015.
			</p>
			<ul>
				<li>Scripting Engine for using JavaScript scripts for synchronous data processing.</li>												
				<li>Solr-4 integration including Cloud-, Http- and EmbeddedSolrServer implementations and support of all available Solr-4 search/indexing features</li>
			</ul>
		
			<h3>SMILA Version 1.2</h3>
			<p>
			This release was published on April, 17th 2013.
			</p>
			<ul>
				<li>Apache Tika integration - extracting text from binary content</li>								
				<li>JDBC-Crawler: Splitting functionality for scaling</li>
				<li>Web-Crawling enhancements (robots.txt, boilerpipe integration)</li>
				<li>Remote-Crawling</li>
				<li>Cluster setup tutorial</li>
			</ul>
		
		    <h3>SMILA Version 1.1</h3>
			<p>
			This release was published on July, 11th 2012.
			</p>
			<ul>
				<li>Migration of web, file, JDBC and feed crawler implementations to self-scaling ETL</li>
				<li>Solr 3.5 integration</li>
			</ul>
		
			<h3>SMILA Version 1.0</h3>
			<p>
			This release was published on February, 2nd 2012.
			</p>
			<ul>
				<li>Self-scaling ETL</li>
			</ul>

			<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);
?>
