<?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("_projectCommon.php");    # All on the same line to unclutter the user's desktop'

	#
	# Begin: page-specific settings.  Change these. 
	$pageTitle 		= "Helios In Action";
	$pageKeywords	= "eclipse, helios, action, webinar, release, virtual conference";
	$pageAuthor		= "Lynn Gayowski";
	
	# Add page-specific Nav bars here
	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank)
	# $Nav->addCustomNav("My Link", "mypage.php", "_self");
	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank");

	# End: page-specific settings
	#
	
	# Paste your HTML content between the EOHTML markers!	

ob_start();
?>		

<style type="text/css">
.switchcontent{display:none;}
</style>

<script type="text/javascript">
function switchMenu(obj) {
	var el = document.getElementById(obj);
	el.style.display = ( el.style.display != "block" )? 'block':'none' 
}
</script>	
	
	<style>
		.paddedlist li {	padding-bottom:7px;	}
		td a { color:#000; }		
		.title { font-size:14px; color:#7036be; }
		.recordingtitle { color:#000; }
		.timezone { font-size:10px; text-decoration:underline; }
	</style>	

	<div id="maincontent">
	<div id="fullcolumn">
	<div id="midcolumn">
	
		<h1><?= $pageTitle ?></h1>

      	<p>
		On June 24 and June 28, the Eclipse Foundation presented Helios In Action - a virtual
      	conference where attendees could interact with project leads involved in the release and see
      	demos of the new features. The annual simultaneous release has now grown to 39 projects
      	with over 33 million lines of code, contributed by committers around the world.  With such
      	a large global community, this is our way of bringing Helios to you!
      	</p>

		<h2>Part 1 - June 24</h2>

		<p>
			<a class="title" href="javascript:switchMenu('linux');" title="Description">
			<img src="http://www.eclipse.org/newsgroups/images/plus.gif" alt="Description" title="Description">
			Linux Tools</a><br>
			<a class="recordingtitle" href="http://live.eclipse.org/node/916" target="blank">Watch the recording</a><br>
			Andrew Overholt (Red Hat)
		</p>			
		<p>
			<div id="linux" class="switchcontent">
			The Linux Tools project aims to bring a full-featured C and C++ IDE to Linux developers. It
			builds on the source editing and debugging features of the CDT and integrates popular
			native development tools such as the GNU Autotools, Valgrind, OProfile, RPM, SystemTap,
			GCov, GProf and LTTng. Current projects include Autotools build integration, a Valgrind
			heap usage analysis tool and an OProfile call profiling tool. It also has projects
			implementing LTTng trace viewers and analyzers.
			<br><br>
			Linux Tools also provides a place for Linux distributions to collaboratively overcome issues
			surrounding distribution packaging of Eclipse technology. The project produces both best
			practices and tools related to packaging. Since the 0.3.0 release, one of the features is
			a source archive of the Eclipse SDK that can be used by all Linux distributions building
			and distributing it. 
			<br><br>
			</div>
		</p>
		
		<p>

			<a class="title" href="javascript:switchMenu('runtime');" title="Description">
			<img src="http://www.eclipse.org/newsgroups/images/plus.gif" alt="Description" title="Description">
			Eclipse Runtime (RT)</a><br>
			<a class="recordingtitle" href="http://live.eclipse.org/node/917" target="blank">Watch the recording</a><br>
			Jeff McAffer (EclipseSource)
		</p>
		<p>												
			<div id="runtime" class="switchcontent">
			With the Eclipse community expanding its offerings in the Runtime space (EclipseRT),
			many developers are interested in figuring out what this means and how they can
			leverage EclipseRT projects like Equinox, Jetty and EclipseLink. Join Jeff McAffer,
			the RT PMC and Equinox co-lead, for a review of EclipseRT projects and the new
			features they bring to Helios.  	
 			<br><br>
			</div>
		</p>
		
		<p>
			<a  class="title"href="javascript:switchMenu('egit');" title="Description">
			<img src="http://www.eclipse.org/newsgroups/images/plus.gif" alt="Description" title="Description">
			Eclipse Git Team Provider</a><br>
			<a class="recordingtitle" href="http://live.eclipse.org/node/918" target="blank">Watch the recording</a><br>
			Chris Aniszczyk (Red Hat)				
		</p>
		<p>
															
			<div id="egit" class="switchcontent">
			EGit is an Eclipse Team provider for the Git version control system. Git is a distributed
			SCM, which means every developer has a full copy of all history of every revision of the
			code, making queries against the history very fast and versatile. 
			<br><br>
			The EGit project is implementing Eclipse tooling on top of the JGit Java implementation of
			Git. 
			<br><br>
			</div>
		</p>
		
		<p>
			<a class="title" href="javascript:switchMenu('jsdt');" title="Description">
			<img src="http://www.eclipse.org/newsgroups/images/plus.gif" alt="Description" title="Description">
			JavaScript Development Tools</a><br>
			<a class="recordingtitle" href="http://live.eclipse.org/node/919" target="blank">Watch the recording</a><br>
			Simon Kaegi (IBM)
		<p>
		<p>										
			<div id="jsdt" class="switchcontent">
			With the advent of Web 2.0, JavaScript have become central in the creation of a richer user
			experience on the Web. Its use has shifted from the creation of simple functions and events
			handlers to the creation of complex Web Application frameworks. Such complexity made it crucial
			that a more sophisticated set of tools become available on Eclipse.
			<br><br>
			JSDT's goal is to develop an IDE for JavaScript applications, with full support for editing, search,
			and refactoring. The functionality of the JavaScript Development Tools is heavily based on the
			functionality of the Java Development Tools, but since JavaScript is not a fully typed or
			class-based language, it is not possible to provide 100% of the JDT functionality. JSDT is
			extensible in that it can be (is) plugged into the HTML and JSP editors within WTP as well as being
			architected with pluggable type inference and completion proposals in mind. The inference engine is
			used to determine type and class structures from the JavaScript code, enabling as much of the JDT
			equivalent functionality as possible, while still allowing adopters to contribute to the process for
			atypical or extended scenarios. 
			<br><br>
			</div>
		</p>
		
		<p>

			<a  class="title" href="javascript:switchMenu('javaee');" title="Description">
			<img src="http://www.eclipse.org/newsgroups/images/plus.gif" alt="Description" title="Description">
			Java EE Standards Support from Web Tools</a><br>
			<a class="recordingtitle" href="http://live.eclipse.org/node/920" target="blank">Watch the recording</a><br>
			Naci Dai (eteration)
		</p>
		<p>													
			<div id="javaee" class="switchcontent">
			The Web Tool Platform (WTP) project provides extensible frameworks and exemplary tools
			to build Web and Java EE applications.  For Helios, the Web Tools Platform will be
			up-to-date with supporting the latest Java EE 6 specification.  Join this session to
			see what's newly available for Java EE development.
			<br><br>
			</div>
		</p>
		
		<p>
			<a class="title" href="javascript:switchMenu('mpc');" title="Description">
			<img src="http://www.eclipse.org/newsgroups/images/plus.gif" alt="Description" title="Description">
			Marketplace Client & p2 Discovery Connector</a><br>
			<a class="recordingtitle" href="http://live.eclipse.org/node/921" target="blank">Watch the recording</a><br>
			Ian Skerrett (Eclipse Foundation)
		</p>
		<p>													
			<div id="mpc" class="switchcontent">
			The Eclipse community has hundreds, if not thousands, of third-party plugins that users can
			add to their Eclipse installation. Unfortunately, there is not easy way to discover and
			install these solutions from within Eclipse.
			<br><br>
			The Eclipse Foundation has recently launched a new website, called Eclipse Marketplace, that
			provides a listing of Eclipse-based solutions. The listings allow each solution provider to
			specify a p2 update site for their solution. MPC provides a tight install integration
			between the Eclipse workspace and Eclipse Marketplace, plus other third party solution
			listings.  	 
			<br><br>
			</div>
		</p>

		<h2>Part 2 - June 28</h2>
		
		<p>
			<a class="title" href="javascript:switchMenu('top10');" title="Description">
			<img src="http://www.eclipse.org/newsgroups/images/plus.gif" alt="Description" title="Description">
			10 Reasons to Install Helios</a><br>
			<a class="recordingtitle" href="http://live.eclipse.org/node/924" target="blank">Watch the recording</a><br>
			Ian Bull (EclipseSource)
		</p>
		<p>
													
			<div id="top10" class="switchcontent">
			Ian Bull, component lead for Zest and the Eclipse Visualization Framework and committer on
			the Equinox p2 project, presents the top 10 features in Helios he is most excited about. 	
 			<br><br>
			</div>
		</p>
		
		<p>
			<a  class="title" href="javascript:switchMenu('emf');" title="Description">
			<img src="http://www.eclipse.org/newsgroups/images/plus.gif" alt="Description" title="Description">
			EMF on the Web</a><br>
			<a class="recordingtitle" href="http://live.eclipse.org/node/925" target="blank">Watch the recording</a><br>
			Kenn Hussey (Cloudsmith)
		</p>
		<p>												
			<div id="emf" class="switchcontent">
			The Eclipse Modeling Framework (EMF) has long provided a code generation facility
			capable of emitting everything needed to get started with building a complete
			application for EMF-based domain models. It includes a GUI from which options can be
			specified and code generators can be invoked, to produce a model API, edit support,
			unit tests and a sample editor.
			<br><br>
			With the Helios release of Eclipse, this facility moves beyond the boundaries of the
			Eclipse platform, and desktop applications in general, by adding support for the Rich
			Ajax Platform (RAP) and Google Web Toolkit (GWT). This session will demonstrate EMF's
			support for these application runtime platforms and highlight differences in the
			code generated for each.
			<br><br>	
			</div>
		</p>
		
		<p>
			<a class="title" href="javascript:switchMenu('modeling');" title="Description">
			<img src="http://www.eclipse.org/newsgroups/images/plus.gif" alt="Description" title="Description">
			Modeling</a><br>
			<a class="recordingtitle" href="http://live.eclipse.org/node/926" target="blank">Watch the recording</a><br>
			Ed Merks, Cedric Brun (Obeo), Sebastian Zarnekow (itemis)
		</p>
		<p>										
			<div id="modeling" class="switchcontent">
			The Eclipse Modeling Project is one of the most active projects within the Eclipse
			community. Ed Merks will give a quick overview of the Modeling projects in Helios.  Then
			Cedric Brun will demo Acceleo and Sebastian Zarnekow will show Xtext.
			<br><br>
			</div>
		</p>	

		<h2>Coming Soon</h2>

		<p>
			<a class="title" href="javascript:switchMenu('mylyn');" title="Description">
			<img src="http://www.eclipse.org/newsgroups/images/plus.gif" alt="Description" title="Description">
			Mylyn</a><br>
			<a class="recordingtitle" href="http://spreadsheets.google.com/viewform?formkey=dHZsdUlVN1ZzRTNlWnJyS2pubHNqbXc6MQ" target="blank">Register</a><br>
			Mik Kersten (Tasktop Technologies)
		</p>
		<p>
			July 20, 2010<br>
			9:00am PDT / 12:00pm EDT / 4:00pm UTC / 6:00pm CEST<br>
			<span class="timezone"><a href="http://www.timeanddate.com/worldclock/fixedtime.html?month=7&day=20&year=2010&hour=16&min=00&sec=0&p1=0">Convert to other time zones</a></span></br>			
		</p>
		<p>
			<div id="mylyn" class="switchcontent">
			This session will demonstrate the most noteworthy features and enhancements for Mylyn
			in the Helios release, such as enhanced support for Agile development, code reviews,
			social technologies and continuous integration systems. Mik Kersten, lead of the Mylyn
			project will showcase the latest and greatest task-focused features and APIs.	
 			<br><br>
			</div>
		</p>			

 	<br><br>
	</div>
	</div>
</div>

<?php
	$html = ob_get_contents();
	ob_end_clean();

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