<?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());
	
	$pageTitle 		= "SMILA - Unified Information Access Architecture";
	$pageKeywords	= "SMILA, Unified Information Access Architecture, unstructured information management, information logistics, semantic web, framework, platform, architecture, eclipse, data, unstructured data, semantics, semantic, project, open source, information, workflow, data connectors, storage, search, search engine, integration, message queue, connectivity, delta indexing, ontology management, ontology, osgi, runtime, scalability, performance, cloud, cluster, commodity hardware deployment, java, remote, metadata, binary storage, record storage, record";
	$pageAuthor		= "Igor Novakovic";

	# Paste your HTML content between the EOHTML markers!
	$html = <<<EOHTML

	<div id="midcolumn">
		<p>
			<img src="logo/SMILA_Tagline_Large.jpg" alt="SMILA logo" width="316" height="90">
		</p>
		<h2>Unleashing the potential of unstructured data sources</h2>
		<p>
			The amount and diversity of information is growing exponentially, mainly in the area of unstructured data,
			like emails, text files, blogs, images etc. Poor data accessibility, user rights integration and the lack of
			semantic meta data are constraining factors for building next generation enterprise search and other document
			centric applications. Missing standards result in proprietary solutions with huge short and long term cost.
		</p>
		<p>
			<b>SMILA</b> is an extensible framework for building search solutions to access unstructured information in
			the enterprise. Besides providing essential infrastructure components and services, SMILA also delivers
			ready-to-use add-on components, like connectors to most relevant data sources. Using the framework as their
			basis will enable developers to concentrate on the creation of higher value solutions, like semantic driven
			applications etc.
		</p>
		<h2>SMILA Architecture</h2>
		<p>
			<a href="http://wiki.eclipse.org/SMILA/Architecture_Overview">
				<img src="images/SMILA_Architecture_Overview.png" alt="SMILA Architecture Overview" align="middle" width="495" height="396">
			</a>
		</p>
		<div class="homeitem3col">
			<h3>News</h3>
			<h4>Meet us at CeBIT 2012, Hall  26, <a href="http://www.theseus-programm.de/de/cebit_2012.php" target="_blank">Theseus Program Booth</a> and join our tutorials</h4>
			<p>
				This year not only that you will be able to meet and talk to us, but we will also organize two 
				<a href="http://www.theseus-programm.de/documents/CeBIT2012-SMILA-Tutorial.pdf" target="_blank">SMILA tutorials</a> on 8th and 9th March starting both at 2PM.
				The participation is free but the number of participants is limited so make sure to register early at innovationszentrum@theseus-programm.de. 
			</p>
			<h4>SMILA 1.0 released!</h4>
			<p>
				We are happy to announce that after almost four years of development, SMILA finally graduated and left the incubator. There is only one major feature this time: Self-scalable ETL. 
				But since this is our first major release, the emphasis is on the API stability and longevity. Thanks to all committers, contributors, and users of SMILA for their contributions and support!
				As always, we are kindly asking you to try it out and give us your feedback. Enjoy!
			</p>
			<h4>Release 0.9 is out!</h4>
			<p>
				Our third official release is out! This release brings two new features: The new asynchronous workflows and REST APIs of major core components. Besides 
				that we also provided a proof of concept for running BPEL designer on RAP. Please try it out and give us your feedback. Enjoy!
			</p>
			<h4>SMILA tutorial at LWA 2011</h4>
			<p>
				This year we were also invited to LWA. So if you like to get some deeper insights in SMILA's architecture and gain some practical experience in
				writing components for SMILA, then we kindly invite you to take part in our tutorial
				<a href="http://lwa2011.dke-research.de/index.php/program/tutorials/81-smila-tutorial.html" target="_blank">Mastering Unstructured Information with SMILA - the Unified Information Access Architecture</a>
				at
				<a href="http://lwa2011.dke-research.de/" target="_blank">LWA 2011</a>.
			</p>
			<h4>0.9 M1 is out!</h4>
			<p>
				Today on 12th September we have published our first milestone of the upcoming release 0.9. The major new features are the
				new asynchronous workflows and REST APIs of major core components. As always, please try it out and give us your feedback.
			</p>
			<h4>Second Eclipse DemoCamp in Kaiserslautern, Germany</h4>
			<p>
				On the 24th of November the second Eclipse DemoCamp in Kaiserslautern, Germany will take place. As always,
				anything related to Eclipse projects is welcome. Come, listen and network:
				<a href="http://wiki.eclipse.org/Eclipse_DemoCamps_November_2011/Kaiserslautern" target="_blank">Eclipse DemoCamp 2011 in Kaiserslautern, Germany</a>.
			</p>
			<h4>Release 0.8 is out!</h4>
			<p>
				Our second official release is finally out! This release brings two new features: The extension of BPEL designer for comfortably 
				editing SMILA workflows and the	simplification of the data model. Please try it out and give us your feedback. Enjoy!
			</p>
			<h4>0.8 M1 is out!</h4>
			<p>
				As planned, today on 31st March we have published our first milestone of the upcoming release 0.8. The major new features are the
				BPEL editor extensions and the new and simplified data model. As always, please try it out and give us your feedback.
			</p>
			<h4>SMILA finally got a logo!</h4>
			<p>
				Thanks to community contribution and a public vote SMILA has finally got its own logo. We hope you'll like it as much as we do.
			</p>
			<h4>SMILA has a new tagline: Unified Information Access Architecture</h4>
			<p>
				Since the original tagline was not accepted well by the community we have chosen a new one which hopefully better reflects SMILA's nature.
			</p>
			<p>
				This year we were lucky to get two talks dealing with SMILA: 
				<a href="http://www.eclipsecon.org/summiteurope2010/sessions/?page=sessions&id=1832" target="_blank">Building Cloud Applications with Eclipse</a> 
				which demonstrates the powerful symbiosis of several Eclipse projects (SMILA, g-Eclipse, RAP and p2) when it comes to building and managing a
				search application deployed in the cloud and  
				<a href="http://www.eclipsecon.org/summiteurope2010/sessions/?page=sessions&id=1805" target="_blank">SMILA - The Search Framework</a>
				which provides a brief overview of the first official release SMILA 0.7 and demonstrates some of its features in live action. 
			</p>
			<h4>Meet us at CeBIT 2011, Hall  9, Theseus Program Booth!</h4>
			<h4>Meet us at Eclipse Summit Europe 2010 and see SMILA in the Cloud!</h4>
			<p>
				This year we were lucky to get two talks dealing with SMILA: 
				<a href="http://www.eclipsecon.org/summiteurope2010/sessions/?page=sessions&id=1832" target="_blank">Building Cloud Applications with Eclipse</a> 
				which demonstrates the powerful symbiosis of several Eclipse projects (SMILA, g-Eclipse, RAP and p2) when it comes to building and managing a
				search application deployed in the cloud and  
				<a href="http://www.eclipsecon.org/summiteurope2010/sessions/?page=sessions&id=1805" target="_blank">SMILA - The Search Framework</a>
				which provides a brief overview of the first official release SMILA 0.7 and demonstrates some of its features in live action. 
			</p>
			<h4>SMILA tutorial at LWA 2010</h4>
			<p>
				Since our tutorial at LWA 2009 awoke a lot of interest, we are invited to hold another one on this 
				years LWA. So if you missed last years tutorial but still would like to get some deeper insights in current SMILA development 
				and gain some practical experience in writing components for SMILA, then we kindly invite you to take part in our tutorial
				<a href="http://www.kde.cs.uni-kassel.de/conf/lwa10/tutorial.html" target="_blank">Mastering Unstructured Information with SMILA - the SeMantic Information Logistics Architecture</a>
				at
				<a href="http://www.kde.cs.uni-kassel.de/conf/lwa10" target="_blank">LWA 2010</a>.
			</p>
			<h4>SMILA's first release is finally out!</h4>
			<p>
				After more than 20 months of intensive development and completion of an extreme long IP process (we broke all 
				the records by submitting more than the hundred CQs), we have fulfilled all the preconditions and finally got 
				the permission to publish our first release with the version number 0.7. Besides very good stability this 
				release brings also two new features: Web Service API support and Apache Solr integration (access to Apache 
				Solr's REST API). As always, please try it out and give us your feedback. Enjoy!

			</p>
			<h4>Meet us at EclipseCon 2010 and see SMILA in the Cloud!</h4>
			<p>
				Since one of SMILA's key features is the parallelization of processes/workflows than the normal thing to do
				would be to deploy SMILA in some kind of distributed environment like the Cloud. For this year's EclipseCon talk
				<a href="http://www.eclipsecon.org/2010/sessions/?page=sessions&id=1388" target="_blank">Searching the Cloud - the EclipseRT Umbrella!</a>
				we joined forces with our g-Eclipse and RAP friends and built a search application that runs in Amazon's EC2.
				If you are visiting	EclipseCon 2010 or will be somewhere near Santa Clara, CA on Monday next week, we kindly
				invite you to come and see how a powerful cloud applications can be built by leveraging existing EclipseRT and
				Eclipse Technology projects.
			</p>
			<h4>SMILA @ Eclipse DemoCamps in Germany</h4>
			<p>
				In the last weeks we have shown several demos with/about SMILA at Eclipse DemoCamps in Germany. Please have a look at the following urls:
			<ul>
				<li><a href="http://wiki.eclipse.org/Eclipse_DemoCamps_November_2009/Braunschweig/Hanover" target="_blank"> Eclipse DemoCamp in Braunschweig</a></li>
				<li><a href="http://wiki.eclipse.org/Eclipse_DemoCamps_November_2009/Kaiserslautern" target="_blank"> Eclipse DemoCamp in Kaiserslautern</a></li>
				<li><a href="http://wiki.eclipse.org/Eclipse_DemoCamps_November_2009/Berlin" target="_blank"> Eclipse DemoCamp in Berlin</a></li>
				<li><a href="http://wiki.eclipse.org/Eclipse_DemoCamps_November_2009/Karlsruhe" target="_blank"> Eclipse DemoCamp in Karlsruhe</a></li>
			</ul>
			</p>
			<h4>First Eclipse DemoCamp in Kaiserslautern, Germany</h4>
			<p>
				On the 26th of November the first Eclipse DemoCamp in Kaiserslautern, Germany will take place. Join us.
				Anything related to Eclipse projects is welcome. May it be a slideware or hands on. Just curious? Come,
				listen and network:
				<a href="http://wiki.eclipse.org/Eclipse_DemoCamps_November_2009/Kaiserslautern" target="_blank">Eclipse DemoCamp in Kaiserslautern, Germany</a>.
			</p>
			<h4>SMILA tutorial at LWA 2009!</h4>
			<p>
				If you would like to get some deeper understanding of SMILA's architecture and gain some practical experience in
				writing components for SMILA, then we kindly invite you to take part in our tutorial
				<a href="http://lwa09.informatik.tu-darmstadt.de/bin/view/LWA/Tutorial" target="_blank">Mastering Unstructured Information with SMILA</a>
				at
				<a href="http://lwa09.informatik.tu-darmstadt.de/bin/view/LWA/WebHome" target="_blank">LWA 2009</a>.
			</p>
			<h4>Meet us at Eclipse Summit Europe 2009 and see SMILA in action!</h4>
			<p>
				You were not able to visit EclipseCon 2009 and see our talk? No problem! In our next talk
				<a href="https://www.eclipsecon.org/summiteurope2009/sessions?id=876" target="_blank">SMILA - The Integration Framework</a>
				at Eclipse Summit Europe 2009 we will give you an update on the latest development efforts and present you
				several demo applications realized by integrating powerful recognition and extraction technologies in SMILA.
			</p>
			<h4>0.5 M3 is out!</h4>
			<p>
				As announced, today on 31st July we have published our third milestone 0.5 M3. The major new features are the
				bulk operations (to increase the throughput of data), two new data source connectors: XML and Job file and an
				alternative implementation of the binary storage based on JPA. Besides that we use now Eclipse 3.5 (Galileo)
				as a base for SMILA and we switched the development	to JDK 6. As always, please try it out and give us your feedback.
			</p>
			<h4>0.5 M2 is out!</h4>
			<p>
				Right on time, today on 29th May we have published our second milestone 0.5 M2. The major new features are the
				compound management and two new data source connectors: RSS and Atom agent. So give it a try and tell us what
				you think.
			</p>
			<h4>Our EclipseCon's session recording is now available on Eclipse Live</h4>
			<p>
				You couldn't make it to our EclipseCon session? No problem!
				A couple of days ago Eclipse foundation released the recording of our talk
				<a href="http://live.eclipse.org/node/734" target="_blank">SMILA - make sense of your data</a>.
			</p>
			<h4>SMILA's first milestone is out!</h4>
			<p>
				Just as planed, today on 23rd March we have published our first milestone 0.5 M1. So if you are interested in SMILA
				please try it out and give us your feedback.
			</p>
			<h4>Meet us at EclipseCon 2009 and see SMILA in action!</h4>
			<p>
				In case that you'll be visiting EclipseCon 2009 we kindly invite you to come to our long talk
				<a href="http://www.eclipsecon.org/2009/sessions?id=398" target="_blank">SMILA - make sense of your data</a>. <br>
				Apart from giving the short introduction to the project, the focus of this talk will be the demonstration of
				several example use cases which can be realized with SMILA. In brief: We wanted this time to concentrate on
				really cool stuff - for example indexing and search of chemical compounds (molecules) and their visualization.
			</p>
			<h4>SMILA initiative gains new supporters</h4>
			<p>
				After getting support from the German Research Center for Artificial Intelligence
				(<a href="http://www.dfki.de/" target="_blank">DFKI</a>) right after SMILA's creation review, now we are
				very pleased to announce that SMILA has got two new supporters: <a href="http://www.attensity.com/" target="_blank">Attensity</a>
				and <a href="http://www.living-e.de/" target="_blank">living-e</a>. <br>
				<br>
				This is the short excerpt from the official press release:<br>
				<i>
				"Retroactive to January 1, 2009, the initiative gains two significant semantic technology partners
				on the occasion of the Open Source Meets Business Congress (27. - 29. January 2009, Nuremberg, Germany)
				with Attensity, Inc., from Palo Alto, California and living-e AG from Karlsruhe, Germany. Both companies
				will continue development of their products based on the SMILA open architecture and infrastructure
				standard - Attensity with semantic text analytics technologies and living-e with its self-learning
				solutions for automated, intelligent responses to e-mails, SMS, faxes and letters."
				</i>
			</p>
		</div>
	</div>

EOHTML;

	include('rightColumn.php');
	$html .= $rightColumn;

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