<?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 		= "Open Source Executive Strategy Summit";
$pageKeywords	= "strategy, open source, eclipse, summit, europe";
$pageAuthor		= "Lynn Gayowski";

ob_start();
?>		
	<div id="maincontent">
		<div id="fullcolumn">
		<div id="midcolumn">
</head>

		<h1>Open Source Executive Strategy Summit</h1>
		<p>
			<strong>Tuesday, October 27, 2009 - 9:00am-5:00pm<br>
			<a href="http://en.nestor-hotels.de/nestor-Hotels/Ludwigsburg" target="blank">Nestor Hotel</a><br>
			Ludwigsburg, Germany<br>
			(co-located with Eclipse Summit Europe 2009)</strong>
		</p>
		
		<p>
			The Eclipse Foundation is organizing an invitation-only, one-day Open Source Executive Strategy
			Summit for  executives who are responsible for their organizations' open source strategy and
			participation. The purpose of event is to answer two questions: <br>
			&nbsp; &nbsp; &nbsp; 1. What Open Source Strategies Are Working Today?<br>
			&nbsp; &nbsp; &nbsp; 2. What Will Work in the Future?
		</p>
		 
		<p>
			The Summit will feature industry speakers, case studies and group discussions that analyze the
			different aspects of an open source strategy, including product strategy, licensing,
			development models and community building. Participants will have the opportunity to learn the
			success factors and challenges of existing open source strategies.
		</p>
		
		<h3>Sponsors</h3>
		<p>
			Thanks to the following companies for sponsoring the Strategy Summit:<br>
			<img src="http://www.eclipse.org/eclipse.org-common/themes/Nova/images/eclipse.png">	
		</p>
		
		<h3>Featured Speakers</h3>
		<p>
			The Summit agenda includes presentations and discussions. Featured speakers include:
	
		<p>
			<b>1. Lessons Learned by Building Ecosystems Modeled on Eclipse</b> &ndash;
			Tony Bailetti, Carleton University
		</p>
		<p>
			<b>Abstract:</b> The talk describes the key lessons learned from (i) designing the Coral CEA and Lead to
			Win ecosystems and (ii) using the maturity model for company engagement with ecosystems anchored
			around open source projects.  The objective of the Coral CEA ecosystem is to enable programmers to
			easily embed communications-related web services into IT applications and commercialize innovative
			applications globally.
			<br><br>	
			The worldwide market for communications enabled applications in 2010 is
			expected to be in the $1.6-$3.3 billion range. It has high potential for sustainable growth over
			the long term. The Lead to Win ecosystem is designed to create jobs and retain talent in a
			geographical region. The maturity model identifies the different ways a company can interact with
			an ecosystem. The talk is most relevant to senior managers interested in benefitting from their
			companies' interactions with open source projects.
		</p>
		<div style="float: left; margin-left: 0em; margin-right: 1em;">
		<img src="speakers/Tony_Bailetti.jpg" width="75" align="top" alt="Tony Bailetti" border="0"></div>
		<p>
			<b>About Tony:</b> Dr. Tony Bailetti is the Director of Ontario's Talent First Network and the
			Executive Director of Coral CEA. He founded Lead to Win in 2002 and was part of the faculty that
			delivered the original program. Professor Bailetti holds a tenured faculty appointment in both the
			Eric Sprott School of Business and the Department of Systems and Computer Engineering at Carleton
			University. His teaching and research interests are in commercialization of new technology. He was
			the Director of Carleton University's School of Business from 1981 to 1988 and worked at
			Bell-Northern Research (today a part of Nortel) from 1988 to 1992. Professor Bailetti has
			published in engineering management journals such as IEEE Transactions on Engineering Management,
			Journal of Product Innovation Management, Research Policy, and R&D Management. He won a Fulbright
			scholarship to study in the United States. In 1996 he won a Carleton University Teaching Award and
			in 2007 a Carleton University Leadership Breakthrough Award. 
		</p>
		<p>
			<b>2. Title coming soon</b> &ndash;
			Dr. Stephan Ferber, Robert Bosch GmbH
		</p>
		<p>
			<b>Abstract:</b> Coming soon
		</p>
		<p>
			<b>About Stephan:</b> Coming soon
		</p>
		<p>		
			<b>3. Insights into Open Source Experiences and the SAP Internal Evolution of Open Source</b> &ndash;
			Harald Mueller, SAP
		</p>
		<p>
			<b>Abstract:</b> This talk will give some insights into SAP and the internal evolution of open source and
			open standards. Several open source use cases will be presented and compared with SAP proprietary
			technologies. Furthermore, details on the SAP open source strategy and the engagement in open
			source projects will be presented. 
		</p>
		<div style="float: left; margin-left: 0em; margin-right: 1em;">
		<img src="speakers/Harald_Mueller.jpg" width="75" align="top" alt="Harald Mueler" border="0"></div>
		<p>
			<b>About Harald:</b> Harald is head of the Java Server &amp; Infrastructure development team at SAP.
			He is responsible for the Java EE Application Server and the Development Tools based on Eclipse.
			SAP is one of the founding members of the Eclipse Foundation and started as a so-called
			"Strategic Consumer". Since June 2009, SAP raised its membership level to "Strategic Developer",
			meaning that SAP will have at least 8 developers assigned full time to the Eclipse project. 
		</p>
		<p>
			<b>4. Open Source Software, the EPL and the Eclipse Ecosystem - Legal Aspects</b> &ndash;
			Martin Braun, WilmerHale
		</p>
		<p>
			<b>Abstract:</b> In comparison with other open source licenses, the EPL has a number of special
			characteristics. These characteristics make it particularly well-suited for the use in the
			enterprise. The way the Eclipse Foundation operates, especially the IP review process, are
			additional assets. The presentation will present the characteristics and legal aspects of the
			Eclipse ecosystem and the EPL.
		</p>
		<div style="float: left; margin-left: 0em; margin-right: 1em;">
		<img src="speakers/Martin_Braun.jpg" width="75" align="top" alt="Martin Braun" border="0"></div>
		<p>
			<b>About Martin:</b> Dr. Martin Braun (<a href="mailto:martin.braun@wilmerhale.com">martin.braun@wilmerhale.com</a>)
			is a lawyer in the Frankfurt office of the international law firm WilmerHale. His focus areas are
			software, information technology, outsourcing, data protection and compliance. He has been
			advising on all legal aspects of open source software for many years, where is is also regularly
			speaking and writing.
			<br><br>
		</p>		
		<p>
			<b>5. Open Source Software Strategies</b> &ndash;
			Markus L&ouml;effler, McKinsey & Company
		</p>
		<p>
			<b>Abstract:</b> Coming soon
		</p>
		<div style="float: left; margin-left: 0em; margin-right: 1em;">
		<img src="speakers/Markus_Loeffler.jpg" width="75" align="top" alt="Markus Loeffler" border="0"></div>
		<p>
			<b>About Markus:</b> Dr. Markus L&ouml;ffler is a Principal with McKinsey & Company, based in Stuttgart,
			Germany. He co-leads the Business Technology Office's global Technology Infrastructure practice
			and is a leader in the IT Architecture practice. He is a core team member of the newly established
			McKinsey Technology Initiative (MTI). This is a multi-year effort to explore the impact of
			technology on business and economy. Mr. L&ouml;ffler advises clients primarily in the industrial
			and high tech sectors. He focuses on technology-enabled business strategies, IT infrastructure and
			architechture, and IT performance management. Mr. L&ouml;ffler has lead IT infrastructure
			transformations for major users and providers of infrastructure. Before joining McKinsey, he was an
			assistant at the Max-Planck-Institute for Quantum Optics, Germany. Mr. L&ouml;ffler has a doctorate
			in physics.
		</p>
		
		<h3>Registration Information</h3>
		
		<p>
			Attendees must be executives of their organization. To request an invitation, please
			send an e-mail to <a href="mailto:strategysummit@eclipse.org">strategysummit@eclipse.org</a>.
		</p>
		
		<p>
			There is no cost to attend the Strategy Summit for Eclipse Foundation member companies, but you must
			pre-register.  A $500 registration fee will be assessed to individuals not associated with an
			Eclipse Foundation member.
		</p>
		
		<p>
			Registration to the Stragy Summit does not include access to Eclipse Summit Europe. Individuals that
			want to participate in <a href="http://www.eclipsecon.org/summiteurope2009/registration/" target="blank">
			Eclipse	Summit Europe</a> as well, must register separately for the conference.
		</p>
		
		<p>
			Space is limited for the Summit. Each organization is asked to register only two individuals.
			 Registration will be accepted on a first-come, first-serverd basis.
		</p>

		<br>
		</div>
		</div>
	</div>
<?php
	# Paste your HTML content between the EOHTML markers!	
	$html = ob_get_contents();
	ob_end_clean();

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