<?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 (SeMantic Information Logistics Architecture)";
	$pageKeywords	= "SMILA, unstructured information management, information logistics, semantic web, framework, platform, architecture, eclipse";
	$pageAuthor		= "Igor Novakovic";

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

	<div id="midcolumn">
		<h1>SMILA - SeMantic Information Logistics Architecture</h1>
		<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, <b>SMILA</b> 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">
			</a>
		</p>
		<div class="homeitem3col">
			<h3>News</h3>
			<h4>SMILA @ Eclipse DemoCamps in Germany</h4>
			<p>
				In the last weeks we have shown severals 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, than 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>

	<div id="rightcolumn">
    	<div class="sideitem">
       		<h6>Incubation</h6><p>
       		<div align="center">
         		<a href="/projects/what-is-incubation.php">
           		<img align="center" src="/images/egg-incubation.png" border="0"/></a>
       		</div>
     	</div>
	  	<div class="sideitem">
			<h6>Links</h6>
			<ul>
				<li><a href="http://wiki.eclipse.org/SMILA" target="_blank">Wiki</a></li>
				<li><a href="http://www.eclipse.org/proposals/eilf/SMILA_Creation_Review.pdf" target="_blank">Creation Review</a></li>
				<li><a href="http://www.eclipse.org/proposals/eilf" target="_blank">Project proposal</a></li>
				<li><a href="http://live.eclipse.org/node/734" target="_blank">EclipseCon 09: SMILA - Make Sense of your Data</a></li>
				<li><a href="http://live.eclipse.org/node/617" target="_blank">Webinar</a></li>
			</ul>
		</div>
		<div class="sideitem">
			<h6>Meet us at</h6>
			<div align="center">
 				<a href="http://www.eclipsesummit.org/"><img border="0"
 					src="http://www.eclipsecon.org/summiteurope2009/static/image/friends/125x125_generic.gif"
 					height="125" width="125" alt="Eclipse Summit Europe 2009"/>
 				</a>
 			</div>
		</div>
	</div>

EOHTML;


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