<?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>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);
?>
