<?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 - Getting Started";
	$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>Getting started</h1>
		<p>
			This page will give you a quick overview of available resources and help you getting started with SMILA.
		</p>	
		<div class="homeitem3col">
			<h3>Installation</h3>
			<p>
			To install SMILA just pick up the latest stable build (a release or a milestone) from the 
			<a href="http://www.eclipse.org/smila/downloads.php">download page</a> for your platform and 
			simply unzip the contents in some arbitrary folder (e.g. "C:\SMILA").
			</p> 
			<p>
			You can now start SMILA by executing either SMILA.exe (Win32) or SMILA (Linux). For configuration
			options please consult the <a href="http://wiki.eclipse.org/SMILA" target="_blank">documentation in our wiki</a>.
			</p> 
		</div>
		<div class="homeitem3col">
			<h3>SMILA in 5 Minutes</h3>
			<p>
			Want to make your first steps in SMILA without reading too much of the documentation? 
			In our <a href="http://wiki.eclipse.org/SMILA/5_Minutes_Tutorial" target="_blank">5 Minutes Tutorial</a> 
			we will crawl a web source, process and index the data and provide a basic search.		
			</p>
		</div>			
		<div class="homeitem3col">
			<h3>Documentation</h3>
			<p>
			Full technical documentation as well as specification/concepts together with integration and 
			development guidelines can be found in our <a href="http://wiki.eclipse.org/SMILA" target="_blank">wiki</a>.
			</p> 
		</div>
		<div class="homeitem3col">
			<h3>Source code</h3>
			<p>
			SMILA's source code is being maintained in Git repositories: <br> 
			<a href="https://git.eclipse.org/c/smila">https://git.eclipse.org/c/smila</a><br>
			For using the source code in a development environment see description <a href="https://wiki.eclipse.org/SMILA/Documentation/HowTo/Howto_set_up_dev_environment">here</a>.			  
			</p> 
		</div>
	</div>
	  
EOHTML;

	include('rightColumn.php');
	$html .= $rightColumn;

	# Generate the web page
	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
?>
