<?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";
	$pageKeywords	= "SMILA, unstructured information management, information logistics, semantic web, framework, platform, eclipse";
	$pageAuthor		= "Igor Novakovic";
	
	# Add page-specific Nav bars here
	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
	# $Nav->addNavSeparator("My Page Links", 	"downloads.php");
	# $Nav->addCustomNav("My Link", "mypage.php", "_self", 3);
	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 3);

	# End: page-specific settings
	#
		
	# 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>
			<img src="images/SMILA_Architecture_Overview.png" alt="SMILA Architecture Overview" align="middle">	  
		</p>
		<div class="homeitem3col">
			<h3>News</h3>
			<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> 
			<h4>Join us in our SMILA Webinar!</h4>
			<p>
				Do you want to see what are the latest developments in SMILA? Would you like to see the demo too?
				Then join us in our <a href="http://live.eclipse.org/node/617" target="_blank">SMILA Webinar</a> that will 
				be held on December 17th, 2008 17:00 CET and will last about one hour.
			</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">Project 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>
			</ul>
		</div>
		<div class="sideitem">
			<h6>Meet us at</h6>
			<div align="center">
 				<a href="http://www.eclipsecon.org/2009/"><img border="0"
 					src="http://www.eclipsecon.org/2009/static/image/image125x125.gif"
 					height="125" width="125" alt="EclipseCon 2009"/>
 				</a>
 			</div>			
		</div>	
	</div>	

EOHTML;


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