<?xml version="1.0" encoding="UTF-8"?>

<!-- 
	Priority 1 is in general reserved for Foundation 'endorsed' or 'sponsored' events. Priority 2 does NOT 
	render on home page summary.  
-->
<events>
   <event>
		<priority>2</priority>
		<name><![CDATA[EclipseCon 2014]]></name>
		<start-date><![CDATA[March 17, 2014]]></start-date>
		<link><![CDATA[http://www.eclipsecon.org/na2014/]]></link>
		<location><![CDATA[San Francisco, California]]></location>
		<description>
			<![CDATA[
			<br/><br/>
			March 17-20, 2013<br/>
			San Francisco, California<br/><br/>
			EclipseCon 2014 is the premier North American gathering for the Eclipse community. The program features half-day tutorials, hundreds of talks, exhibits, and social networking opportunities.
			]]>
		</description>
	</event>   
   <event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Finance Day 2013]]></name>
		<start-date><![CDATA[November 5, 2013]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/Eclipse_Finance_Day_2013]]></link>
		<location><![CDATA[Zürich, Switzerland]]></location>
		<description>
			<![CDATA[
			<br/><br/>
			November 5, 2013<br/>
			Zürich, Switzerland<br/><br/>
			The Eclipse Finance Day is a great opportunity to learn how financial institutions are using and benefiting from Eclipse and open source software.
			]]>
		</description>
	</event>
   <event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Stammtisch Darmstadt (Bickenbach)]]></name>
		<start-date><![CDATA[October 10, 2013]]></start-date>
		<link><![CDATA[http://doodle.com/v82a6tqhy28xei5b]]></link>
		<location><![CDATA[Bickenbach, Germany]]></location>
		<description>
			<![CDATA[
			<br/><br/>
			October 10, 2013<br/>
			Bickenbach, Germany<br/><br/>
			Join the Darmstadt Eclipse Community on Thursday, October 10th at Il Centro, in Bickenbach. Starting at 18:00 we’ll present short demos to mark the successful conclusion of our local GSOC projects. We’ll follow up with a brief look at the M2M project from Ralph Mueller and EclipseCon Europe by Christian Campo, Compeople. Then, we’ll take the remainder of the evening for some good conversation, a little networking and very possibly, a beer or two.<br/><br/>
			The evening is supported by the Eclipse Foundation and Codetrails, the company mentoring the Code Recommenders GSOC students. Space is limited, so please <a target="_blank" href="http://doodle.com/v82a6tqhy28xei5b">sign up on doodle</a>. See you there!
			]]>
		</description>
	</event>
    <event>
		<priority>2</priority>
		<name><![CDATA[EclipseCon Europe 2013]]></name>
		<start-date><![CDATA[October 29, 2013]]></start-date>
		<link><![CDATA[http://www.eclipsecon.org/europe2013/]]></link>
		<location><![CDATA[Ludwigsburg, Germany]]></location>
		<description>
			<![CDATA[
			<br/><br/>
			October 29-31, 2013<br/>
			Ludwigsburg, Germany<br/><br/>
			EclipseCon Europe is the Eclipse Foundation’s primary European event designed to create opportunities for the European Eclipse community to learn, explore, share, and collaborate on the latest ideas and information about Eclipse and its member companies.
			]]>
		</description>
	</event>
    <event>
		<priority>2</priority>
		<name><![CDATA[2013 NCSA Eclipse PTP User-Developer Workshop]]></name>
		<start-date><![CDATA[September 13-14, 2013]]></start-date>
		<link><![CDATA[http://www.ncsa.illinois.edu/Conferences/Eclipse/]]></link>
		<location><![CDATA[Schiller Park, IL]]></location>
		<description>
			<![CDATA[
			<br/><br/>
			September 13, 2013<br/>
			Four Points Sheraton<br/>
			Schiller Park, IL<br/><br/>
			The Parallel Tools Platform (PTP) User/Developer workshop is an annual 2-day meeting of users and developers that provides a forum for discussing all aspects of PTP. Participants in the the workshop will be able to help shape the future direction of the PTP project.
			]]>
		</description>
	</event>
	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Day China]]></name>
		<start-date><![CDATA[June 29, 2013]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/Eclipse_Day_China]]></link>
		<location><![CDATA[Beijing, China]]></location>
		<description>
			<![CDATA[
			<br/><br/>
			June 29, 2013<br/>
			ThoughtWorks<br/>
			Rm 1105 Guohua Plaza, No.3 Dongzhimen South St<br/>
			Dongcheng District, Beijing<br/><br/>
			The first Eclipse Day China features experts and senior consultants from leading IT companies that will share their experiences with Eclipse open source projects, Eclipse demo, and discuss technical issues.
			]]>
		</description>
	</event>
	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Testing Day 2013: Mobile Testing]]></name>
		<start-date><![CDATA[September 25, 2013]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/Eclipse_Testing_Day_2013]]></link>
		<location><![CDATA[Darmstadt, Germany]]></location>
		<description>
			<![CDATA[
			<br/><br/>
			September 25, 2013<br/>
			Commundo Tagungshotel<br/>
			27 Hilpertstraße Darmstadt<br/>
			HE 64295, DE<br/><br/>
			2013 is the fourth consecutive year of the Eclipse Testing Day - a not-for-profit, full-day event dedicated to topics in testing. The event is organised by BREDEX GmbH and the Eclipse Foundation.
			]]>
		</description>
	</event>	
	<event>
		<priority>2</priority>
		<name><![CDATA[BITKOM Forum]]></name>
		<start-date><![CDATA[June 24, 2013]]></start-date>
		<link><![CDATA[http://www.bitkom.org/de/veranstaltungen/102_75649.aspx]]></link>
		<location><![CDATA[Berlin, Germany]]></location>
		<description>
			<![CDATA[
			<br/><br/>
			June 24, 2013<br/>
			Open Source – Take Home Benefits<br/>
			Kalkscheune - Johannisstraße 2, 10117 Berlin<br/><br/>			
			The first "open source" forum last summer was a great success. This year, Mike Milinkovich will be there to talk about Open Source Processes: Lessons for Industry.
			]]>
		</description>
	</event>	
	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse IT 2013]]></name>
		<start-date><![CDATA[September 19, 2013 ]]></start-date>
		<link><![CDATA[http://2013.eclipse-it.org/]]></link>
		<location><![CDATA[Crema, Italy]]></location>
		<description>
			<![CDATA[
			<a href="http://2013.eclipse-it.org/"> </a>
			<br/><br/>
			September 19-20, 2013<br/>
			Università degli Studi di Milano<br/>
			Dipartimento di Informatica - Crema Campus<br/>			
			Via Bramante, 65<br/>
			I-26013 Crema, Italy<br/><br/>			
			The theme for Eclipse IT 2013 is "cooperative software development for mobile applications." This year's meeting is the seventh annual gathering of the Italian Eclipse Community.
			]]>
		</description>
	</event>

<event>
		<priority>2</priority>
		<name><![CDATA[Open Forum 2013]]></name>
		<start-date><![CDATA[May 16, 2013 ]]></start-date>
		<link><![CDATA[http://www.open-forum.net/]]></link>
		<location><![CDATA[Stuttgart, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://www.open-forum.net/"> </a>
			<br/><br/>
			May 16-17, 2013<br/>
			Neckar Forum<br/>
			Haupteingang über Hauffstraße<br/>			
			73728 Esslingen am Neckar, Germany<br/><br/>			
			The Open Forum Stuttgart combines technologies for modern networks with new approaches in collaboration and work organization. The 
			conference theme is "Software Skills for the Future" (which includes the former Eclipse Embedded Day), along with a partner event with the theme "A2A. Apps for Automotive."
			]]>
		</description>
	</event>

	
	<event>
		<priority>2</priority>
		<name><![CDATA[EclipseCon France 2013]]></name>
		<start-date><![CDATA[June 5, 2013 ]]></start-date>
		<link><![CDATA[http://http://www.eclipsecon.org/france2013/]]></link>
		<location><![CDATA[Toulouse, France]]></location>
		<description>
			<![CDATA[
			<a href="http://http://www.eclipsecon.org/france2013/"> </a>
			<br/><br/>
			June 5-6, 2013<br/>
			Centre de Congrès Pierre Baudis<br/>
			11, esplanade Compans Caffarelli<br/>			
			31685 Toulouse, France<br/><br/>			
			The first EclipseCon France will emphasize modeling, systems engineering, and technologies 
			related to the Internet of Things, as well as content on current Eclipse technology.
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[EclipseCon 2013]]></name>
		<start-date><![CDATA[March 25, 2013 ]]></start-date>
		<link><![CDATA[http://http://www.eclipsecon.org/2013/]]></link>
		<location><![CDATA[Boston, USA]]></location>
		<description>
			<![CDATA[
			<a href="http://http://www.eclipsecon.org/2013/"> </a>
			<br/><br/>
			March 25-28, 2013<br/>
			Seaport Hotel and World Trade Center<br/>
			200 Seaport Boulevard<br/>
			Boston, MA 02210<br/><br/>			
			EclipseCon 2013 is the premier North American gathering for the Eclipse community. The 
			program features half-day tutorials, hundreds of talks, exhibits, and social networking opportunities.	
			]]>
		</description>
	</event>
	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Day Florence]]></name>
		<start-date><![CDATA[May 10, 2013 ]]></start-date>
		<link><![CDATA[http://www.eclipsedayflorence.com/]]></link>
		<location><![CDATA[Florence, Italy]]></location>
		<description>
			<![CDATA[
			<a href="http://www.eclipsedayflorence.com/"> </a>
			<br/><br/>
			May 10, 2013<br/>
			Sala Verde del Palazzo dei Congressi<br/>
			Piazza Adua, 1<br/>
			50123 Firenze<br/><br/>			
			This second edition of Eclipse Day Florence is for anyone who wants to share with the 
			community their success in the adoption of Eclipse or open-source technologies.	
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Integrated Development Day]]></name>
		<start-date><![CDATA[May 27, 2013 ]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/Eclipse_IDD_2013]]></link>
		<location><![CDATA[Berlin, Germany]]></location>
		<description>
			<![CDATA[
			<a href=""> </a>
			<br/><br/>
			May 27, 2013<br/>
			Fraunhofer FOKUS<br/>
			Kaiserin-Augusta-Allee 31<br/>
			10589 Berlin<br/><br/>			
			Eclipse Integrated Development Day in Berlin is a day-long event for technical developers, architects 
			and managers interested in tool and process integration as well as automation in development processes. 
			Attendees will have the chance to hear speakers from leading organizations and experts 
			from the Eclipse community.	
			]]>
		</description>
	</event>
	
<event>
		<priority>2</priority>
		<name><![CDATA[fOSSa 2012 Edition]]></name>
		<start-date><![CDATA[December 4th, 2012]]></start-date>
		<link><![CDATA[http://fossa.inria.fr/en/program]]></link>
		<location><![CDATA[Lille, France]]></location>
			<description><![CDATA[
			Inria & EuraTechnologies are happy to announce you the fOSSa 2012 Edition!<br/>
<strong>fOSSa conference will take place on the 4,5, 6th December 2012 in Lille, France, nearby London, Paris and Brussels.</strong><br/><br/>
			This year, the conference will address: Education, Research & Innovation, fOSSarcheology - History of the Free Software/Open Source movement, Movie: 'Revolution OSâ,  Digital Native Generation, Openness, Openarts, Open Hardware, Licences, Community management, Workshops (Many code development training sessions are scheduled -> Gnome, Mozilla, LibreOffice, Pharo, SpagoBI, ROS framework, Elgg & Social Network Usages, etc.)]]></description>
	</event>
	
	
	<event>
		<priority>2</priority>
		<name><![CDATA[Orion Hackathon Krakow]]></name>
		<start-date><![CDATA[October 26, 2012]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/Orion_Hackathon_Krakow_2012]]></link>
		<location><![CDATA[Krakow]]></location>
			<description><![CDATA[
			<a href="http://wiki.eclipse.org/Orion_Hackathon_Krakow_2012">More Information Here</a>
			<br/><br/>
			October 26-28, 2012<br/>
			AGH University of Science and Technology<br/>
			Building D-10,  Auditorium A (first floor)<br/>
			A. Mickiewicza 30 Ave.<br/>
			30-059 Krakow<br/>
			Poland<br/>
			<br/>At the Orion Hackathon Krakow, developers will code together in teams. Learn new stuff, compete with other teams, win prizes, meet new people, and have lots of geek fun.
			]]></description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Day Krakow]]></name>
		<start-date><![CDATA[September 13, 2012]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/Eclipse_Day_Krakow_2012]]></link>
		<location><![CDATA[Krakow]]></location>
		<description><![CDATA[
		<a href="http://wiki.eclipse.org/Eclipse_Day_Krakow_2012#Who_Is_Attending">Register Here</a>
		<br/><br/>
		September 13, 2012<br/>
		AGH University of Science and Technology<br/>
		A. Mickiewicza 30 Ave.<br/>
		30-059 Krakow<br/>
		Poland<br/>
		<br/>Eclipse Day in Krakow is a one-day event for developers to learn about different Eclipse projects and related technologies. You are invited to attend and listen as experts from the Eclipse projects share their experiences of using Eclipse. It's also a great opportunity 
		to meet and network with other Eclipse enthusiasts. The <a href="http://wiki.eclipse.org/Eclipse_Day_Krakow_2012#Call_for_Papers">call for papers</a> is 
		open until 15 August, 2012.
		]]></description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Detroit JUG - What is Eclipse?]]></name>
		<start-date><![CDATA[January 21, 2009]]></start-date>
		<link><![CDATA[http://sites.google.com/site/detroitjug/]]></link>
		<location><![CDATA[Detroit, MI, USA]]></location>
		<description>
			<![CDATA[
			<a href="http://sites.google.com/site/detroitjug/">Register Here</a>
			<br/><br/>
			January 21, 2009<br/>
			ePrize Corporate Headquarters, One ePrize Dr., Pleasant Ridge<br/><br/>			
			What is Eclipse?  Most people think Eclipse is a Java IDE.  But it's much more!  Eclipse is a
			set of Java technology frameworks built upon OSGi than can be used to build client and/or
			server applications.
			<br/><br/>
			This presentation by Dennie O'Flynn, Software Architect, will provide you with a general
			overview of the Eclipse technology
			frameworks.  You will gain an understanding of the different component development models
			available, including a brief demo of OSGi's service components. 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Open Source Meets Business]]></name>
		<start-date><![CDATA[January 27, 2009]]></start-date>
		<link><![CDATA[http://www.heise.de/events/2009/open_source_meets_business/en/]]></link>
		<location><![CDATA[Nuremburg, Germany]]></location>
		<description>
			<![CDATA[
			<a href="https://www.heise.de/events/2009/open_source_meets_business/en/registration/">Register Here</a>
			<br/><br/>
			January 27-29, 2009<br/>
			CongressCenter Nuremberg (CCN West)<br/><br/>			
			More than 700 attendees collect concentrated information from over 100 talks,
			workshops and keynotes, and take part in a lively exchange of knowledge and opinions. 
			Decision makers of organisations from all industries and sizes, IT users and
			suppliers, communitiy members, investors and promoters: they are all coming together
			to learn and speak about Open Source and its business potential.
			Keynotes: internationally renowned experts from IT user and supplier companies as
			well as from the financial industry assess the status, forecast the perspective and
			evaluate the potential of Open Source software in enterprise applications. 
			<br/><br/>
			Note on day 2, Maro Lenz, CTO of Empolis will give a technology keynote on the Eclipse
			SMILA project.
			]]>
		</description>
	</event>
	
	

	<event>
		<priority>2</priority>
		<name><![CDATA[Using Eclipse as an Application Platform in the Enterprise]]></name>
		<start-date><![CDATA[January 28, 2009]]></start-date>
		<link><![CDATA[http://www.ars.de/instantiations]]></link>
		<location><![CDATA[Munich, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://www.ars.de/web/contact?type=registration20090128&eventId=Instantiations_090128&lang=en">Register Here</a>
			<br/><br/>
			January 28-29, 2009<br/>
			PACT HOME Conference Center<br/><br/>			
			This is a 2-day conference for managers and developers of enterprise applications on Eclipse plug-in development
			techniques and best practices. Day 1 will include case studies, sessions on Equinox, JAZZ as a teaming tool, UI
			Building, RCP plug-in development and more. Day 2 is a full-day, hands-on tutorial by the co-founders of
			Instantiations and authors of the successful book "Eclipse: Building Commercial-Quality Plug-Ins," Eric Clayberg
			and Dan Rubel. Bring along your laptop computer to the hands-on tutorial to learn the latest techniques and best
			practices of plug-in development in Eclipse, based on the third edition of their new "Eclipse Plug-Ins" book coming
			out in January 2009. All of the examples and labs use the latest Eclipse 3.4 APIs and JDK 1.5/1.6 syntax.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Sigasi Brings Together the Belgian Eclipse Community]]></name>
		<start-date><![CDATA[February 10, 2009]]></start-date>
		<link><![CDATA[http://www.sigasi.com/node/25]]></link>
		<location><![CDATA[Brussels, Belgium]]></location>
		<description>
			<![CDATA[
			<a href="http://www.sigasi.com/node/25">Register Here</a>
			<br/><br/>
			February 10, 2009<br/>
			Collibra, Brussels Business Base, Tweebeek industrial park, rue de Ransbeek 230<br/><br/>			
			Sigasi is organizing the first meeting of the regional Eclipse community in Belgium,
			in collaboration with Collibra and Inventive Designers. The focus of this first meeting is on
			getting to know each other and on discussing future events.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Banking Day in London]]></name>
		<start-date><![CDATA[February 12, 2009]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/EclipseBankingDayLondon]]></link>
		<location><![CDATA[London, United Kingdom]]></location>
		<description>
			<![CDATA[
			<a href="http://wiki.eclipse.org/EclipseBankingDayLondon#Attendee_Registration">Register Here</a>
			<br/><br/>
			February 12, 2009<br/>
			etc.venues - The Hatton, 51-53 Hatton Garden<br/><br/>			
			Eclipse Banking Day is a day-long event for senior technical developers, architects and managers in
			the finance industry to learn how to better leverage Eclipse technology and the Eclipse community
			as part of their development strategy.  Attendees will have the chance to hear speakers from
			leading financial institutions and experts from the Eclipse community. This event builds on the
			success of Eclipse Banking Days in New York and Frankfurt.
			<br/><br/>
			Attendees must be employees or contractors of a financial institution. There is no cost to attend
			but pre-registration is required. 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Open Source Singapore Pacific-Asia Conference]]></name>
		<start-date><![CDATA[February 16, 2009]]></start-date>
		<link><![CDATA[http://www.osspac.com/]]></link>
		<location><![CDATA[Singapore, Singapore]]></location>
		<description>
			<![CDATA[
			<a href="http://www.osspac.com/registration/conference-registration/">Register Here</a>
			<br/><br/>
			February 16-18, 2009<br/>
			Grand Hyatt Singapore<br/><br/>			
			The Open Source Singapore Pacific-Asia Conference and Expo (OSSPAC) will be the seminal event for
			the best and brightest developers, executives and visionaries to gather to set the future course
			of Open Source across the region.  Experience first hand the wide-ranging open systems ecosystem
			through a multitude of activities, sessions, vendors and networking events. Whether your business
			already uses Open Source or you are looking to implement free software for the first time, OSSPAC
			'09 will have the answers.  Hear from keynote speakers and learn from the best and brightest within
			the industry on what Open Source can do for you. Discover the latest trends, examine the newest
			software and solutions and experience endless networking opportunities.
			<br/><br/>
			Steve Ball from Ingres will present a talk on <i>Open Source Database Development using Eclipse, Java
			&amp; PHP</i>.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Stammtisch in Braunschweig]]></name>
		<start-date><![CDATA[February 26, 2009]]></start-date>
		<link><![CDATA[http://www.bredex.de/en/news/eclipse.html]]></link>
		<location><![CDATA[Braunschweig, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://www.bredex.de/en/news/eclipse.html">Register Here</a>
			<br/><br/>
			February 26, 2009<br/>
			Bredex GmbH, Mauernstr. 33, 38100 Braunschweig<br/><br/>			
			Ralph M&uuml;ller from the Eclipse Foundation and Alexander Neumann from the developer
			channel at Heise will be joining for an Eclipse stammtisch (regular get-together)
			at Bredex in Braunschweig. This time we'd like to hear some more from
			you.  What are you doing or planning on doing with Eclipse? Where have you had
			problems and what solutions have you found? If you'd like to do a short introduction
			on how you use Eclipse, send a mail to <a href="mailto:eclipsestammtisch@bredex.de">.
			eclipsestammtisch@bredex.de</a>.  Afterwards, we'll head to Mephisto, around the
			corner from Bredex, for some drinks and food.  Please pre-register for the event and
			as always, feel free to invite friends or colleagues.
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[Aspect-Oriented Software Development (AOSD)]]></name>
		<start-date><![CDATA[March 2, 2009]]></start-date>
		<link><![CDATA[http://aosd.net/2009/index.php]]></link>
		<location><![CDATA[Charlottesville, VA, USA]]></location>
		<description>
			<![CDATA[
			<a href="http://aosd.net/2009/index.php">Register Here</a>
			<br/><br/>
			March 2-6, 2009<br/>
			University of Virginia<br/><br/>			
			The International Conference on Aspect-Oriented Software Development (AOSD) is the
			premier conference on software modularity, with an emphasis on modular structures that
			cut across traditional abstraction boundaries. The conference offers several tracks,
			including the Research and Industry Tracks, which bring together leading researchers
			and practitioners working in such fields as software engineering, programming
			languages, systems, and others. AOSD welcomes submissions of high quality in all
			areas relating to aspects, ranging from foundational research to evaluations of
			aspect-oriented concepts, methods and tools based on experiences using them in
			practice.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Stammtisch in Munich]]></name>
		<start-date><![CDATA[March 4, 2009]]></start-date>
		<link><![CDATA[http://www.doodle.com/participation.html?pollId=5m4cwxh75hdh7cvw]]></link>
		<location><![CDATA[Munich, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://www.doodle.com/participation.html?pollId=5m4cwxh75hdh7cvw">Register Here</a>
			<br/><br/>
			March 4, 2009<br/>
			<a href="http://www.kuffler-gastronomie.de/de/muenchen/gruental/index.php" target="blank">Wirtshaus im Gr&uuml;nTal</a>, Gr&uuml;tal 15<br/><br/>			
			An Eclipse Stammtisch (regular get-together) will take place March 4th at 7:00 pm at
			Wirtshaus im Gr&uuml;nTal.  Everyone who is interested in meeting up with Mike Milinkovich
			and Ralph M&uuml;ller from the Eclipse Foundation and many other Eclipse enthusiasts
			is invited to attend.  Please pre-register for this interesting evening!
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[SD West]]></name>
		<start-date><![CDATA[March 9, 2009]]></start-date>
		<link><![CDATA[http://www.sdexpo.com/]]></link>
		<location><![CDATA[Santa Clara, CA, USA]]></location>
		<description>
			<![CDATA[
			<a href="http://www.sdexpo.com/2009/west/register.htm">Register Here</a>
			<br/><br/>
			March 9-13, 2009<br/>
			Santa Clara Convention Center<br/><br/>			
			SD West 2009 offers more than 150 classes, tutorials, case studies, roundtables, panels, keynotes
			and Birds-of-a-Feather gatherings in 13 important subject areas. This year, two new tracks have
			been added - Cloud Computing and New Horizons.  There are more new and updated sessions than ever before.
			Learn about the latest technologies, network with a select group of your peers and get
			inspiration from industry visionaries all under one roof at SD West 2009.
			<br/><br/>
			Steve Adolph is giving a talk titled <i>The Agile Business Analyst</i> where he will introduce
			the Eclipse Process Framework (EPF).
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Open Source in Mobile (OSiM) USA]]></name>
		<start-date><![CDATA[March 11, 2009]]></start-date>
		<link><![CDATA[http://usa.osimworld.com/]]></link>
		<location><![CDATA[San Francisco, CA, USA]]></location>
		<description>
			<![CDATA[
			<a href="http://www.sdexpo.com/2009/west/register.htm">Register Here</a>
			<br/><br/>
			March 11-12, 2009<br/>
			Westin<br/><br/>			
			Open Source in Mobile is the only open source event in the world to focus exclusively on the
			mobile industry. Featuring an unrivalled line up representing the entire ecosystem, OSiM USA
			will once again equip you with all the necessary knowledge to understand, act and succeed in
			the North American Open Source industry.
			<br/><br/>
			Mike Milkinovich, Executive Director of the Eclipse Foundation will present <i>Enabling
			Platforms, Industry Collaboration and Ecosystems with Open Source</i> at OSiM.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[SDForum Global Open Source Colloquium]]></name>
		<start-date><![CDATA[March 23, 2009]]></start-date>
		<link><![CDATA[http://www.sdforum.org/index.cfm?fuseaction=Calendar.eventDetail&eventID=13371]]></link>
		<location><![CDATA[San Francisco, CA, USA]]></location>
		<description>
			<![CDATA[
			<a href="https://www.sdforum.org/index.cfm?fuseaction=Calendar.showRegistrationForm&eventId=13371&nodeID=1">Register Here</a>
			<br/><br/>
			March 23, 2009<br/>
			11:30 am - 6:15 pm<br/>
			Swissnex, 730 Montgomery St.<br/><br/>			
			Last year, SDForum's Global Open Source Conference attracted a high level, exclusive group of 80
			leaders discussing the globalization of open source - attendees included leading industry and
			government experts examining the worldwide trends in open source software and its commercial as
			well as on government policy. 
			<br/><br/>
			In 2009, the Global Open Source Colloquium will continue to address the changing nature of open
			source software trends in the world.  With an exclusive group of leaders in the open source
			developer, user, and investor communities, the agenda is designed to foster discussion on
			emerging business ideas and opportunities in the use of open source for both local and global
			needs in the coming years. 
			]]>
		</description>
	</event>

	<event>
		<priority>1</priority>
		<name>EclipseCon 2009</name>
		<start-date>March 23, 2009</start-date>
		<link>http://www.eclipsecon.org/2009/</link>
		<location>Santa Clara, CA, USA</location>
		<description>
			<![CDATA[
			<a href="http://usa.osimworld.com/register/register">Register Here</a>
			<br/><br/>
			March 23-26, 2009<br/>
			Santa Clara Convention Center, 5001 Great America Parkway<br/><br/>			
			EclipseCon is the premier technical and user conference focusing on the power of the Eclipse platform. From implementers to
			users, and everyone in between, if you are using, building, or considering Eclipse, EclipseCon is the conference you need
			to attend.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipe Forum India]]></name>
		<start-date><![CDATA[April 6, 2009]]></start-date>
		<link><![CDATA[http://www.sda-india.com/conferences/2009/EFI/]]></link>
		<location><![CDATA[Bangalore, India]]></location>
		<description>
			<![CDATA[
			<a href="http://www.sda-india.com/conferences/2009/EFI/register_soon.php">Register Here</a>
			<br/><br/>
			April 6-10, 2009<br/>
			NIMHANS Convention Centre<br/><br/>		
			Eclipse Forum India is the conference on the Indian subcontinent for all experts using Eclipse
			as a strategic platform - either as a development environment, as runtime for Rich Clients or
			as a server framework. As a late feature vertical industry frameworks based on Eclipse has been added
			to this as well.
			<br/><br/>
			Being among the first events on Eclipse on the subcontinent, Eclipse Forum India has gained a
			lot of reputation among the industry over the last 3 years - making it the No 1 conference on
			Eclipse in India. In addition to its successful and proven concept, Eclipse Forum India 2009,
			will offer this year a special day dedicated to students and academics. The 3rd Annual Eclipse
			Forum India in Bangalore again offers the best speakers and the most important companies
			within the Eclipse ecosytem. The conference program focuses on all aspects of the Eclipse
			platform.
			<br/><br/>
			Eclipse Forum India is organised and run by S&S Media, producer of Eclipse Forum Europe and
			Eclipse Forum Asia, among many other internationally renowned technology events. S&S Media is
			furthermore publisher of the highly acclaimed <i>Eclipse Magazin</i>. 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Forum Europe]]></name>
		<start-date><![CDATA[April 20, 2009]]></start-date>
		<link><![CDATA[http://it-republik.de/konferenzen/efe/]]></link>
		<location><![CDATA[Mainz, Germany]]></location>
		<description>
			<![CDATA[
			<a href="https://www.entwickler.com/ssl/formtool/index.php?id=9&lang=en">Register Here</a>
			<br/><br/>
			April 20-24, 2009<br/>
			Rheingoldhalle Mainz, Rheinstrasse 66<br/><br/>			
			Eclipse Forum Europe is the conference for all experts using Eclipse as a strategic platform
			- either as a development environment, as runtime for Rich Clients or as a server framework.
			As a late feature, vertical industry frameworks based on Eclipse has been added to this as well.
			The 4th Eclipse Forum Europe in Mainz again offers you the best speakers and the most
			important companies within the Ecipse ecosytem. The conference program focuses on all
			aspects of the Eclipse platform. The key to the success of the platform is based on the ideas
			and the immeasurable commitment of all member of the Eclipse ecosytem - building a staple
			foundation for technological and business innovation. Eclipse Forum Europe brings together
			all players - open source developers, users and business strategists, offering a unique concept to
			enable know-how transfer, the exchange of ideas and business innovation.
			<br/><br/>
			The Eclipse Forum Europe 2009 will run parallel to two complementary conferences - JAX 09 &
			SOACON.  JAX 09 is the leading European conference on enterprise technologies and strategies
			and SOACON is the conference for all experts dealing with service orientation in companies.
			By registering for one of the three conferences you will have the chance to visit the other
			conferences for free.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[FOSS Leaders Panel Discussion]]></name>
		<start-date><![CDATA[April 23, 2009]]></start-date>
		<link><![CDATA[http://fosslc.org/drupal/yyz3]]></link>
		<location><![CDATA[Toronto, ON, Canada]]></location>
		<description>
			<![CDATA[
			<a href="http://fosslc.org/drupal/civicrm/event/register?id=6&reset=1">Register Here</a>
			<br/><br/>
			April 23, 2009<br/>
			University of Toronto<br/><br/>			
			The Free and Open Source Software Learning Centre (FOSSLC) is presenting a leaders panel discussion
			with Ingres CEO Roger Burkhardt, Mozilla Executive Director Mark Surman, Eclipse Executive Director
			Mike Milinkovich and IBM Software Developer Lawrence Mandel.
			Open source has been accused of being anti-capitalist, the saviour of government, and a way of
			breaking vendor lock-in and saving money in a down economy. This panel discussion involving senior
			leaders from open source organizations will explore these themes and provide valuable insights. 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[EclipsIST]]></name>
		<start-date><![CDATA[April 28, 2009]]></start-date>
		<link><![CDATA[http://www.eclipsist.org/web/eclipsist2009/home]]></link>
		<location><![CDATA[Istanbul, Turkey]]></location>
		<description>
			<![CDATA[
			<a href="http://www.eclipsist.org/web/eclipsist2009/registration">Register Here</a>
			<br/><br/>
			April 28-29, 2009<br/>
			Istanbul Technical University, Maslak<br/><br/>		
			EclipsIST is the premier technical and user conference focusing on the power of the Eclipse
			platform in Turkey.  From implementers to users, and everyone in between, if you are using,
			building or considering Eclipse, EclipsIST is the one conference you need to attend. 
			Don't miss the chance to hear about the latest Eclipse developments and discuss key business and
			technical issues facing the community. Keynote speaker Jeff McAffer is joined by Eclipse
			Evangelist, Wayne Beaton and Ralph Mueller, as well as our own Turkish  community speakers to
			deliver the best EclipsIST yet!
			<br/><br/>
			Talks at EclipsIST 2009 reflect the diversity of the Eclipse community and include: Emerging
			Technology, e4, Java, OSGi, Runtime, SOA, Tools, UI/RCP and Web Tools.  
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[ICSE]]></name>
		<start-date><![CDATA[May 16, 2009]]></start-date>
		<link><![CDATA[http://www.cs.uoregon.edu/events/icse2009/home/]]></link>
		<location><![CDATA[Vancouver, BC, Canada]]></location>
		<description>
			<![CDATA[
			<a href="https://server2.regmaster3.com/conf/ICSE09/register.php">Register Here</a>
			<br/><br/>
			May 16-24, 2009<br/>
			<a href="http://www.starwoodmeeting.com/StarGroupsWeb/booking/reservation?id=0804023960&key=21D66">Westin Bayshore</a>, 1601 Bayshore Dr.<br/><br/>		
			The International Conference on Software Engineering is now in its 31st year.  ICSE 2009
			promises to be an exciting event, with an outstanding research track and several new tracks:
			Software Engineering in Practice, New Idesas and Emerging Results and Tools and Demos.
			<br/><br/>
			Eclipse talks at ICSE include <i>Introduction to the Eclipse Modeling Framework</i> by Ed Merks
			and <i>Product-line Modeling and Automation in Eclipse</i> by Jules White and Egon Wuchner.
			]]>
		</description>
	</event>

	<event>
		<priority>1</priority>
		<name><![CDATA[Eclipse DemoCamps for Galileo]]></name>
		<start-date><![CDATA[June 29, 2009]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/Eclipse_DemoCamps_Galileo_2009]]></link>
		<location><![CDATA[Worldwide]]></location>
		<description>
			<![CDATA[
			<a href="http://wiki.eclipse.org/Eclipse_DemoCamps_Galileo_2009">Register Here</a>
			<br/><br/>
			May 18-June 29, 2009<br/><br/>
			From May 18 to June 29, the Eclipse Foundation is inviting individuals to attend Eclipse DemoCamps
			around the world to celebrate the Galileo release. The Eclipse DemoCamps are an opportunity to
			showcase all of the cool interesting technology being built by the Eclipse community. They are also
			an opportunity for you to meet Eclipse enthusiasts in your city. You don't need to be a software
			developer to attend!
			<br/><br/>			 
			The format of a DemoCamp is pretty informal. The idea is for a group of Eclipse enthusiasts to meet
			up and demo what they are doing with Eclipse. The demos can be of research projects, Eclipse open
			source projects, applications based on Eclipse, commercial products using Eclipse or whatever you
			think might be of interest to the attendees. The only stipulation is that it must be Eclipse
			related.  Help us commemorate Galileo! 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Stammtisch]]></name>
		<start-date><![CDATA[May 27, 2009]]></start-date>
		<link><![CDATA[http://www.compeople.de/24-0-Veranstaltungen.html]]></link>
		<location><![CDATA[Frankfurt, Germany]]></location>
		<description>
			<![CDATA[
			<a href="mailto:andrea.drews@compeople.de">Register Here</a>
			<br/><br/>
			May 27, 2009<br/>
			compeople AG, Untermainanlage 8<br/><br/>
			compeople is hosting an informal get together for some short Eclipse presentations followed by drinks
			at Chicacgo Meatpackers.  Ralph M&uumlller from the Eclipse Foundation will open with an
			overview of the Foundation and news about the open source community.  Ekkehard Gentz, software
			architect, will present on UI for Business Applications and Jochen Krause, EclipseSource, will
			present on the Eclipse RAP project. We look forward to meeting you at the Eclipse Stammtisch!
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[IBM Rational Software Conference]]></name>
		<start-date><![CDATA[June 2, 2009]]></start-date>
		<link><![CDATA[http://www.remotersc.com/]]></link>
		<location><![CDATA[Various Locations in Canada and USA]]></location>
		<description>
			<![CDATA[
			<a href="http://www.remotersc.com">Register Here</a>
			<br/><br/>
			June 2, 2009<br/>
			Austin, Foster City, New York City, Toronto, Waltham and Chicago<br/><br/>		
			Tight travel budget? Attend IBM's one-day remote Rational Software Conference in a city near
			you. You'll find Real Teams, Real Insights and Real Results, just like the Rational Software
			Conference in Orlando, but closer to home (Austin, Foster City, New York City, Toronto,
			Waltham, Chicago). Don't miss this value-packed one-day session on Tuesday, June 2. Hurry,
			because space is limited!
			<br/><br/>
			Technical workshops at these action-packed sessions include "Enterprise Modernization" and
			"Business IT Transformation," featuring IBM Rational Developer for System z Version 7.5 and
			IBM Rational Team Concert, a pair of powerful productivity tools built upon the Eclipse
			platform. Come compete against your fellow developers on the sister remote conference teams
			to complete as many workshops as possible during the allocated breakout sessions! Don't miss
			this opportunity to network, win prizes, and experience the Rational Software Conference in a
			city near you! And the price is right at just US$99. Register today at
			<a href="http://www.remotersc.com" target="blank">http://www.remotersc.com</a>.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[JavaOne]]></name>
		<start-date><![CDATA[June 2, 2009]]></start-date>
		<link><![CDATA[http://java.sun.com/javaone/index.jsp]]></link>
		<location><![CDATA[San Francisco, CA, USA]]></location>
		<description>
			<![CDATA[
			<a href="http://java.sun.com/javaone/2009/registration.jsp">Register Here</a>
			<br/><br/>
			June 2-5, 2009<br/>
			Moscone Center<br/><br/>		
			This year's JavaOne will have one of the deepest curriculum programs yet. With more than 1,300
			submissions, you can choose from a variety of tracks, labs and BOFs that will enhance your
			skill set, help you problem-solve quicker and more efficiently, show you new tools and
			products, share code and give you hands-on opportunities. You'll learn more about latest in
			tools, RIAs, Java technology, JavaFX, scripting and much, much more.
			<br/><br/>
			Eclipse sessions: <i>Practical Lessons in Memory Analysis</i> by Andrew Johnson and Krum Tsvetkov,
			<i>Building Commercial-Quality Eclipse Plugins By the Guys Who Wrote the Book</i> by Eric Clayberg
			and Dan Rubel and <i>Less is More - Redefining the "I" of the IDE</i> by Mik Kersten.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Stammtisch]]></name>
		<start-date><![CDATA[June 4, 2009]]></start-date>
		<link><![CDATA[http://www.weiglewilczek.com/blog/?p=661]]></link>
		<location><![CDATA[Stuttgart, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://www.weiglewilczek.com/blog/?p=661">Register Here</a>
			<br/><br/>
			June 4, 2009<br/>
			[http://wrs.region-stuttgart.de/ WirtschaftsfÃÂ¶rderung Stuttgart], Friedrichstrasse 10<br/><br/>		
			This stammtische is being organized by Weigle Wilczek and Instinctoos, with help from
			Ralph Mueller of the Eclipse Foundation.  There will be 90 minutes of short presentations
			followed by a get together at Joe Pena's.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Code Generation 2009]]></name>
		<start-date><![CDATA[June 16, 2009]]></start-date>
		<link><![CDATA[http://www.codegeneration.net/cg2009/index.php]]></link>
		<location><![CDATA[Cambridge, United Kingdom]]></location>
		<description>
			<![CDATA[
			<a href="http://www.codegeneration.net/cg2009/index.php">Register Here</a>
			<br/><br/>
			June 16-18, 2009<br/>
			Murray Edwards College<br/><br/>			
			Code Generation 2009 is for people who want to successfully apply or just learn more about the
			following topics: Eclipse Modelling Tools, Domain-Specific Languages, Domain-Specific Modelling,
			Model-Driven Architecture, Executable UML, Model-Driven Software Development, Software Factories
			and Software Product Lines, Generative Programming and other similar approaches.
			<br/><br/>
			Keynote Speakers are Markus V&ouml;lter (Independent) and Steven Kelly (MetaCase).  The team
			from itemis will be giving a workshop on Xtext.
			]]>
		</description>
	</event>
	<event>
		<priority>1</priority>
		<name><![CDATA[Eclipse Stammtisch in Berlin]]></name>
		<start-date><![CDATA[June 16, 2009]]></start-date>
		<link><![CDATA[http://www3.doodle.com/xsfdcb8rugnzpe4d]]></link>
		<location><![CDATA[Berlin, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://www3.doodle.com/xsfdcb8rugnzpe4d">Register Here</a>
			<br/><br/>
			June 16, 2009<br/>
			<a href="http://www.bavarium-berlin.de/" target="blank">Bavarium</a> in Europa Center<br/><br/>			
			The Eclipse Foundation's Board of Directors is having its first meeting outside of the USA.  While they're
			meeting in Berlin, they'd like to take the opportunity to have a beer with members of the
			local Eclipse community. We hope you can join!
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[China International Software & Information Fair]]></name>
		<start-date><![CDATA[June 18, 2009]]></start-date>
		<link><![CDATA[http://www.cisis.com.cn/news/279/280/2290/newsexdisen2959.aspx]]></link>
		<location><![CDATA[Dalian, China]]></location>
		<description>
			<![CDATA[
			<a href="http://www.cisis.com.cn/news/279/280/2290/newsexdisen2959.aspx">Register Here</a>
			<br/><br/>
			June 18-21, 2009<br/>
			Dalian World Expo Centre<br/><br/>			
			The CISIS is an international IT industry event and a platform for international cooperation.
			VIPs from overseas government departments, CEOs of World Top 500, well-known consultants and
			overseas IT associations take part in the fair each year. The CISIS is an official conference
			for industry policies, industry trends and forecasting.	The Chinese software independent
			innovation report and Chinese software outsourcing development strategy report are released by
			the CISIS and are two important publications for the China software industry of today and
			tomorrow.
			<br/><br/>
			Eclipse member Soyatec will be organizing a session about Eclipse.  Partners interested in
			participating are welcome to contact Yves Yang at Soyatec (email yves dot yang at soyatec dot
			com).
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[International SPICE Days]]></name>
		<start-date><![CDATA[June 22, 2009]]></start-date>
		<link><![CDATA[http://www.isqi.org/konferenzen/spice-days/2009/]]></link>
		<location><![CDATA[Stuttgart, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://www.isqi.org/en/conferences/spice-days/2009/registration/">Register Here</a>
			<br/><br/>
			June 22-24, 2009<br/>
			SpOrt Stuttgart, Sport Bildungs- und Dienstleistungszentrum, Fritz-Walter-Weg 19<br/><br/>			
			With a conference location in Stuttgart, it is only natural that the International SPICE Days
			should focus on the lessons learned from industry wide adoption and what plans for
			the future are. Moving from improvement of single organisations to attempting to improve a
			whole value creation network is an undertaking many other industries may be able to draw
			benefit from. The programme naturally focusses on the automotive industry and is constructed
			to facilitate transfer of experience, not least by providing an excellent platform for
			networking.
			<br/><br/>
			Eclipse talks at International SPICE Days include <i>Using the Eclipse Platform and Community
			Offerings to Facilitate Automotive SPICE Compliance</i> and several sessions on
			Eclipse Embedded.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Time]]></name>
		<start-date><![CDATA[June 23, 2009]]></start-date>
		<link><![CDATA[http://www.eclipsetime.org]]></link>
		<location><![CDATA[Toulouse, France]]></location>
		<description>
			<![CDATA[
			<a href="http://www.eclipsetime.org">Register Here</a>
			<br/><br/>
			June 23-24, 2009<br/>
			M&eacute;diath&egrave;que de Toulouse<br/><br/>			
			The fourth annual Eclipse Time will present different aspects of the Eclipse platform
			during the conference day: technical (RCP architecture, Domain Specific business IDE),
			strategic (Eclipse as an answer to industrial topics, developing domain specific
			business applications), and community. This conference day is an occasion for
			attendees to learn news from the Foundation, to see new trends about Eclipse use,
			to learn about implementation of components, and to discover solutions developed for
			customers.
			<br/><br/>
			During the second day, people can attend workshops (groups of 20 people) presented by
			Eclipse experts, which focus on OSGi, RCP, IDE for embedded applications (Integration
			of components), Rich clients (technologies, examples), Eclipse 4, IDE modeling
			(OAW, EMF, GMF) and other topics. This is an opportunity to focus on technologies
			and learn when to use which technologies.
			<br/><br/>
			Based on the success of the past event, more than 150 attendees are expected at
			Eclipse Time, including architects, developers and managers who represent many
			fields of activity, such as aerospace, aeronautics, automotive, and energy.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Embedded Day in Stuttgart]]></name>
		<start-date><![CDATA[June 25, 2009]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/EclipseEmbeddedDayStgt]]></link>
		<location><![CDATA[Stuttgart, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://wiki.eclipse.org/EclipseEmbeddedDayStgt#Attendee_Registration">Register Here</a>
			<br/><br/>
			June 25, 2009<br/>
			SpOrt Stuttgart, Bildungs- und Dienstleistungszentrum GbR, Fritz-Walter-Weg 19<br/><br/>
			Eclipse Embedded Day is a day-long event for senior technical developers, architects and
			technical managers in the automotive, telematics, mobile, consumer electronic and medical
			industry to learn how to better leverage Eclipse technology and the Eclipse community as
			part of their development strategy. In addition the event features sessions on Eclipse
			projects related to the embedded space and case studies of automotive, telematics, mobile,
			medical and consumer electronic institutions. The event will focus on three themes: 
			<ol>
				<li>Eclipse as a platform for application development in the embedded space</li>
				<li>Collaborating with the open source community and Working Groups</li>
				<li>Case studies of projects of companies in the automotive, telematics, medical or consumer electronics area</li> 
			</ol>
			<br/>
			Attendees will have the chance to hear speakers from leading companies in the embedded
			space and experts from the Eclipse community. There is no cost to attend but
			pre-registration is required. 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Java Forum Stuttgart]]></name>
		<start-date><![CDATA[July 2, 2009]]></start-date>
		<link><![CDATA[http://www.java-forum-stuttgart.de/]]></link>
		<location><![CDATA[Stuttgart, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://www.java-forum-stuttgart.de/anmeldung.html">Register Here</a>
			<br/><br/>
			July 2, 2009<br/>
			<a href="http://www.java-forum-stuttgart.de/veranstaltungsort.html" target="blank">Kultur- & Kongresszentrum Liederhalle (KKL)</a><br/><br/>
			Java Forum Stuttgart is a one-day conference focusing on Java topics for developers.  The Forum
			offers participants the opportunity to learn through lectures, case studies and product
			presentations.
			<br/><br/>
			There is an Eclipse track at Java Forum Stuttgart, which includes the sessions: <i>Eclipse JPA
			Link: JPA 2.0 and More</i> by Michael Bra&auml;uer and Kersten Mebus, <i>Ten Eclipse Projects You
			Have not Heard Enough About</i> by Wayne Beaton and <i>e4 - the Next Generation Eclipse Platform</i>
			by Jochen Krause.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Application Developer Day]]></name>
		<start-date><![CDATA[July 7, 2009]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/EclipseApplicationDeveloperDayKarlsruhe]]></link>
		<location><![CDATA[Karlsruhe, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://eadd2009.eventbrite.com/">Register Here</a>
			<br/><br/>
			July 7, 2009<br/>
			Silverstroke head office, Ludwig-Erhard-Strasse 2, Ettlingen<br/><br/>
			The Eclipse Application Developer Day 2009 (EADD) is a one-day event focusing on building
			applications using the Eclipse platform. EADD will provide the opportunity to learn more about the
			platform and how it is being used in every day applications. Both experienced Eclipse developers
			and those just getting started will benefit from the information sharing and networking at the
			event.
			<br/><br/>
			EADD 2009 takes place in Karlsruhe and is completely free of charge for participants. 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Acceleo Day]]></name>
		<start-date><![CDATA[July 10, 2009]]></start-date>
		<link><![CDATA[http://www.acceleo.org/wiki/index.php/Eclipse_Acceleo_Day]]></link>
		<location><![CDATA[Nantes, France]]></location>
		<description>
			<![CDATA[
			<a href="http://www.acceleo.org/wiki/index.php/Eclipse_Acceleo_Day">Register Here</a>
			<br/><br/>
			July 10, 2009<br/>
			Polytech Nantes<br/><br/>
			<a href="http://www.acceleo.org" target="blank">Acceleo</a> is an Eclipse-based toolkit for
			code generation, with a model based approach. Code generation is the technique of using or
			writing programs that write source code. Code generators are tools built to serve engineers
			in the automatic creation of applications. Acceleo is free software and its development is
			totally open. 
			<br/><br/>
			The Eclipse Acceleo Day will be an occasion for some of the users and developers of Acceleo
			to meet and to exchange ideas. This meeting will also be an opportunity to present some of the
			planned extensions to this tool and discuss MDE related subjects. 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse India Summit]]></name>
		<start-date><![CDATA[July 17, 2009]]></start-date>
		<link><![CDATA[http://www.eclipsesummit.com]]></link>
		<location><![CDATA[Bangalore, India]]></location>
		<description>
			<![CDATA[
			<a href="http://www.eclipsesummit.com/registration.html">Register Here</a>
			<br/><br/>
			July 17-18, 2009<br/><br/>
			Eclipse is no longer open source's best-kept secret.  It has come out of the closet, and how!  Now at a crossroad in its
			evolution, the ecosystem's footprint is broadening to encompass a larger spectrum of offerings for software developers in
			areas such as modeling, embedded, mobile, RIA and Ajax, SOA and dynamic languages. Eclipse India Summit (ESI), Asia's
			first and annual Eclipse-only show, will feature all that you need to know as a developer using Eclipse-based tools and
			technologies.
			<br/><br/>
			One of the largest user bases for Eclipse in the world, the Indian ecosystem of software/tool developers and technology
			companies are benefiting from quick time-to-market and standardized user experiences by building their tools using
			Eclipse technology. Brought to you by Saltmarch Media, producers of the hugely successful Great Indian Developer Summit,
			in association with India's pioneering and foremost group of Eclipse intelligentsia, ANCiT Consulting, Eclipse Summit
			India 2009 will feature four core tracks that hold relevance, immediacy and impact for the Eclipse ecosystem in India.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[OSCON]]></name>
		<start-date><![CDATA[July 20, 2009]]></start-date>
		<link><![CDATA[http://en.oreilly.com/oscon2009]]></link>
		<location><![CDATA[San Jose, CA, USA]]></location>
		<description>
			<![CDATA[
			<a href="https://en.oreilly.com/oscon2009/public/register">Register Here</a>
			<br/><br/>
			July 20-24, 2009<br/>
			San Jose McEnery Convention Center, 150 West San Carlos St.<br/><br/>
			Now in its eleventh year, the O'Reilly Open Source Convention (OSCON) is moving locations to the
			San Jose Convention Center in California.  The conferencer will bring together over 3,000 experts,
			visionaries and hackers in the trenches to explore all that open source has to offer. 2009 promises
			interesting developments in Linux, Java, Web, and open source infrastructure. OSCON will have
			tracks for Linux, PHP, Perl, Python, Ruby, Java, Mobile, Databases, Desktop Applications, Web
			Applications, Administration, Security, People, Business and Emerging Topics.
			<br/><br/>
			Donald Smith from the Eclipse Foundation will speak at OSCON on <i>Stand Up to the Lawyers - Open
			Source Licensing and Intellectual Property Law 101 for Developers</i>.  Beth Tibitts from IBM
			Research will also give a session on <i>How to Write Your Own Eclipse Plug-ins</i>.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Groovy Meetup]]></name>
		<start-date><![CDATA[July 23, 2009]]></start-date>
		<link><![CDATA[http://groups.google.com/group/groovyvan/browse_thread/thread/a57b2a918420f730?pli=1]]></link>
		<location><![CDATA[Vancouver, BC, Canada]]></location>
		<description>
			<![CDATA[
			<a href="http://groups.google.com/group/groovyvan/browse_thread/thread/a57b2a918420f730?pli=1">Register Here</a>
			<br/><br/>
			July 23, 2009<br/>
			6:30 pm<br/>
			1111 Melville St. (Melville & Thurlow), Suite 480<br/><br/>
			This Groovy Meetup is going to be an informal way to learn about what's going on in Vancouver's
			Groovy world. Andrew Eisenberg from SpringSource will be talking about the new Groovy Eclipse
			plugin and compiler support that SpringSource is working on, and there will be people from
			Boats.com who will talk about how their use of Groovy and Grails has affected their
			applications.  Afterwards, everyone will head to the pub and get to some real business! 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Northern Virginia Eclipse User Group Meeting]]></name>
		<start-date><![CDATA[July 30, 2009]]></start-date>
		<link><![CDATA[http://fs2.formsite.com/foxhole/form295295764/index.html]]></link>
		<location><![CDATA[Falls Church, VA, USA]]></location>
		<description>
			<![CDATA[
			<a href="http://fs2.formsite.com/foxhole/form295295764/index.html">Register Here</a>
			<br/><br/>
			July 30, 2009<br/>
			11:30am - 12:45pm<br/>
			Skyline 3 (IntelliDyne Conf. Room), Suite 1600, 5201 Leesburg Pike<br/><br/>
			The Northern Virginia Eclipse User Group is holding their monthly meeting with the topic
			Cloud Computing usine Eclipse and Amazon Web Services. Ken Miller, Software Development
			Manager with Amazon Web Services will present.  Discussion will include the unique challenges
			and advantages of Open Source and Eclipse, and how your organization can participate in the
			Eclipse community to help you achieve maximum success for your projects. Attendance is free,
			but please register in advance.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Modeling Stammtisch]]></name>
		<start-date><![CDATA[August 19, 2009]]></start-date>
		<link><![CDATA[http://thegordian.blogspot.com/2009/08/modeling-stammtisch-details.html]]></link>
		<location><![CDATA[Berlin, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://www.doodle.com/qwpp6p8wtcq78t2in">Register Here</a>
			<br/><br/>
			August 19, 2009<br/>
			6:30pm
			Prater Garten, Kastanienallee 7 - 9<br/><br/>
			Ed Merks, Eike Stepper and Ralph Mueller are hosting an Eclipse Modeling Stammtisch (or "regular's table"
			with beers) for the Eclipse community.  Come out if you'd like to talk about modeling, or
			even just Eclipse in general!
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[ruhrjug (Java User Group) Meeting]]></name>
		<start-date><![CDATA[August 20, 2009]]></start-date>
		<link><![CDATA[http://www.ruhrjug.de/vorschau/details/11-jan-koehnlein]]></link>
		<location><![CDATA[Essen, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://www.ruhrjug.de/vorschau/details/11-jan-koehnlein">Register Here</a>
			<br/><br/>
			August 20, 2009<br/>
			6:30pm - 10:00pm
			Glaspavillon Campus Essen<br/><br/>
			Jan Kohnlein is giving a talk on <i>Domain-specific Languages with Xtext</i> at the Java
			User Group ruhrjug in Essen.  Come out to learn more about DSLs in practice!
			]]>
		</description>
	</event>

	<event>
		<priority>1</priority>
		<name><![CDATA[Eclipse Day at the Googleplex]]></name>
		<start-date><![CDATA[August 27, 2009]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/Eclipse_Day_At_Googleplex_2009]]></link>
		<location><![CDATA[Mountain View, CA, USA]]></location>
		<description>
			<![CDATA[
			<a href="http://wiki.eclipse.org/Eclipse_Day_At_Googleplex_2009#Attendee_Registration">Register Here</a>
			<br/><br/>
			August 27, 2009<br/>
			Googleplex<br/><br/>
			Eclipse Day at the Googleplex is a full day event for developers to learn about different
			Eclipse projects and related technologies. You are invited to attend and listen as experts
			from the Eclipse projects and Google share their experiences of using Eclipse. It's also a
			great opportunity for you to meet and network with other Eclipse enthusiasts. There is no
			cost to attend, but pre-registration is required. 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[FOSSLC Debate on Which OS License is Best]]></name>
		<start-date><![CDATA[August 31, 2009]]></start-date>
		<link><![CDATA[http://www.fosslc.org/drupal/node/407]]></link>
		<location><![CDATA[Ottawa, ON, Canada]]></location>
		<description>
			<![CDATA[
			<a href="http://fosslc.org/drupal/oss_debate_registration">Register Here</a>
			<br/><br/>
			August 31, 2009<br/>
			9:30am - 12:00pm<br/>
			160 Elgin St., 26th Floor, Gowlings board room<br/><br/>
			This event is a debate between proponents of the GPL, EPL, and BSD licenses. Which license is
			the best license for business? For community? For academia? What are the key factors that
			influence the decision regarding an open source license? Are there certain things you should
			look out for?
			<br/><br/>
			This event will educate and entertain in the form of a debate between experts.
			The debate will be moderated by Thomas Prowse, a practising lawyer from Gowlings proficient in
			open source licensing. The debaters are Matt Asay of Alfresco, David Maxwell of Coverity and
			Mike Milinkovich of the Eclipse Foundation.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Belgian Eclipse User Group Meeting]]></name>
		<start-date><![CDATA[September 1, 2009]]></start-date>
		<link><![CDATA[http://www.sigasi.com/node/170/]]></link>
		<location><![CDATA[Gent, Belgium]]></location>
		<description>
			<![CDATA[
			<a href="http://www.sigasi.com/node/170">Register Here</a>
			<br/><br/>
			September 1, 2009<br/>
			6:00 pm
			Sigasi, Parkoffice, F. Rooseveltlaan 348<br/><br/>
			The Belgian Eclipse User Group is proud to present the program of its next meeting on Tuesday,
			September 1, 2009. We have invited some interesting Eclipse speakers including Jan Van de Poel from
			IBM who will present an overview of the JAZZ development framework, and Ralph Mueller from
			the Eclipse Foundation who will talk about the Eclipse ecosystem across Europe. Attendance is
			free, but the number of participants is limited so please register in advance.
			<br/><br/>
			The goal of the Belgian Eclipse User Group is to unite everybody in Belgium who builds a
			product based on Eclipse technology, or who uses Eclipse as their main IDE. 
			]]>			
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[JBoss World]]></name>
		<start-date><![CDATA[September 1, 2009]]></start-date>
		<link><![CDATA[http://www.jbossworld.com/]]></link>
		<location><![CDATA[Chicago, IL, USA]]></location>
		<description>
			<![CDATA[
			<a href="http://www.jbossworld.com/register/">Register Here</a>
			<br/><br/>
			September 1-3, 2009<br/><br/>
			The Red Hat Summit and JBoss World are being held together this year. Both of these open
			source events will bring together engineers, business decision makers, developers and
			community enthusiasts to learn about the latest open source advancements. A comprehensive
			agenda allows attendees the unique opportunity to move between both conferences, and learn
			about open source advancements.
			<br/><br/>
			Of particular note to Eclipse users, Vladimir Ralev &amp; guests will have a BOF on <i>Rapid
			VoIP Development Environment</i>, which will include discussion of the Eclipse VoIP Tooling,
			and Max Rydahl Andersen will give a talk on <i>The JBoss Tools Project and JBoss Developer
			Studio</i>.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Open Business Lunch Bern]]></name>
		<start-date><![CDATA[September 9, 2009]]></start-date>
		<link><![CDATA[http://www.ch-open.ch/events/lunchbe.html]]></link>
		<location><![CDATA[Bern, Switzerland]]></location>
		<description>
			<![CDATA[
			<a href="http://www.ch-open.ch/events/lunchbe.html">Register Here</a>
			<br/><br/>
			September 9, 2009<br/>
			11:45 am - 2:00 pm<br/>
			Restaurant Frohsinn, Muenstergasse 54<br/><br/>
			The /ch/open association is hosting the next Open Business Lunch Bern for members, as well
			as other interested parties, to meet and exchange ideas.
			Andreas Hoegger of Business Systems Integration AG (BSI) will present a short lecture on
			<i>Increased Efficiency, Stability and Flexibility with Eclipse RCP</i>.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Practical Use of EMF Compare]]></name>
		<start-date><![CDATA[September 14, 2009]]></start-date>
		<link><![CDATA[http://www.itemis.com/itemis-ag/events/2009/language=en/taps=646/26056/practical-use-of-emf-compare]]></link>
		<location><![CDATA[Dortmund, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://www.itemis.com/itemis-ag/language=en/26333/registration-series-of-talks-dortmund?training=Practical+use+of+EMF+Compare&date=14.09.2009+%E2%80%93+14.09.2009&location=Dortmund%2c+Harenberg+City+Center">Register Here</a>
			<br/><br/>
			September 14, 2009<br/>
			6:30 pm - 9:00 pm<br/>
			Harenberg City Center<br/><br/>
			Eclipse Foundation member itemis is offering a free series of talks in Dortmund.  In September,
			Dr. Lothar Wendehals and Holger Schill will present the <i>Practical Use of EMF Compare</i>. The
			first part of the presentation will explain using the EMF compare framework and its basic
			function. The run-time behavior of different model sizes is examined to show the practical
			applicability. The second part of the presentation will present the EMF compare tools and the
			Eclipse integration.  After the lecture there will be time for networking.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Open Source in Mobile]]></name>
		<start-date><![CDATA[September 15, 2009]]></start-date>
		<link><![CDATA[http://www.osimconference.com/]]></link>
		<location><![CDATA[Amsterdam, Netherlands]]></location>
		<description>
			<![CDATA[
			<a href="http://event.osimworld.com/register/register">Register Here</a>
			<br/><br/>
			September 15-16, 2009<br/>
			Hotel Okura<br/><br/>
			For the fourth year running, Open Source in Mobile (OSiM) World will bring together the entire
			open source ecosystem to debate and plan for the future of the industry. In addition to our
			multi-streamed fully interactive conference featuring over 80 leading visionaries of the
			open source world, OSiM World will also feature multiple networking events, late night
			coding sessions, the 2nd Annual OSiM Pub Quiz, live apps demos from leading operator and OEM
			apps stores, OpenLounge chillout zones, bloggers corner and a vibrant exhibition floor
			bursting with content and demos. This year, OSiM World in its entirety will be absolutely
			free to the independent developer. We are also pleased to announce WIPJam@ OSiM World, the
			largest mobile developer event in open source.
			<br/><br/>
			Ralph Mueller from the Eclipse Foundation will join Dave Neary - GNOME Foundation and Jay
			Sullivan - Mozilla, for a debate on <i>What is the Best Way to Share Code?</i>.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Stammtisch]]></name>
		<start-date><![CDATA[September 22, 2009]]></start-date>
		<link><![CDATA[http://www.bredex.de/de/news/eclipse.html]]></link>
		<location><![CDATA[Braunschweig, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://www.bredex.de/de/contact/first.html">Register Here</a>
			<br/><br/>
			September 22, 2009<br/>
			7:00 pm<br/>
			Bredex, Mauernstrasse 33<br/><br/>
			The Braunschweig Stammtisch, hosted by Eclipse Foundation member Bredex, is an opportunity to
			share what you're building with Eclipse, what
			problems you might have encountered and solutions you've discovered. The format involves a
			short presentation about Eclipse topics, then the group moves on to a local pub for some food
			and drink. Feel free to invite your friends!  There is no cost to attend.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse-IT]]></name>
		<start-date><![CDATA[September 28, 2009]]></start-date>
		<link><![CDATA[http://eit09.unibg.it/]]></link>
		<location><![CDATA[Bergamo, Italy]]></location>
		<description>
			<![CDATA[
			<a href="http://eit09.unibg.it/">Register Here</a>
			<br/><br/>
			September 28-29, 2009<br/>
			University of Bergamo, Piazzale Sant'Agostino, 2<br/><br/>
			This workshop is the fourth yearly meeting of the Eclipse Italian Community, which includes
			universities, industries, researchers, practitioners, students and professionals, all joined by
			an interest in experimenting, extending and supporting the Eclipse platform.
			<br/><br/>
			This year the conference will have sessions on Jazz technology and will feature an industrial
			track in addition to the regular track for research papers and the student track for student
			papers and demos.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Insurance Day]]></name>
		<start-date><![CDATA[September 30, 2009]]></start-date>
		<link><![CDATA[http://www.eclipse-insurance.org/en/index.html]]></link>
		<location><![CDATA[Cologne, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://www.eclipse-insurance.org/en/direct.html">Register Here</a>
			<br/><br/>
			September 30, 2009<br/>
			Im MediaPark 6<br/><br/>
			Insurance experts, IT managers and software architects will meet to communicate and
			exchange experiences at this one-day event. Members from the insurance industry and leading
			Open Source development companies will fill the agenda with exciting talks.
			<br/><br/>
			Get an overview of the options Eclipse is offering for insurance-focused IT applications.
			Find out how to leverage Eclipse technology and the Eclipse community as part of your
			development strategy.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Open World Forum]]></name>
		<start-date><![CDATA[October 1, 2009]]></start-date>
		<link><![CDATA[http://openworldforum.org]]></link>
		<location><![CDATA[Paris, France]]></location>
		<description>
			<![CDATA[
			<a href="http://openworldforum.org/Register">Register Here</a>
			<br/><br/>
			October 1-2, 2009<br/>
			Eurosites George V, 28 avenue George V<br/><br/>
			The Open World Forum is the leading global summit bringing together decision-makers from
			across the world to discuss the technological, financial and social impact of open
			technologies. At the hub of the Open Source revolution, the Open World Forum 2009 will include
			a FLOSS Communities Summit, an Open CIO Summit, a FLOSS Competence Centers Summit, a FLOSS
			Political Summit keynote and an egov Open Source event from IDABC, an Open Innovation Summit,
			key conferences on open source and numerous other associated events.
			<br/><br/>
			Look for Mike Milinkovich, Executive Director of the Eclipse Foundation, during the Open
			Source Communities keynote.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Code Camp - Modeling]]></name>
		<start-date><![CDATA[October 12, 2009]]></start-date>
		<link><![CDATA[http://entwickler-akademie.de/ak/codecamps/eclipse-cc-modeling-en]]></link>
		<location><![CDATA[Munich, Germany]]></location>
		<description>
			<![CDATA[
			<a href="https://www.entwickler.com/ssl/formtool/index.php?id=63&lang=en">Register Here</a>
			<br/><br/>
			October 12-15, 2009<br/>
			Novotel Muenchen Messe, Willy-Brandt-Platz 1<br/><br/>
			The new Eclipse Code Camp - Modeling is presented by the Eclipse Magazin and the Entwickler
			Akademie. The 4-day camp illustrates the benefits of Modeling and teaches how best to exploit
			them in your own projects. You'll leave with a broad overview of state of the art
			technology as well as deep insights into the repertoire of building blocks that are available,
			by learning from leading experts in the Eclipse Modeling scene. You'll enjoy four exciting
			and fun filled days with Ed Merks, lead of the Eclipse Modeling Project and the Eclipse
			Modeling Framework (EMF) subproject, and Eike Stepper, lead of the CDO Model Repository
			subproject.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Zend/PHP Conference]]></name>
		<start-date><![CDATA[October 19, 2009]]></start-date>
		<link><![CDATA[http://www.zendcon.com/ZendCon08/public/content/home]]></link>
		<location><![CDATA[San Jose, CA, USA]]></location>
		<description>
			<![CDATA[
			<a href="http://www.zendcon.com/registration">Register Here</a>
			<br/><br/>
			October 19-22, 2009<br/>
			San Jose McEnery Convention Center, 150 W. San Carlos St.<br/><br/>
			The Zend/PHP conference will be the largest gathering of the PHP Community and will bring
			together PHP developers and business managers from around the world for three days of
			exceptional presentation and networking events. At ZendCon 2009, sessions will focus on
			creating, deploying and managing applications that take advantage of the speed, scalability
			and simplicity of PHP. ZendCon is a premier event for technical education and the conference
			attracts attendees including developers, IT executives and managers, and PHP users at all
			levels. The Zend/PHP Conference is designed to be an intensive learning event and one of the
			best PHP networking events of the year.
			<br/><br/>
			Roy Ganor will give a talk on <i>To Eclipse or Not to Eclipse - That is the Question</i>,
			on the PHP Development Tools project at Eclipse.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Elmshorner Wirtschaftsinformatiktag]]></name>
		<start-date><![CDATA[October 23, 2009]]></start-date>
		<link><![CDATA[http://ewita.nordakademie.de/]]></link>
		<location><![CDATA[Elmshorn, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://ewita.nordakademie.de/registration.html">Register Here</a>
			<br/><br/>
			October 23, 2009<br/>
			Nordakademie, Koellner Chausee 11<br/><br/>
			The first Elmshorner Wirtschaftsinformatiktag will elaborate on the topic "Modeling the Business".
			Heiko Behrens from itemis will speak about <i>Mastering Differentiated MDSD Requirements at Deutsche
			Boerse AG</i> and Arne-Michael Toersel from FH Stralsund will speak on the <i>Application of openArchitectureWare to Test
			Case Generation for Web Applications</i>.
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[Ontario Linux Fest]]></name>
		<start-date><![CDATA[October 24, 2009]]></start-date>
		<link><![CDATA[http://onlinux.ca/]]></link>
		<location><![CDATA[Toronto, ON, Canada]]></location>
		<description>
			<![CDATA[
			<a href="http://onlinux.ca">Register Here</a>
			<br/><br/>
			October 24, 2009<br/>
			Days Hotel and Conference Centre - Toronto Airport East, 1677 Wilson Ave.<br/><br/>
			Ontario Linux Fest is the conference, workshop and community meeting place that is organized and
			run by the community for the community. This full day of presentations, workshops,
			birds-of-a-feather and social networking is ready to go for the third year. Everybody with an
			interest in using, deploying and developing Free / Libre and Open Source Software will find
			Ontario Linux Fest well worth their while. 
			<br/><br/>
			Watch for a display on Eclipse organized by Andrew Overholt from Red Hat!
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[OOPSLA]]></name>
		<start-date><![CDATA[October 25, 2009]]></start-date>
		<link><![CDATA[http://www.oopsla.org/]]></link>
		<location><![CDATA[Orlando, FL, United States]]></location>
		<description>
			<![CDATA[
			<a href="http://www.oopsla.org/oopsla2009/attending-oopsla/registration">Register Here</a>
			<br/><br/>
			October 25-29, 2009<br/>
			Disney's Comtemporary Resort<br/><br/>
			OOPSLA is the conference of choice for software technoologists - from recognized academics to
			undergraduate students, from industrial researchers to developers and managers, from the
			creators of technology to its users. Seed Clouds, Scale and Mash, be Reliable and Agile!
			There are 4 co-located events: WikiSym, Mini-PLoP, Dynamic Language Symposium and Onward!
			<br/><br/>
			There is an Eclipse tutorial by Bruce Trask and Angel Roman from MDE Systems on an <i>Introduction
			to Model Driven Development with Examples using Eclipse Frameworks</i> on Sunday and a Software Tools
			and Libraries panel titled <i>Accelerating
			the Creation of Customized, Language-Specific IDEs in Eclipse</i> on Wednesday.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[TheServerSide Java Symposium Europe]]></name>
		<start-date><![CDATA[October 27, 2009]]></start-date>
		<link><![CDATA[http://javasymposium.techtarget.com/europe/europe_info.html]]></link>
		<location><![CDATA[Prague, Czech Republic]]></location>
		<description>
			<![CDATA[
			<a href="http://javasymposium.techtarget.com/html/register.html">Register Here</a>
			<br/><br/>
			October 27-28, 2009<br/>
			<a href="http://www.cchp.cz/pages/cz/default.aspx" target="blank">Clarion Congress Hotel Prague</a>, Freyova 33<br/><br/>
			Created by TheServerSide.com, the Web's largest independent enterprise Java community,
			TheServerSide Java Symposium is jam-packed with 2 full days of technical knowledge and
			definitive real-world solutions delivered by today's most respected experts. And this year
			we've designed specific sessions that fall under 4 focused tracks to address exactly how you
			can accelerate your organization's projects for the next 6-18 months: frameworks, architetures
			languages and tools &amp; techniques.
			<br/><br/>
			Eclipse committer Andrew Johnson will talk about the Eclipse Memory Analyzer project in his
			talk, <i>Practical Lessons in Memory Analysis</i>
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Smartphone Show]]></name>
		<start-date><![CDATA[October 27, 2009]]></start-date>
		<link><![CDATA[http://www.smartphoneshow.com]]></link>
		<location><![CDATA[London, United Kingdom]]></location>
		<description>
			<![CDATA[
			<a href="http://www.smartphoneshow.com">Register Here</a>
			<br/><br/>
			October 27-28, 2009<br/>
			Earls Court 2<br/><br/>
			Now in its eleventh year, the Smartphone Show continues to bring together the leaders and visionaries shaping the future of
			mobile.	 Network with over 4,000 representatives from major handset vendors, content providers, network operators and developers and
			experience the latest smartphones, components, applications and software.  Learn from industry case studies and see where
			the key players are taking the future of mobile.
			]]>
		</description>
	</event>

	<event>
		<priority>1</priority>
		<name><![CDATA[Eclipse Summit Europe]]></name>
		<start-date><![CDATA[October 27, 2009]]></start-date>
		<link><![CDATA[http://www.eclipsecon.org/summiteurope2009/]]></link>
		<location><![CDATA[Ludwigsburg, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://www.eclipsecon.org/summiteurope2009/">Register Here</a>
			<br/><br/>
			October 27-29, 2009<br/>
			<a href="http://www.ludwigsburg.de/servlet/PB/menu/1187968_l1/index.html" target="blank">Forum am Schlosspark</a><br/><br/>
			The Eclipse Foundation is hosting the 4th annual Eclipse Summit Europe on October 27-29, 2009. To be held in the
			Stuttgart region of Germany, the Eclipse Summit is the Foundation's premier event designed to create opportunities for
			the European Eclipse community to explore, share and collaborate on the latest ideas and information about Eclipse and
			its members. 
			<br/><br/>
			The conference will consist of one day of symposia followed by two days of technical and business track sessions, selected
			keynotes, demos and networking gatherings. Sponsors supporting the Eclipse Summit will showcase their latest products and
			services, as well as the exciting contributions their organizations are making to the Eclipse ecosystem. The conference
			is a stimulating and dynamic event for Eclipse committers, contributors, adopters, add-in providers and service providers
			to learn, share expertise and discover new opportunities and solutions in the Eclipse ecosystem. 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[W-JAX]]></name>
		<start-date><![CDATA[November 9, 2009]]></start-date>
		<link><![CDATA[http://w-jax.de/]]></link>
		<location><![CDATA[Munich, Germany]]></location>
		<description>
			<![CDATA[
			<a href="https://www.entwickler.com/ssl/formtool/index.php?id=42&lang=de">Register Here</a>
			<br/><br/>
			November 9-13, 2009<br/>
			ArabellaSheraton Grand Hotel, Arabellastrasse 6<br/><br/>
			W-JAX is the conference for holistic, technical know-how in the enterprise and web
			environment. Here Europe's leading experts come together to distribute their knowledge and
			experience to attendees. Perfect organization, expert competence, as well as the comfortable
			ambiance make W-JAX a unique experience. The SOACON, which focuses on the technical and
			business aspects of the service orientated architecture, forms a strong team together
			with W-JAX, and offers a broad orientation in a dynamic technology environment.
			<br/><br/>
			Eclipse sessions include <i>JPA Under the Hood</i> by Alois Reitbauer, <i>Introduction to the
			OSGi Service Platform</i> by Gerd Wuetherich and Nils Hartmann, <i>Divide and Conquer - Eclipse
			RCP and Spring in Distributed Applications</i> by Benjamin Pasero and Stefan Reichert, and
			<i>Advanced Eclipse Rich Client Platform</i> by Kai Toedter.
			]]>
		</description>
	</event>

	<event>
		<priority>1</priority>
		<name><![CDATA[Eclipse Modeling Day in New York]]></name>
		<start-date><![CDATA[November 16, 2009]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/Eclipse_Modeling_Day]]></link>
		<location><![CDATA[New York, NY, United States]]></location>
		<description>
			<![CDATA[
			<a href="http://wiki.eclipse.org/Eclipse_Modeling_Day#NYC_Attendee_Registration">Register Here</a>
			<br/><br/>
			November 16, 2009<br/>
			Credit Suisse Offices, One Madison Ave. (Clock Tower Building)<br/><br/>
			The Eclipse Modeling Day is a day-long event that explores the tools and frameworks developed by the
			Eclipse modeling community. This is your opportunity to learn how you can incorporate model driven
			development into your software development efforts. Eclipse modeling experts will present the
			innovations in the Eclipse modeling projects. End-user organizations, like Credit Suisse and Los
			Alamos National Labs, will discuss how they benefit from using Eclipse for their modeling needs.
			This event will be ideal for software architects, software development managers and senior
			developers that are interested in deploying model driven development in their organizations.
			There is no cost to attend the event but you must pre-register. 
			]]>
		</description>
	</event>

	<event>
		<priority>1</priority>
		<name><![CDATA[EclipseRT Day in Austin]]></name>
		<start-date><![CDATA[November 17, 2009]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/EclipseRT_Day]]></link>
		<location><![CDATA[Austin, TX, United States]]></location>
		<description>
			<![CDATA[
			<a href="http://wiki.eclipse.org/EclipseRT_Day#Austin_Attendee_Registration">Register Here</a>
			<br/><br/>
			November 17, 2009<br/>
			IBM Austin Research Lab, 11501 Burnet Rd.<br/><br/>
			EclipseRT is the portfolio of Eclipse projects that include runtime frameworks used to build and
			deploy running applications. EclipseRT is based on component oriented development architecture built
			on the Equinox runtime framework, an implementation of the OSGi standard. EclipseRT Day is your
			opportunity to discover what is possible using Equinox and the complementary projects, such as
			EclipseLink, RAP, Eclipse RCP, etc. Experts from the EclipseRT community will discuss how you can
			build applications for embedded devices, desktops and even large scale server applications. IBM,
			SpringSource and TD Canada Trust will share their experiences of using Equinox and OSGi for their
			solutions. This event is for software architects, software development managers and senior
			developers that are interested in adopting a component-based architecture for their software.
			There is no cost to attend the event but you must pre-register. 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Free Open Source Software Academia Conference]]></name>
		<start-date><![CDATA[November 17, 2009]]></start-date>
		<link><![CDATA[http://ocs.inrialpes.fr/2009/?q=node/2]]></link>
		<location><![CDATA[Grenoble, France]]></location>
		<description>
			<![CDATA[
			<a href="http://ocs.inrialpes.fr/2009/?q=node/5">Register Here</a>
			<br/><br/>
			November 17-18, 2009<br/><br/>
			The fOSSa Conference aims to suppost anyone who would like to create, sustain and transfer
			an OSS project from the laboratory to the industrial world in a more productive manner.
			Start-ups and companies can attend to  find answers to overcome Open Source "constraints"
			within their environment and better understand the OSS culture. Academia and industrials can
			meet, talk together and find synergies between research projects and industrial needs. 
			Let fOSSa show you the benefits of participating in a collaborative network that is
			aimed at increasing the value of academic results, gathering them in a common environment
			and releasing them in Open Source.
			<br/><br/>
			The program is packed with 2 days of OSS sessions, including Ralph Mueller from the Eclipse
			Foundation speaking on <i>OSS and Collaboration for Innovating Academic Projects</i>.
			]]>
		</description>
	</event>

	<event>
		<priority>1</priority>
		<name><![CDATA[Eclipse Modeling Day in Toronto]]></name>
		<start-date><![CDATA[November 18, 2009]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/Eclipse_Modeling_Day]]></link>
		<location><![CDATA[Toronto, ON, Canada]]></location>
		<description>
			<![CDATA[
			<a href="http://wiki.eclipse.org/Eclipse_Modeling_Day#Toronto_Attendee_Registration">Register Here</a>
			<br/><br/>
			November 18, 2009<br/>
			IBM Toronto Lab, 8200 Warden Ave., Markham<br/><br/>
			The Eclipse Modeling Day is a day-long event that explores the tools and frameworks developed by the
			Eclipse modeling community. This is your opportunity to learn how you can incorporate model driven
			development into your software development efforts. Eclipse modeling experts will present the
			innovations in the Eclipse modeling projects. End-user organizations, like Credit Suisse and Los
			Alamos National Labs, will discuss how they benefit from using Eclipse for their modeling needs.
			This event will be ideal for software architects, software development managers and senior
			developers that are interested in deploying model driven development in their organizations.
			There is no cost to attend the event but you must pre-register. 
			]]>
		</description>
	</event>

	<event>
		<priority>1</priority>
		<name><![CDATA[EclipseRT Day in Toronto]]></name>
		<start-date><![CDATA[November 19, 2009]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/EclipseRT_Day]]></link>
		<location><![CDATA[Toronto, ON, Canada]]></location>
		<description>
			<![CDATA[
			<a href="http://wiki.eclipse.org/EclipseRT_Day#Toronto_Attendee_Registration">Register Here</a>
			<br/><br/>
			November 19, 2009<br/>
			IBM Toronto Lab, 8200 Warden Ave., Markham<<br/><br/>
			EclipseRT is the portfolio of Eclipse projects that include runtime frameworks used to build and
			deploy running applications. EclipseRT is based on component oriented development architecture built
			on the Equinox runtime framework, an implementation of the OSGi standard. EclipseRT Day is your
			opportunity to discover what is possible using Equinox and the complementary projects, such as
			EclipseLink, RAP, Eclipse RCP, etc. Experts from the EclipseRT community will discuss how you can
			build applications for embedded devices, desktops and even large scale server applications. IBM,
			SpringSource and TD Canada Trust will share their experiences of using Equinox and OSGi for their
			solutions. This event is for software architects, software development managers and senior
			developers that are interested in adopting a component-based architecture for their software.
			There is no cost to attend the event but you must pre-register. 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[MOSKittDay & EclipseDay]]></name>
		<start-date><![CDATA[December 1, 2009]]></start-date>
		<link><![CDATA[http://www.moskitt.org/eng/moskittday-eclipseday/]]></link>
		<location><![CDATA[Valencia, Spain]]></location>
		<description>
			<![CDATA[
			<a href="http://www.moskitt.org/eng/boletin_inscripcion0/">Register Here</a>
			<br/><br/>
			December 1, 2009<br/>
			Convention and Exhibition Centre of Feria Valencia<br/><br/>
			Conselleria de Infraestructruras y Transporte (CIT) of the Valencian Comunity Regional
			Government is organizing MOSKittDay together with the second EclipseDay. CIT is a member of
			the Eclipse Foundation and leads the MOSKitt (Modeling Software Kitt) project in the development of
			an open source CASE tool based on Eclipse. 
			<br/><br/>
			MOSkittDay has a double goal. On the one hand CIT wants to make the MOSKitt Project known and to
			promote collaboration with other public and private organizations. On the other hand, CIT is also
			interested on making the MOSKitt CASE Tool known to future users beyond its current scope,
			identifying the added value that MOSKitt as a CASE Tool can give: support to Model Driven
			Development (a new strategy of software develpoment) integrated in a Software Development Metodology. 
			<br/><br/>
			In addition to this event, CIT will also host the EclipseDay event for the second time. EclipseDay
			is an Eclipse Foundation initiative. The idea behind it is to spread the Eclipse ecosystem
			across Europe. It aims to consolidate the Eclipse community and introduce new people, especially
			from the host country, Spain, to it. The aim of EclipseDay in Valencia is to bring the Spanish
			community of Eclipse users and developers together for a series of talks and technical tutorials,
			along the lines of similar events that have been held in other parts of the world. Participants are
			expected come from a wide range of academic, institutional and business backgrounds.			
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Stammtisch in Bern]]></name>
		<start-date><![CDATA[December 15, 2009]]></start-date>
		<link><![CDATA[http://doodle.com/vdrwz3m36k4ipm9e]]></link>
		<location><![CDATA[Bern, Switzerland]]></location>
		<description>
			<![CDATA[
			<a href="http://doodle.com/vdrwz3m36k4ipm9e">Register Here</a>
			<br/><br/>
			December 15, 2009<br/>
			6:00 pm<br/>
			<a href="http://maps.google.com/maps?f=q&source=s_q&hl=en&geocode=&q=Eigerplatz,+3007+Berne,+Switzerland&sll=37.0625,-95.677068&sspn=58.685917,135.263672&ie=UTF8&hq=&hnear=Eigerplatz,+3007+Berne,+Switzerland&t=h&z=16">Puzzle Offices</a>, Eigerplatz 4<br/><br/>
			The Bern Stammtisch, hosted by Eclipse Foundation member Puzzle ITC, is an opportunity to
			discuss Eclipse and toast the end of 2009.  Feel free to invite your friends!  There is no cost to attend.			
			]]>
		</description>
	</event>

	<event>
		<priority>1</priority>
		<name><![CDATA[Eclipse Foundation Holiday Meetup]]></name>
		<start-date><![CDATA[December 18, 2009]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/Foundation09holidaymeetup]]></link>
		<location><![CDATA[Ottawa, ON, Canada]]></location>
		<description>
			<![CDATA[
			<a href="http://wiki.eclipse.org/Foundation09holidaymeetup">Register Here</a>
			<br/><br/>
			December 18, 2009<br/>
			3:00 pm<br/>
			<a href="http://www.marshys.com/images/map.jpg">Marshy's Bar-B-Q & Grill</a>, 117 Centrepointe Dr.<br/><br/>
			The Eclipse Foundation welcomes the Eclipse community to a gathering in celebration of the holidays.
			It will be a stammtisch for Canadians - buy yourself a drink and Eclipse will supply the snacks. 
			We hope you can join us!		
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>JUGS Event: e4 - The Next Generation of the Eclipse Platform</name>
		<start-date>January 14, 2010</start-date>
		<link>http://www.jugs.ch/html/events/2010/e4.html</link>
		<location>Zurich, Switzerland</location>
		<description>
			<![CDATA[
			<a href="http://www.sigs-datacom.de/anmeldung-preise/konditionen.html">Register Here</a>
			<br/><br/>
			January 14, 2010<br/>
			5:00 pm - 6:15 pm with refreshments afterwards<br/>
			Technopark Zurich, Room Fortran<br/><br/>			
			Java User Group Switzerland (JUGS) is hosting a presentation by Tom Schindl of
			<a href="http://www.bestsolution.at/" target="blank">BestSolution.at</a> on e4, the next
			generation of the Eclipse platform. e4 is a completely new developed application framework,
			based on technologies such as EMF and programming models such as DI (dependency injection).
			The presentation will be given in German with slides in English.
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name>OOP</name>
		<start-date>January 25, 2010</start-date>
		<link>http://www.sigs-datacom.de/sd/kongresse/oop_2010/index.php</link>
		<location>Munich, Germany</location>
		<description>
			<![CDATA[
			<a href="http://www.sigs-datacom.de/anmeldung-preise/konditionen.html">Register Here</a>
			<br/><br/>
			January 25-29, 2010<br/>
			International Congress Center Munich, Messegalaende<br/><br/>			
			OOP 2010 emphasizes three major themes focused around increasing productivity: people,
			process and technology. The conference addresses technical issues in the context of software
			development as well as from a business perspective.  OOP provides in-depth and unbiased
			information on current software issues such as dynamic languages, Web 2.0, multicore and 
			cloud computing.
			<br/><br/>
			Markus Voeleter and Andreas Graf will speak on model-driven development with Eclipse tools for
			embedded systems and Kai Toedter will speak on Advanced Eclipse Rich Client Platform. 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Stammtisch in Munich]]></name>
		<start-date><![CDATA[January 28, 2010]]></start-date>
		<link><![CDATA[http://www.doodle.com/f4npwkcwes5cii8p]]></link>
		<location><![CDATA[Munich, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://www.doodle.com/f4npwkcwes5cii8p">Register Here</a>
			<br/><br/>
			January 28, 2010<br/>
			7:00 pm<br/>
			<a href="http://www.kuffler-gastronomie.de/de/muenchen/gruental/index.php">Wirtshaus im GruenTal</a>, Gruental 15<br/><br/>
			The Munich Stammtisch, hosted by Eclipse Foundation member MicroDoc, is an opportunity to
			discuss Eclipse and plans for 2010.  Feel free to invite your friends!  There is no cost to attend.			
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[ITEA 2 Project Outline Preparation Days]]></name>
		<start-date><![CDATA[February 1, 2010]]></start-date>
		<link><![CDATA[http://www.itea2.org/po_days2010]]></link>
		<location><![CDATA[Berlin, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://www.itea2.org/meeting/">Register Here</a>
			<br/><br/>
			February 1-2, 2010<br/><br/>
			ITEA 2 (Information Technology for European Advancement) stimulates and supports innovative and
			pre-competitive R&D projects that will contribute research excellence to Europe's competitive
			Software-Intensive Systems and Services.
			<br/><br/>
			In order to prepare yourself for this 5th Call, a two-day brokerage event is organised in Berlin,
			February 1-2, 2010. Participation is free of charge and open to all those with an interest in our
			5th Call.The aim of this two-day meeting is to help organisations form consortia and generate
			preliminary outlines for projects by bringing together interested companies, research institutes
			and universities with innovative ideas for projects in ITEA 2. 	
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Open Business Lunch Bern - EMF]]></name>
		<start-date><![CDATA[February 10, 2010]]></start-date>
		<link><![CDATA[http://www.ch-open.ch/events/lunchbe.html]]></link>
		<location><![CDATA[Bern, Switzerland]]></location>
		<description>
			<![CDATA[
			<a href="http://www.ch-open.ch/events/lunchbe.html">Register Here</a>
			<br/><br/>
			February 10, 2010<br/>
			Restaurant Frohsinn, Meunstergasse 54<br/><br/>
			Open Business Lunch Bern will present the theme EMF Simple at their next meeting.
			Simon Hofer, Matthias Hutter and Luke Steinter will hold a short lecture on the Eclipse Modeling
			Framework (EMF) and how to keep it simple for use in effective business models.  Registration
			is open until February 9.
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse in Denmark: e4 and General Assembly]]></name>
		<start-date><![CDATA[February 11, 2010]]></start-date>
		<link><![CDATA[http://sites.google.com/a/eclipse.dk/publicpublic/arrangements/2010-02-11-eclipse-e4-og-generalforsamling]]></link>
		<location><![CDATA[Ballerup, Denmark]]></location>
		<description>
			<![CDATA[
			<a href="http://sites.google.com/a/eclipse.dk/publicpublic/arrangements/tilmelding">Register Here</a>
			<br/><br/>
			February 11, 2010<br/>
			4:00pm - 8:00pm
			Topcenter, Borupvang 4<br/><br/>
			This summer Eclipse e4 1.0 is being released, but what is it about and what does it mean
			for plug-in development? In this meeting, Tonny Madsen, RCP Company, will describe plug-in
			development in Eclipse e4 and will look at some of the changes for plug-in developers.
			In addition, Eclipse.dk we will hold its Annual General Meeting.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>Eclipse Stammtisch in Hamburg</name>
		<start-date>February 22, 2010</start-date>
		<link>http://thomaskratz.blogspot.com/2010/02/eclipse-stammtisch-in-hamburg-am.html</link>
		<location>Hamburg, Germany</location>
		<description>
			<![CDATA[
			<a href="http://thomaskratz.blogspot.com/2010/02/eclipse-stammtisch-in-hamburg-am.html">Register Here</a>
			<br/><br/>
			February 22, 2010<br/>
			7:00 pm<br/>
			Kick & Company, Klausstrasse 1<br/><br/>			
			The Eclipse Stammtisch in Hamburg is an opportunity for Eclipse enthusiasts to meet up.
			Feel free to invite your friends!  There is no cost to attend, but kindly register in advance.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>JAX London</name>
		<start-date>February 22, 2010</start-date>
		<link>http://jaxlondon.com/</link>
		<location>London, United Kingdom</location>
		<description>
			<![CDATA[
			<a href="http://jaxlondon.com/conferences/Pricing/">Register Here</a>
			<br/><br/>
			February 22-24, 2010<br/>
			Novotel London West<br/><br/>			
			JAX London will provide an ideal forum for software developers, project managers and
			architects to learn about the latest Technology, Architecture and Agile Methodologies.
			The primary goal of JAX is to showcase technical solutions for today's problems and offer
			visions to the important trends of tomorrow. Delegates will benefit from hand-picked
			technical content with no marketing bushwah.
			<br/><br/>
			Eclipse talks include: <i>OSGi, Eclipse and API Tooling</i> by Chris Aniszczyk from
			EclipseSource and <i>Introducing the OSGi JPA Standard</i> by Shaun Smith and Mike Keith
			from Oracle.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>Belgian Eclipse User Group Meeting</name>
		<start-date>February 23, 2010</start-date>
		<link>http://www.peopleware.be/belgian-eclipse-user-group</link>
		<location>Lier, Belgium</location>
		<description>
			<![CDATA[
			<a href="http://extranet.peopleware.be/peopleware/public/enrol/Training+Manager.nsf/wEnrolment?OpenForm&ID=E9827E852B5DFAABC12576C000558D42">Register Here</a>
			<br/><br/>
			February 23, 2010<br/>
			6:00pm - 10:00pm
			PeopleWare NV, Buwijckstraat 17<br/><br/>			
			The Belgian Eclipse User Group presents the first meeting of 2010 on Tuesday, February 23 at
			6:00pm. This time we have not only invited speakers about Eclipse 4, but also contributions by
			our fellow community members. Community talks will cover Eclipse RCP, GMF, RAP and more! Attendance is
			free, but registration is required and the number of participants is limited. 
			<br/><br/>
			The goal of the Belgian Eclipse User Group is to unite everybody in Belgium who builds a product
			based on Eclipse technology, or who uses Eclipse as their main IDE.  Feel free to invite friends
			and colleagues who may also be interested. We hope to see you on February 23!
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>Eclipse Get-Together in Braunschweig</name>
		<start-date>February 24, 2010</start-date>
		<link>http://www.bredex.de/en/news/eclipse.html</link>
		<location>Braunschweig, Germany</location>
		<description>
			<![CDATA[
			<a href="http://www.bredex.de/en/news/eclipse.html">Register Here</a>
			<br/><br/>
			February 24, 2010<br/>
			7:00pm<br/>
			Bredex, Mauernstrasse 33<br/><br/>			
			You are invited to the next Eclipse get-together in Braunschweig! Markus Tiede will be
			talking about a "normal day working with Eclipse", and we're pleased to have Ralph Mueller
			from the Eclipse Foundation at the get-together again.
			<br/><br/>
			If you are planning on coming or you would like to give a talk at the get-together, please
			register in advance. As always, feel free to invite friends or colleagues.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Code Camp - Modeling]]></name>
		<start-date><![CDATA[March 1, 2010]]></start-date>
		<link><![CDATA[http://entwickler-akademie.de/ak/codecamps/eclipse-cc-modeling-en]]></link>
		<location><![CDATA[Berlin, Germany]]></location>
		<description>
			<![CDATA[
			<a href="https://www.entwickler.com/ssl/formtool/index.php?id=63&lang=_en">Register Here</a>
			<br/><br/>
			March 1-5, 2010<br/>
			NH Berlin Mitte, Leipziger Strasse 106-111<br/><br/>
			The next Eclipse Code Camp - Modeling is presented by Eclipse Magazin and the Entwickler
			Akademie. This five-day training illustrates benefits and teaches you how best to exploit them in
			your own projects. You'll leave with a broad 
			overview of state of the art technology as well as deep insights into the basic repertoire of
			leading experts in the Eclipse Modeling scene. You'll enjoy five exciting and fun filled days
			with Ed Merks, lead of the Eclipse Modeling Project and the Eclipse Modeling Framework (EMF)
			subproject, and Eike Stepper, lead of the CDO Model Repository subproject. The sessions comprise
			a combination of well-aligned presentations and discussions along with extensive hands-on
			exercises. You'll discover just how much tedious manual work is reduced when modeling is
			effectively applied. The fact that all this technology is freely and openly available is an added
			bonus.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Embedded World]]></name>
		<start-date><![CDATA[March 2, 2010]]></start-date>
		<link><![CDATA[http://www.embedded-world.de/en/]]></link>
		<location><![CDATA[Nuremberg, Germany]]></location>
		<description>
			<![CDATA[
			<a href="https://www.embedded-world.eu/registration.html?step=1">Register Here</a>
			<br/><br/>
			March 2-4, 2010<br/><br/>
			Embedded World is the most important get-together for the international embedded community.
			Are you looking for an insight into the latest technical developments or discussions with
			experts? Then look forward to this ultimate embedded event. Here you will find the ideal forum
			for making new contacts and strengthening existing business relations.
			<br/><br/>
			Eclipse member itemis will give a hands-on class titled <i>Model-Based Development with 
			Eclipse</i>. 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[CeBIT]]></name>
		<start-date><![CDATA[March 2, 2010]]></start-date>
		<link><![CDATA[http://www.cebit.de/homepage_e]]></link>
		<location><![CDATA[Hanover, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://www.cebit.de/7380">Register Here</a>
			<br/><br/>
			March 2-6, 2010<br/>
			Hanover Exhibition Grounds, Hermesallee<br/><br/>
			CeBIT is the world's largest trade fair showcasing digital IT and telecommunications solutions for
			home and work environments. The key target groups are users from industry, the wholesale/retail
			sector, skilled trades, banks, the services sector, government agencies, science and all users
			passionate about technology. CeBIT offers an international platform for comparing notes on current
			industry trends, networking, and product presentations. 
			<br/><br/>
			Make sure you visit the <a href="http://wiki.eclipse.org/index.php/CeBIT2010" target="blank">
			Eclipse island</a> in CeBIT's Open Source Park, where Eclipse members Actuate,
			Bredex, EclipseSource and Sopera will be exhibiting. 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>Open Mobility</name>
		<start-date>March 9, 2010</start-date>
		<link>http://www.openmobilityusa.com/</link>
		<location>San Francisco, CA, USA</location>
		<description>
			<![CDATA[
			<a href="http://www.openmobilityusa.com/?a=157851">Register Here</a>
			<br/><br/>
			March 9-10, 2010<br/>
			Mission Bay Conference Center<br/><br/>			
			Open Mobility 2010, an evolution from OSiM (Open Source in Mobile) USA show, will equip you with all you
			need to succeed in an open mobile ecosystem. We're shaking things up a little and as well as hearing from
			headline speakers from established companies that have formed our industry and made $billions from doing
			so (we're talking T-Mobile, Pandora, Nokia, Sony Ericsson, Palm, Verizon, Gracenote, Warner Bros, MTV,
			AT&T et al). We will also be devoting huge chunks of the show to Silicon Valley startups, those that have
			exploded onto the scene in the last few months, those that have developed this year's must have apps and
			have earned their dollar through taking advantage of the rapidly changing ecosystem. Hear from the
			founders of Yelp, Digg, Qik, Zynga, Cooliris, Sokule, Mozes, Planet 9 Studios and more.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[IT-Brunch: Open Source - Trends, Benefits and NoGoes]]></name>
		<start-date><![CDATA[March 11, 2010]]></start-date>
		<link><![CDATA[http://www.it-brunch.net/index.php?id=212]]></link>
		<location><![CDATA[Stuttgart, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://www.it-brunch.net/index.php?id=86">Register Here</a>
			<br/><br/>
			March 11, 2010<br/>
			8:00am - 10:00am<br/>
			STEP - Engineering Park, Gropiusplatz 2<br/><br/>
			At the March IT-Brunch there will be several presenters speaking about open source software.
			Learn more about how tens of thousands of people are discovering a wealth of free
			knowledge, new forms of cooperation and community spirit.  You will also have an opportunity
			to expand your personal network and enjoy the brunch buffet.
			<br/><br/>
			Speakers will include Hans-Ulrich Schmid from Wirtschaftsfoerderung der Region Stuttgart, Thomas
			Uhl from Vorstand LiSoG, Ralph Mueller from the Eclipse Foundation and David Guembel from
			itomiq.
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Code Camp - Advanced RCP]]></name>
		<start-date><![CDATA[March 15, 2010]]></start-date>
		<link><![CDATA[http://entwickler-akademie.de/codecamps/eclipse-cc-rcp-advanced]]></link>
		<location><![CDATA[Munich, Germany]]></location>
		<description>
			<![CDATA[
			<a href="https://www.entwickler.com/ssl/formtool/index.php?id=81">Register Here</a>
			<br/><br/>
			March 15-16, 2010<br/>
			NH Hotel Muenchen Neue Messe, Eggenfeldener Strasse 100<br/><br/>
			Eclipse Code Camp - Advanced RCP is an exclusive training event presented by Eclipse Magazin
			and the Entwickler Akademie. Trainer Kai Toedter will teach advanced topics on Eclipse RCP. The
			training is practical, and with most topics, there will be demos integrated with exercises based
			on real hands-on experiences. For this training, you should already have experience with
			Eclipse RCP and the Eclipse plugin development. Other requirements are advanced
			programming skills in Java and experience with the Eclipse SDK as a Java development environment.
			]]>
		</description>
	</event>

	<event>
		<priority>1</priority>
		<name>EclipseCon 2010</name>
		<start-date>March 22, 2010</start-date>
		<link>http://www.eclipsecon.org</link>
		<location>Santa Clara, CA, USA</location>
		<description>
			<![CDATA[
			<a href="http://www.eclipsecon.org/2010/registration/">Register Here</a>
			<br/><br/>
			March 22-25, 2010<br/>
			Hyatt Regency Santa Clara, 5101 Great America Parkway<br/><br/>			
			EclipseCon is the premier technical and user conference focusing on the power of the Eclipse platform. From implementers to
			users, and everyone in between, if you are using, building, or considering Eclipse, EclipseCon is the conference you need
			to attend.		
			]]>
		</description>
	</event>

	<event>
		<priority>1</priority>
		<name>Eclipse Day India</name>
		<start-date>April 23, 2010</start-date>
		<link>http://www.eclipseday.in</link>
		<location>Bangalore, India</location>
		<description>
			<![CDATA[
			<a href="http://eclipsedayindia.eventbrite.com/">Register Here</a>
			<br/><br/>
			April 23, 2010<br/><br/>
			Eclipse Day India is a day-long event that explores Eclipse projects and topics for the local
			community. Eclipse experts will present innovations in the Eclipse projects and organizations
			will discuss how they benefit from using Eclipse for their needs. This event will be ideal
			for software architects, software development managers and senior developers that are
			interested in using Eclipse. There is no cost to attend the event but you must pre-register.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>JAX</name>
		<start-date>May 3, 2010</start-date>
		<link>http://it-republik.de/konferenzen/jax2010/</link>
		<location>Mainz, Germany</location>
		<description>
			<![CDATA[
			<a href="https://www.entwickler.com/ssl/formtool/index.php?id=75&lang=en">Register Here</a>
			<br/><br/>
			May 3-7, 2010<br/>
			Rheingoldhalle<br/><br/>			
			JAX is the conference to attend for technical know-how in Java, Enterprise
			Architecture and SOA. The main conference offers over 150 sessions and attendees
			can also attend the Business Technology Days, Special Days, expo and Power Workshops.
			<br/><br/>
			For Eclipse content, there are many sessions to watch in the
			Eclipse Equinox and OSGI track. As well, there is as a full Enterprise Eclipse Day
			including topics such as EclipseRT, JPA, Riena and Maven Tycho.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>Belgian Eclipse User Group with BeJUG Meeting</name>
		<start-date>May 25, 2010</start-date>
		<link>http://www.eventbrite.com/event/540546790</link>
		<location>Antwerp, Belgium</location>
		<description>
			<![CDATA[
			<a href="http://extranet.peopleware.be/peopleware/public/enrol/Training%20Manager.nsf/wSchedule?OpenForm&CNS=BEUG">Register Here</a>
			<br/><br/>
			May 25, 2010<br/>
			7:00pm<br/>
			Best Western Hotel Ter Elst, Ter Elststraat 310, Edegem<br/><br/>			
			The Belgian Eclipse User Group meeting will be organized together with BeJUG (the
			Devoxx/Javapolis people).  The theme of the meeting is Maven3, presented by founder Jason van Zyl,
			CTO of Sonatype. Maven 3.0 will be the Maven for the people. The Maven team has gone to the ends of
			the earth to ensure backward compatibility, improve usability, increase performance, allow safe
			embedding and pave the way to implement many highly demanded features. This informal session will
			cover Maven3, the Eclipse integration and more. This meeting will be organized as a standard BeJUG
			meeting, but is free for Eclipse User Group members.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>EclipseLink Summit</name>
		<start-date>May 25, 2010</start-date>
		<link>http://wiki.eclipse.org/EclipseLink/Development/Summit</link>
		<location>Ottawa, ON, Canada</location>
		<description>
			<![CDATA[
			<a href="http://wiki.eclipse.org/EclipseLink/Development/Summit#Interested_Participants">Register Here</a>
			<br/><br/>
			May 25-27, 2010<br/>
			Oracle Offices<br/><br/>			
			The EclipseLink Summit will offer interested committers an opportunity to dive deeper into the
			implementation. Long time and new committers, contributors, and consumers will get together and
			exchange information about the project with the goal of increasing the shared knowledge and
			capturing it in updated architecture and design documents. 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>OpenSourceDay in Tyrol</name>
		<start-date>May 28, 2010</start-date>
		<link>http://www.opensourceday.at/</link>
		<location>Innsbruck, Austria</location>
		<description>
			<![CDATA[
			<a href="http://www.opensourceday.at/">Register Here</a>
			<br/><br/>
			May 28, 2010<br/>
			1:30pm<br/>
			Wirtschaftskammer Tirol, MeinhardstraÃÂe 14<br/><br/>			
			Due to the transparency and innovation of open source software, it is gaining market share worldwide
			and is becoming increasingly important in Tyrol.  Therefore the first Tyrolean OpenSource Day will be
			held May 28 at 1:30pm.  The event is aimed at entrepreneurs, designers, geeks and IT managers.
			<br/><br/>
			Presentations at OpenSourceDay will include the LiMux project from the city of Munich, OpenStreetMap
			and Eclipse - an "innovation network" for vertical markets from the Eclipse Foundation.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>Eclipse Banking Day</name>
		<start-date>June 1, 2010</start-date>
		<link>http://wiki.eclipse.org/Eclipse_Banking_Day_2010</link>
		<location>Lyngby, Denmark</location>
		<description>
			<![CDATA[
			<a href="http://wiki.eclipse.org/Eclipse_Banking_Day_2010#Attendee_Registration">Register Here</a>
			<br/><br/>
			June 1, 2010<br/>
			IBM Denmark, Nymollevej 91<br/><br/>			
			Eclipse Banking Day is a day-long event for senior technical developers, architects and managers in
			the finance industry to learn how to better leverage Eclipse technology and the Eclipse community as
			part of their development strategy. The event will focus on three themes:
			<ol>
				<li>Eclipse as a platform for application development;</li>
				<li>Leveraging Eclipse modeling technology for data exchange; and</li>
				<li>Collaborating with the open source community.</li> 
			</ol>
			Attendees will have the chance to hear speakers from leading financial institutions and experts from
			the Eclipse community.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>Jazoon</name>
		<start-date>June 1, 2010</start-date>
		<link>http://jazoon.com/</link>
		<location>Zurich, Switzerland</location>
		<description>
			<![CDATA[
			<a href="http://jazoon.com/Register">Register Here</a>
			<br/><br/>
			June 1-3, 2010<br/>
			Arena Filmcity, Sihlcity, Kalanderplatz 8<br/><br/>			
			Jazoon is the International Conference on Java Technology. It will again attract famous Java experts
			and geeks to Zurich. In contrast to other events, Jazoon places emphasis on the active participation of
			the community and in turn invites everyone to contribute lectures on interesting research results,
			developments and practical experiences.
			<br/><br/>
			Watch for several Eclipse talks: Peter Friese on <i>Building DSLs with Eclipse</i>, Matthew McCullough <i>Maven
			3.0 - M2Eclipse, Ployglot and Shell for Better Builds</i> and Benjamin Muskalla on <i>Single Sourcing RCP and
			RAP - Desktop and web clients from a single code base</i>.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>EMF, Xtext and Xpand for the Interested Amateur</name>
		<start-date>June 7, 2010</start-date>
		<link>http://www.eclipse.dk/arrangements/emf-xtext-og-xpand-for-den-interesserede-dilletant-udi-modelleringens-og-syntaksens-spaendende-verden</link>
		<location>Copenhagen, Denmark</location>
		<description>
			<![CDATA[
			<a href="http://www.eclipse.dk/arrangements/tilmelding">Register Here</a>
			<br/><br/>
			June 7, 2010<br/>
			4:00pm - 6:00pm
			ReportSoft, Kalkbraenderilobskaj 6<br/><br/>			
			EMF is used to create and maintain a common data model, which may then be applied automatically in
			XML, Java code and databases. The model may provide a basis for Domain Specific Languages (DSL) via
			Xtext and form the basis for transformations of Xpand.  This free presentation will consist of a
			brief review of the context of modules, a thorough demonstration and a little comparison to
			include JavaCC.  The review is intended for developers and architects who want to get started with
			EMF, Xtext and Xpand, but it is not a full course. 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>Code Generation</name>
		<start-date>June 16, 2010</start-date>
		<link>http://www.codegeneration.net/cg2010/</link>
		<location>Cambridge, United Kingdom</location>
		<description>
			<![CDATA[
			<a href="http://www.codegeneration.net/cg2010/">Register Here</a>
			<br/><br/>
			June 16-18, 2010<br/>
			Murray Edwards College<br/><br/>			
			CG2010 is for people who want to successfully apply or just learn more about the following
			topics: openArchitectureWare, Eclipse Modeling Tools, Domain-Specific Languages,
			Domain-Specific Modeling, Model-Driven Architecture, Executable UML, Model-Driven Software
			Development, Software Factories and Software Product Lines, Generative Programming and other
			similar approaches.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>ECOOP</name>
		<start-date>June 21, 2010</start-date>
		<link>http://ecoop2010.uni-mb.si/</link>
		<location>Maribor, Slovenia</location>
		<description>
			<![CDATA[
			<a href="http://ecoop2010.uni-mb.si/registration/Login.aspx?ReturnUrl=%2fregistration%2fuser%2fConferenceRegistration.aspx">Register Here</a>
			<br/><br/>
			June 21-25, 2010<br/>
			University of Maribor, building G2, Smetanova ulica 17<br/><br/>			
			ECOOP 2010, the 24th European Conference on Object-Oriented Programming is being organized by the
			University of Maribor, Faculty of Electrical Engineering and Computer Science. The conference continues
			a well-established tradition of scientific conferences in the field of object-oriented programming and
			related areas.
			<br/><br/>
			Bruce Trask and Angel Roman of MDE Systems will present a tutorial at ECOOP on <i>Effective Model Driven
			Engineering Patterns, Principles and Practices in Action</i>, covering MDE core concepts and an Eclipse
			MDE tutorial.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>JBoss World</name>
		<start-date>June 22, 2010</start-date>
		<link>http://www.redhat.com/promo/summit/2010/</link>
		<location>Boston, MA, USA</location>
		<description>
			<![CDATA[
			<a href="http://www.redhat.com/promo/summit/2010/rates/">Register Here</a>
			<br/><br/>
			June 22-25, 2010<br/>
			<a href="http://www.redhat.com/promo/summit/2010/rates/" target="blank">Seaport Hotel & World Trade Center</a>, One Seaport Lane<br/><br/>			
			The Red Hat Summit and JBoss World are the premier open source events to learn about the latest and
			greatest in open source cloud computing, platform, virtualization, middleware and management technologies.
			The Red Hat Summit and JBoss World are for anyone looking to exponentially increase their overall knowledge of
			open source, without making a heavy monetary investment. Every single type of person attends - from community
			enthusiasts to sys admins and CEOs.
			<br/><br/>
			Andrew Overholt will give a session on Friday on <i>Effective Eclipse: Coding, Debugging, Teamwork</i>.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>Symposium on Eclipse OS Software and OMG Open Specifications</name>
		<start-date>June 23, 2010</start-date>
		<link>http://www.omg.org/news/meetings/tc/mn/special-events/Eclipse.htm</link>
		<location>Minneapolis, Minnesota, USA</location>
		<description>
			<![CDATA[
			<a href="http://www.omg.org/news/meetings/tc/mn/special-events/Eclipse.htm">Register Here</a>
			<br/><br/>
			June 23, 2010<br/><br/>			
			In 2008 Eclipse and OMG jointly ran two one-day symposia to promote and build on the
			partnership between Eclipse's open source software and OMG's open specifications. Following
			the success of these events, OMG and Eclipse will hold a further one-day symposium during the
			OMG Technical Meeting in Minneapolis, Minnesota on 23rd June 2010. The symposium will be
			organised as a series of discussion sessions on OMG standards and corresponding Eclipse
			projects, to discuss the alignment between current specifications and implemented software,
			and identify areas where the cooperation could be further improved in future.
			This symposium is a further opportunity to participate in shaping the joint future of the
			Eclipse Open Source community and the OMG Open Specifications community. Please join us for
			stimulating technical planning and discussion in this exciting area.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>SPICE Meets Eclipse BoF</name>
		<start-date>June 23, 2010</start-date>
		<link>http://wiki.eclipse.org/EclipseEmbeddedDayStgt2010#BoF_-_Birds_of_a_Feather_-_SPICE_meets_ECLIPSE</link>
		<location>Stuttgart, Germany</location>
		<description>
			<![CDATA[
			<a href="http://wiki.eclipse.org/EclipseEmbeddedDayStgt2010#BoF_-_Birds_of_a_Feather_-_SPICE_meets_ECLIPSE">Register Here</a>
			<br/><br/>
			June 23, 2010<br/>
			5:00 pm<br/>
			Koenig-Karl Halle<br/><br/>			
			There is a unique opportunity for all Eclipse Embedded Day 2010 participants to take part in a
			Birds of a Feather discussion: "SPICE Days meets with Embedded Eclipse". The subject of the
			discussion will be highlights and topics of common interest between the SPICE Days and Eclipse
			Embedded Day participants.
			<br/><br/>
			This event will take place in Koenig-Karl Halle, and may continue for refreshments across the road. 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>Eclipse Embedded Day Stuttgart</name>
		<start-date>June 24, 2010</start-date>
		<link>http://wiki.eclipse.org/EclipseEmbeddedDayStgt2010</link>
		<location>Stuttgart, Germany</location>
		<description>
			<![CDATA[
			<a href="http://embeddedday2010.eventbrite.com/">Register Here</a>
			<br/><br/>
			June 24, 2010<br/><br/>			
			MicroDoc presents the second Eclipse Embedded Day called EDay 2010 in Stuttgart, sponsored by the
			Eclipse Foundation. Senior technical developers, architects and technical managers will learn how to
			better leverage Eclipse technology and the Eclipse community as part of their development strategy.
			<br/><br/>
			The agenda will be packed with high value talks about Eclipse technologies for the embedded space
			(mobile, automotive, telematics, consumer electonics, medical, etc.). Parallel sessions on Eclipse
			embedded projects and interesting case studies will complement the strategic presentations.
			<br/><br/>
			There's a unique opportunity for the attendees from the automotive sector to visit EDay 2010 and
			Open Forum 2010: International SPICE Days and Automotive Safety & Security the days before at the
			same location. 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>EGL Open Source Launch Event</name>
		<start-date>June 29, 2010</start-date>
		<link>http://www-949.ibm.com/software/rational/cafe/community/egl/open</link>
		<location>Conference Call</location>
		<description>
			<![CDATA[
			<a href="https://www.mymeetings.com/emeet/rsvp/index.jsp?customHeader=mymeetings&Conference_ID=5669161&passcode=5310670">Register Here</a>
			<br/><br/>
			June 29, 2010<br/>
			10:00 am ET<br/><br/>			
			EGL is a higher-level programming language designed for simplifying development of modern
			business applications and services. EGL code compiles into COBOL, Java, and JavaScript, which
			means it can be deployed to a wide variety of environments. EGL frees developers to focus on the
			business problem rather than on the details of the target runtime platforms and associated
			middleware. EGL is ideal for business-oriented development teams that value ease of learning
			and need to quickly deliver modern applications and services. 
			<br/><br/>
			Join thelaunch call to learn more about EGL and the proposed open source project on Eclipse.
			For additional background, please visit the <a href="http://www.ibm.com/software/rational/cafe/community/egl/open" target="blank">EGL community site</a>.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>IBM Rational Jazz Roadshow</name>
		<start-date>July 6, 2010</start-date>
		<link>http://www-05.ibm.com/de/events/jazz/</link>
		<location>Ehningen, Germany</location>
		<description>
			<![CDATA[
			<a href="https://www.event4all.de/jazz-roadshow">Register Here</a>
			<br/><br/>
			July 6, 2010<br/>
			9:30am - 4:00pm<br/>
			IBM Forum Ehningen, IBM-Allee 1 (Am Keltenwald 1)<br/><br/> 
			Learn how to optimise team work with the help of Jazz solutions from IBM Rational at the IBM Rational
			Jazz Roadshow 2010. Take part in demonstrations and scenarios that provide an informative overview of
			the Jazz platform and how it can help with software development. In addition to this, use the
			opportunity to discuss the challenges of smart software development with our experts at IBM.  Sessions
			will be held in German. 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>IBM Rational Jazz Roadshow</name>
		<start-date>July 7, 2010</start-date>
		<link>http://www-05.ibm.com/de/events/jazz/</link>
		<location>Munich, Germany</location>
		<description>
			<![CDATA[
			<a href="https://www.event4all.de/jazz-roadshow">Register Here</a>
			<br/><br/>
			July 7, 2010<br/>
			9:30am - 4:00pm<br/>
			IBM Forum Munich, Hollerithstrasse 1 <br/><br/> 
			Learn how to optimise team work with the help of Jazz solutions from IBM Rational at the IBM Rational
			Jazz Roadshow 2010. Take part in demonstrations and scenarios that provide an informative overview of
			the Jazz platform and how it can help with software development. In addition to this, use the
			opportunity to discuss the challenges of smart software development with our experts at IBM.  Sessions
			will be held in German. 
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name>OSCON</name>
		<start-date>July 19, 2010</start-date>
		<link>http://www.oscon.com/oscon2010</link>
		<location>Portland, OR, USA</location>
		<description>
			<![CDATA[
			<a href="https://en.oreilly.com/oscon2010/public/register">Register Here</a>
			<br/><br/>
			July 19-23, 2010<br/><br/>			
			There is big change in technology and society, and open source is making it happen. Cloud computing is
			transforming our toolkit, from NoSQL to systems management. Mobile services are growing exponentially,
			set alight by Android and iPhone. New languages and APIs are flourishing. Developers must adapt to a
			rapidly evolving platform, which open source is the key to managing and steering. Rapid change presents
			opportunity as well as challenges. Open source isn't just about being cost-effective, it's leading in
			innovation. You can change the game in your business, your community or even the world. OSCON brings
			together people like you from across the open source universe to learn, inspire each other and
			collaborate.
			<br/><br/>
			Mike Milinkovich, Executive Director of the Eclipse Foundation, will participate in a panel on <i>Financial
			Incentives in Open Source</i>.  Donald Smith from the Eclipse Foundation will present a talk on <i>Measuring
			the Health of Open Source Ecosystems</i>.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>Open Source Technology Showcase</name>
		<start-date>August 14, 2010</start-date>
		<link>http://www.fosslc.org/drupal/summercamp2010</link>
		<location>Ottawa, ON, Canada</location>
		<description>
			<![CDATA[
			<a href="http://www.fosslc.org/drupal/summercamp2010">Register Here</a>
			<br/><br/>
			August 14, 2010<br/>
			9:30am - 5:30pm<br/>
			University of Ottawa Campus, Desmarais Building, 55, Laurier Ave. E<br/><br/>			
			FOSSLC in partnership with IEEE is hosting this annual open source technology showcase
			featuring technical, legal and business aspects of open source use in private industry,
			community and government.  Wayne Beaton from the Eclipse Foundation will present on <i>Helios:
			The Eclipse Simultaneous Release</i>.
			]]>
		</description>
	</event>
	
	<event>
		<priority>1</priority>
		<name>Eclipse Day at the Googleplex</name>
		<start-date>August 26, 2010</start-date>
		<link>http://wiki.eclipse.org/Eclipse_Day_At_Googleplex_2010</link>
		<location>Mountain View, CA, USA</location>
		<description>
			<![CDATA[
			<a href="http://wiki.eclipse.org/Eclipse_Day_At_Googleplex_2010#Attendee_Registration">Register Here</a>
			<br/><br/>
			August 26, 2010<br/>
			9:00am - 5:00pm<br/>
			Googleplex, 1600 Amphitheatre Parkway<br/><br/>			
			Eclipse Day at the Googleplex is a full day event for developers to learn about different Eclipse
			projects and related technologies. You are invited to attend and listen as experts from the
			Eclipse projects and Google share their experiences of using Eclipse. It's also a great
			opportunity for you to meet and network with other Eclipse enthusiasts. There is no cost to
			attend, but pre-registration is required. 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>Belgian Eclipse Community Meeting</name>
		<start-date>August 31, 2010</start-date>
		<link>http://wiki.eclipse.org/Regional_Communities/Belgium#Upcoming_Events</link>
		<location>Antwerp, Belgium</location>
		<description>
			<![CDATA[
			<a href="http://wiki.eclipse.org/Regional_Communities/Belgium#Upcoming_Events">Register Here</a>
			<br/><br/>
			August 31, 2010<br/>
			7:00pm<br/>
			Inventive Designers, Hoboken<br/><br/>			
			The next Belgian Eclipse Community meeting will include 2 guest speakers.  Sven Efftinge, itemis, will
			present the Eclipse Xtext project and Nick Van den Bleeken, Inventive Designers, will talk about EGit:
			the Git integration in the Eclipse platform.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>Eclipse DemoCamp in Tokyo</name>
		<start-date>September 6, 2010</start-date>
		<link>http://wiki.eclipse.org/Eclipse_DemoCamps_Helios_2010/Tokyo</link>
		<location>Tokyo, Japan</location>
		<description>
			<![CDATA[
			<a href="http://wiki.eclipse.org/Eclipse_DemoCamps_Helios_2010/Tokyo#Registration_.2F_.E5.8F.82.E5.8A.A0.E7.94.B3.E8.BE.BC.E3.81.BF">Register Here</a>
			<br/><br/>
			September 6, 2010<br/>
			7:00pm - 9:00pm<br/>
			Hitachi's 2nd Oomori Building<br/><br/>			
			Join the Eclipse Japan Working Group for an evening of technical talks and demos on Eclipse.  Topics
			to be presented include the Helios release, Eclipse 4.0, embedded systems, Xtext and plugin development.
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name>Eclipse Testing Day</name>
		<start-date>September 8, 2010</start-date>
		<link>http://wiki.eclipse.org/EclipseTestingDay2010</link>
		<location>Darmstadt, Germany</location>
		<description>
			<![CDATA[
			<a href="http://wiki.eclipse.org/EclipseTestingDay2010#Registration">Register Here</a>
			<br/><br/>
			September 8, 2010<br/>
			8:30am - 6:00pm<br/>
			<a href="http://www.commundo-tagungshotels.de/darmstadt/darmstadt.htm">Commundo Tagungshotel Darmstadt</a>, Hilpertstrasse 27<br/><br/>			
			The Eclipse Testing Day is a day-long event. This is your opportunity to learn best practices and
			technial information on Eclipse testing.
			<br/><br/>
			This event will be ideal for software architects, software development managers and senior developers.
			Pre-registration is required. 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>Developing Domain-Specific Languages with Xtext</name>
		<start-date>September 9, 2010</start-date>
		<link>http://jwsdsl09sep.eventbrite.com/</link>
		<location>Stockholm, Sweden</location>
		<description>
			<![CDATA[
			<a href="http://jwsdsl09sep.eventbrite.com/">Register Here</a>
			<br/><br/>
			September 9, 2010<br/>
			4:00pm - 7:00pm<br/>
			Drottninggatan 108, Jayway i Stockholm AB, 3tr<br/><br/>			
			Jayway is hosting a free event with presentations on Xtext.  Sven Efftige will talk about the Eclipse Xtext
			project and Patrik Nordwall and Andreas Kaellberg will present Sculptor, an open-source framework/code
			generator based on textual domain-specific languages implemented in Xtext.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>Eclipse Karlsruhe Stammtisch</name>
		<start-date>September 15, 2010</start-date>
		<link>http://eclipsesource.com/en/about/events/eclipse_karlsruhe_stammtisch/</link>
		<location>Karlsruhe, Germany</location>
		<description>
			<![CDATA[
			<a href="http://eclipsesource.com/en/about/events/eclipse_karlsruhe_stammtisch/">Register Here</a>
			<br/><br/>
			September 9, 2010<br/>
			5:30pm - 9:30pm<br/>
			IHK Haus der Wirtschaft, Lammstrasse 13, Rebland Room, 1. OG<br/><br/>			
			Engage the Eclipse community in Karlsruhe at the Eclipse Stammtisch! To get the ideas rolling, we'll
			start off with a program of what promises to be interesting talks from a variety of Eclipse projects.
			Then we'll move over to the Mille Stelle Restaurant for a round. Program topics include Eclipse in Europe,
			EGit, p2, RAP and Scout. Seating is limited so if you'd like to attend, please sign up!
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[JavaOne]]></name>
		<start-date><![CDATA[September 19, 2010]]></start-date>
		<link><![CDATA[http://www.oracle.com/us/javaonedevelop/index.html]]></link>
		<location><![CDATA[San Francisco, CA, USA]]></location>
		<description>
			<![CDATA[
			<a href="http://www.oracle.com/us/javaonedevelop/063292.html">Register Here</a>
			<br/><br/>
			September 19-23, 2009<br/><br/>		
			This year's JavaOne, co-located with Oracle Develop, will offer unparalleled education, practical
			hands-on sessions, engaging activities and exceptional entertainment exclusively geared toward the
			developer community. Network, share information and learn from leading experts in the Java, PL/SQL,
			rich internet application development, SOA communities and more.
			<br/><br/>
			Some of the Eclipse sessions: <i>Building Software with Rich Client Platforms</i> by Rikard Thulin,
			<i>Java Persistence API (JPA) 2.0 with EclipseLink</i> by Shaun Smith and Doug Clarke,
			<i>Going Beyond Memory Leaks: Debugging Java from Dumps Using Memory Analyzer</i> by Chris Bailey and Trent Gray Donald
			and <i>Saving Time with AppXRay and Eclipse</i> by Andrew McCulloch and Pieter Humphrey.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>CDT Summit</name>
		<start-date>September 21, 2010</start-date>
		<link>http://wiki.eclipse.org/CDT/summitfall2010</link>
		<location>Montreal, QC, Canada</location>
		<description>
			<![CDATA[
			<a href="http://wiki.eclipse.org/CDT/summitfall2010#Attendees">Register Here</a>
			<br/><br/>
			September 21-23, 2010<br/>
			Ericsson Offices, 8400 Decarie Blvd.<br/><br/> 
			This Eclipse CDT Summit is intended for contributors to the C/C++ Development Tooling
			project to review their plans and discuss issues with the rest of the CDT community. It is
			intended for contributors, that is people working or at least planning on working on the CDT.
			All aspects of the CDT will be discussed with a focus on features and improvements for the
			next simultaneous release in June 2011. 
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name>IBM Rational Jazz Roadshow</name>
		<start-date>September 21, 2010</start-date>
		<link>http://www-05.ibm.com/de/events/jazz/</link>
		<location>Frankfurt, Germany</location>
		<description>
			<![CDATA[
			<a href="https://www.event4all.de/jazz-roadshow">Register Here</a>
			<br/><br/>
			September 21, 2010<br/>
			9:30am - 4:00pm<br/>
			IBM Forum Frankfurt am Main, Wilhelm-Fay-Strasse 32<br/><br/> 
			Learn how to optimise team work with the help of Jazz solutions from IBM Rational at the IBM Rational
			Jazz Roadshow 2010. Take part in demonstrations and scenarios that provide an informative overview of
			the Jazz platform and how it can help with software development. In addition to this, use the
			opportunity to discuss the challenges of smart software development with our experts at IBM.  Sessions
			will be held in German. 
			]]>
		</description>
	</event>	

	<event>
		<priority>2</priority>
		<name>IBM Rational Jazz Roadshow</name>
		<start-date>September 22, 2010</start-date>
		<link>http://www-05.ibm.com/de/events/jazz/</link>
		<location>Dusseldorf, Germany</location>
		<description>
			<![CDATA[
			<a href="https://www.event4all.de/jazz-roadshow">Register Here</a>
			<br/><br/>
			September 22, 2010<br/>
			9:30am - 4:00pm<br/>
			IBM Forum Dusseldorf, Karl-Arnold-Platz 1a <br/><br/> 
			Learn how to optimise team work with the help of Jazz solutions from IBM Rational at the IBM Rational
			Jazz Roadshow 2010. Take part in demonstrations and scenarios that provide an informative overview of
			the Jazz platform and how it can help with software development. In addition to this, use the
			opportunity to discuss the challenges of smart software development with our experts at IBM.  Sessions
			will be held in German. 
			]]>
		</description>
	</event>
	
		<event>
		<priority>2</priority>
		<name>IBM Rational Jazz Roadshow</name>
		<start-date>September 23, 2010</start-date>
		<link>http://www-05.ibm.com/de/events/jazz/</link>
		<location>Hamburg, Germany</location>
		<description>
			<![CDATA[
			<a href="https://www.event4all.de/jazz-roadshow">Register Here</a>
			<br/><br/>
			September 23, 2010<br/>
			9:30am - 4:00pm<br/>
			IBM Forum Hamburg, Beim Strohhause 17 <br/><br/> 
			Learn how to optimise team work with the help of Jazz solutions from IBM Rational at the IBM Rational
			Jazz Roadshow 2010. Take part in demonstrations and scenarios that provide an informative overview of
			the Jazz platform and how it can help with software development. In addition to this, use the
			opportunity to discuss the challenges of smart software development with our experts at IBM.  Sessions
			will be held in German. 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>Tutorial Day: Eclipse e4</name>
		<start-date>September 30, 2010</start-date>
		<link>http://www.eclipse.dk/arrangements/tutorial-day-eclipse-e4</link>
		<location>Copenhagen, Denmark</location>
		<description>
			<![CDATA[
			<a href="http://www.eclipse.dk/arrangements/tutorial-day-eclipse-e4">Register Here</a>
			<br/><br/>
			September 30, 2010<br/>
			5:00am - 9:00pm<br/>
			IT-Universitetet, Rued Langgaards Vej<br/><br/> 
			The Eclipse e4 Tutorial Day will immerse you in tutorials, including those from Lars Vogel, to look
			deeper into the code and Eclipse 4.0.  The event was previously held at a large insurance company,
			and we are now repeating it for Eclipse Denmark members.
			<br/><br/>
			Hear the experiences of others and ask for advice. Also, you will be able to network with other
			peers who also have valuable knowledge in a relaxed and cozy environment. Do not miss this rewarding
			and social event. Remmember to bring a laptop with e4 installed.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>Eclipse-IT</name>
		<start-date>September 30, 2010</start-date>
		<link>http://2010.eclipse-it.org/</link>
		<location>Savona, Italy</location>
		<description>
			<![CDATA[
			<a href="http://2010.eclipse-it.org/register/">Register Here</a>
			<br/><br/>
			September 30-October 1, 2010<br/>
			Savona University Campus<br/><br/>			
			The Eclipse-IT 2010 workshop is the fifth yearly meeting of the Eclipse Italian Community,
			which includes both universities and industries, with the aim of joining researchers,
			practitioners, students and professionals around the common interest in experimenting,
			extending and supporting the Eclipse platform.
			<br/><br/>
			Due to a special interest and running project, this year, the Conference hosts a special
			session on the Jazz cooperative development environment, based on the Enforcing Team
			Cooperation (ETC) Project. ETC involves many universities with the aim to bring together
			teams of students in order to develop software in a cooperative way.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>Open World Forum</name>
		<start-date>September 30, 2010</start-date>
		<link>http://www.openworldforum.org/</link>
		<location>Paris, France</location>
		<description>
			<![CDATA[
			<a href="http://www.openworldforum.org/Register">Register Here</a>
			<br/><br/>
			September 30-October 1, 2010<br/><br/>			
			Founded by a heavyweight group of communities and IT players, the Open World Forum is the
			premier global summit meeting in this field, bringing together decisions-makers from across
			the world to discuss the technological, financial and social impact of the Free/Open Source
			mouvement, and to cross-fertilize ideas and initiatives in this area. The numerous sessions,
			activities and events at the Open World Forum aim to bring you Free/Open Source's best.
			Beyond the conference itself, the Open World Forum establishes a new environment where
			people can think ahead, identify key trends, challenges and opportunities for the future.
			Bringing together international experts working on future planning, scenarios and
			recommendations, it delivers and debates each year the 2020 Free Libre and Open Source
			Software Roadmap.
			<br/><br/>
			Mike Milinkovich, Executive Director of the Eclipse Foundation, along with many other leaders
			from the open source community, will be a keynote speaker at Open World Forum.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>Eclipse Day 2010 in Rome</name>
		<start-date>October 5, 2010</start-date>
		<link>http://www.spagoworld.org/xwiki/bin/view/openevents/</link>
		<location>Rome, Italy</location>
		<description>
			<![CDATA[
			<a href="http://www.spagoworld.org/xwiki/bin/view/openevents/Registration">Register Here</a>
			<br/><br/>
			October 5, 2010<br/><br/>			
			The Eclipse Day 2010 in Rome is the first event taking place in Italy focusing on the enterprise
			adoption of Eclipse-based solutions. Co-organized by Engineering Group and the Eclipse Foundation,
			and supported by vendors and IT leaders, the event outlines some hot topics concerning the
			service-oriented architectures, integration and interoperability domains, offering some specific
			use cases surrounding the Eclipse ecosystem.
			<br/><br/>
			Recognized testimonials will share use cases of open source software and will address the emerging
			issues on its adoption supporting the complexity of the new IT architectures.
			<br/><br/>
			The target audience of the event is composed of IT managers, decision-makers, CIOs, CTOs
			software architects, development managers and senior developers of private companies, public
			institutions and systems integrators/vendors that are interested in these topics or in adopting
			Eclipse for their software applications. Presentations are in English and Italian. In the morning,
			a simultaneous translation is provided.
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name>Eclipse Integrated Development Day in Berlin</name>
		<start-date>October 12, 2010</start-date>
		<link>http://wiki.eclipse.org/Eclipse_Integrated_Development_Day_Berlin</link>
		<location>Berlin, Germany</location>
		<description>
			<![CDATA[
			<a href="http://wiki.eclipse.org/Eclipse_Integrated_Development_Day_Berlin#Attendee_Registration">Register Here</a>
			<br/><br/>
			October 12, 2010<br/><br/>			
			Eclipse Integrated Development Day in Berlin is a day-long event for technical developers, architects
			and managers interested in tool and process integration as well as automation in development
			processes. Attendees will have the chance to hear speakers from leading organization and experts from
			the Eclipse community. There is no cost to attend the event but pre-registration is required. 
			]]>
		</description>
	</event>	
	<event>
		<priority>2</priority>
		<name>Annie Ying on Eclipse, from the Linux Perspective</name>
		<start-date>October 20, 2010</start-date>
		<link>http://nylug.org/blog/2010/10/04/annie-ying-on-eclipse-from-the-linux-perspective/</link>
		<location>New York, NY, USA</location>
		<description>
			<![CDATA[
			<a href="http://rsvp.nylug.org/">Register Here</a>
			<br/><br/>
			October 20, 2010<br/>
			6:30pm - 8:00pm
			IBM, 590 Madison Ave., 12th Floor (Madison & 57th)<br/><br/>
			Eclipse, a software development environment and an extensible plug-in
			platform, is closer to the Linux community than many Linux enthusiasts
			may think. Eclipse has a vibrant community of contributors of
			plug-ins and patches. Eclipse is governed by the Eclipse Foundation,
			a not-for-profit corporation (even though it was born in a
			corporation, IBM.) Each Eclipse installation comes with all the
			source code, supporting Linux enthusiasts' practice of
			hacking-code-to-make-people's-lives-easier. Started a couple of years
			ago, the Eclipse Linux Tools project provides better support for Linux
			developers, including integration with native development tools such
			as GNU Autotools and best practices for packaging. This project has
			also helped several Linux distributions with packaging of Eclipse
			itself. Eclipse's license is relatively friendly, further promoting
			the submission of contributions.
			<br/><br/>
			In this talk, Annie will explore these synergies of Eclipse and Linux. She
			will then dive into Eclipse hacking, both for customizing Eclipse for
			yourself or your organization, and for contributing patches and
			plug-ins back to the community. 
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name>Rational Innovate2010 Conference</name>
		<start-date>October 27, 2010</start-date>
		<link>http://www.ibm.com/de/events/innovate</link>
		<location>Leipzig, Germany</location>
		<description>
			<![CDATA[
			<a href="http://www-05.ibm.com/de/events/innovate/anmeldung.html">Register Here</a>
			<br/><br/>
			October 27-28, 2010<br/>
			Westin Hotel Leipzig, Gerberstrasse 15<br/><br/>			
			Innovate2010 is the conference that covers all aspects of software and systems development in
			an economical and technical context. Learn first hand how to integrate development into daily
			business, how to ensure communication and cooperation across heterogeneous and geographically
			dispersed teams and how using development as a business process can lead to optimization
			opportunities within your business. 
			]]>
		</description>
	</event>

	<event>
		<priority>1</priority>
		<name><![CDATA[Eclipse Enterprise Modeling Day]]></name>
		<start-date><![CDATA[October 28, 2010]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/Eclipse_MDD_Day]]></link>
		<location><![CDATA[Zurich, Switzerlnd]]></location>
		<description>
			<![CDATA[
			<a href="http://wiki.eclipse.org/Eclipse_MDD_Day#Attendee_Registration">Register Here</a>
			<br/><br/>
			October 28, 2010<br/><br/>
			Eclipse Enterprise Modeling Day is for IT architects and IT strategists who are exploring a model driven
			development approach for their enterprise application development.
			<br/><br/>
			Many enterprises are already using modeling to streamline their application development. The sessions
			will explore how enterprises, such as UBS and Bosch have used Eclipse technology to implement a
			modeling strategy. Eclipse modeling experts will also provide a review of the core Eclipse modeling
			technology that enables key enterprise modeling features, including data modeling, graphical modeling,
			model repositories and textual modeling. Finally, a presentation on the Eclipse Modeling Platform will
			show how an integrated Eclipse-based platform can provide the flexibility and extensibility required for
			large-scale enterprise model driven development.
			]]>
		</description>
	</event>
	
	<event>
		<priority>1</priority>
		<name><![CDATA[Eclipse DemoCamps and Campus DemoCamps]]></name>
		<start-date><![CDATA[November 1, 2010]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/Eclipse_DemoCamps_November_2010]]></link>
		<location><![CDATA[Worldwide]]></location>
		<description>
			<![CDATA[
			<a href="http://wiki.eclipse.org/Eclipse_DemoCamps_November_2010">Register Here</a>
			<br/><br/>
			November 1-30, 2010<br/><br/>
			The Eclipse Foundation is inviting individuals to organize and attend Eclipse DemoCamps around the world.
			The Eclipse DemoCamps are an opportunity to showcase all of the cool technology being built by the
			Eclipse community. They are also an opportunity for you to meet Eclipse enthusiasts in your city.
			<br/><br/>
			A DemoCamp is an informal event for a group of Eclipse enthusiasts to meet up and demo what they are
			doing with Eclipse. The demos can be of research projects, Eclipse open source projects, applications
			based on Eclipse, commercial products using Eclipse or whatever you think might be of interest to the
			attendees. The only stipulation is that it must be Eclipse related.
			<br/><br/>
			For this series, we are adding on a special set of Eclipse Campus DemoCamps for university and college
			students to meet and learn more about Eclipse.  
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name>Free Open Source Software Conference (fOSSa)</name>
		<start-date>November 8, 2010</start-date>
		<link>http://fossa2010.inrialpes.fr</link>
		<location>Grenoble, France</location>
		<description>
			<![CDATA[
			<a href="http://fossa2010.inrialpes.fr">Register Here</a>
			<br/><br/>
			November 8-10, 2010<br/>
			EMSI School<br/><br/>			
			The aim of fOSSa (Free/Open Source Software for Academics) is to review open source fundamentals,
			present innovating open source projects and share open source communities' experiences.
			Hopefully, we expect to show the benefits of the participation in a collaborative network aimed
			at increasing the value of academic results, gathering them in a common environment and
			releasing them in open source.
			<br/><br/>
			The Eclipse Foundation as well
			as several Eclipse members are helping to organize the conference.  We hope you can join us!
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>Tutorial Day: Eclipse RCP Under the Hood</name>
		<start-date>November 10, 2010</start-date>
		<link>http://www.eclipse.dk/arrangements/eclipse-rcp-under-the-hood</link>
		<location>Copenhagen, Denmark</location>
		<description>
			<![CDATA[
			<a href="http://www.eclipse.dk/arrangements/eclipse-rcp-under-the-hood">Register Here</a>
			<br/><br/>
			November 10, 2010<br/>
			5:00am - 9:00pm<br/>
			IT-Universitetet, Rued Langgaards Vej<br/><br/> 
			This event is a combination of a tutorial day and a live demonstration of a "full featured" Eclipse
			RCP application where developments are commented on-the-fly. Bring your laptop and try for
			yourself.  See how easy it is to start up an Eclipse RCP application. It is very important that you
			already have Eclipse 3.6 installed on your machine.
			]]>
		</description>
	</event>

	<event>
		<priority>1</priority>
		<name><![CDATA[Eclipse Summit Europe]]></name>
		<start-date><![CDATA[November 2, 2010]]></start-date>
		<link><![CDATA[http://www.eclipsecon.org/summiteurope2010/]]></link>
		<location><![CDATA[Ludwigsburg, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://www.eclipsecon.org/summiteurope2010/">Register Here</a>
			<br/><br/>
			November 2-4, 2010<br/>
			<a href="http://www.ludwigsburg.de/servlet/PB/menu/1187968_l1/index.html" target="blank">Forum am Schlosspark</a><br/><br/>
			The Eclipse Foundation is hosting the 5th annual Eclipse Summit Europe on November 2-4, 2010. To be held in the
			Stuttgart region of Germany, the Eclipse Summit is the Foundation's premier event designed to create opportunities for
			the European Eclipse community to explore, share and collaborate on the latest ideas and information about Eclipse and
			its members. 
			<br/><br/>
			The conference will consist of symposia, technical and business track sessions, selected
			keynotes, demos and networking gatherings. Sponsors supporting the Eclipse Summit will showcase their latest products and
			services, as well as the exciting contributions their organizations are making to the Eclipse ecosystem. The conference
			is a stimulating and dynamic event for Eclipse committers, contributors, adopters, add-in providers and service providers
			to learn, share expertise and discover new opportunities and solutions in the Eclipse ecosystem. 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Day Paris]]></name>
		<start-date><![CDATA[November 5, 2010]]></start-date>
		<link><![CDATA[http://www.eclipsedayparis.com/]]></link>
		<location><![CDATA[Paris, France]]></location>
		<description>
			<![CDATA[
			<a href="http://www.eclipsedayparis.com/?page=Registration&lang=en">Register Here</a>
			<br/><br/>
			November 5, 2010<br/>
			Pavillon Royal, Carrefour du bout du Lac, Bois de Boulogne, Ave. de Suresnes<br/><br/>
			Eclipse Day Paris is a day-long event exploring Eclipse projects and topics for the French
			community.  Eclipse experts will present innovations in the Eclipse projects and organizations
			will discuss how they benefit from using Eclipse for their needs. This event is ideal for IT
			decision makers, software architects and process and methods engineers that are interested in
			using Eclipse.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Embedded Day Spain]]></name>
		<start-date><![CDATA[November 9, 2010]]></start-date>
		<link><![CDATA[http://www.esi.es/eclipseembeddedday]]></link>
		<location><![CDATA[Zamudio, Spain]]></location>
		<description>
			<![CDATA[
			<a href="http://www.esi.es/eclipseembeddedday">Register Here</a>
			<br/><br/>
			November 9, 2010<br/>
			ESI-TECNALIA, Sala Auditorio, Parque Technologico, Edificio 204<br/><br/>
			Eclipse is becoming a major open source reference technology for building extensible development
			platforms, runtimes and application frameworks in the embedded system domain.
			<br/><br/>
			Eclipse Embedded Day Spain 2010 aims to bring together experts, practitioners and researchers,
			mainly from the Spanish embedded systems community, in a mix of high-quality talks, sessions and
			demonstrations. 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Devoxx]]></name>
		<start-date><![CDATA[November 15, 2010]]></start-date>
		<link><![CDATA[http://www.devoxx.com]]></link>
		<location><![CDATA[Antwerp, Belgium]]></location>
		<description>
			<![CDATA[
			<a href="http://reg.devoxx.com/">Register Here</a>
			<br/><br/>
			November 15-19, 2010<br/>
			Metropolis Antwerp, Groenendaallaan 394<br/><br/>
			With close to 3,000 attendees, Devoxx is the biggest independent Java conference in Europe and beyond.
			Join us during this 5 day roller-coaster ride.
			<br/><br/>
			See Christian Dupuis from SpringSource talk about Grovvy/Grails Development in Eclipse!
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[W-JAX]]></name>
		<start-date><![CDATA[November 15, 2010]]></start-date>
		<link><![CDATA[http://w-jax.de/]]></link>
		<location><![CDATA[Munich, Germany]]></location>
		<description>
			<![CDATA[
			<a href="https://www.entwickler.com/ssl/formtool/index.php?id=42&lang=de">Register Here</a>
			<br/><br/>
			November 15-19, 2010<br/>
			The Westin Grand M&umlnchen Arabellapark, Arabellastrasse 6<br/><br/>
			W-JAX is the conference for technical know-how in the Java and web
			environment. Here Europe's leading experts come together to distribute their knowledge and
			experience to attendees. Perfect organization, expert competence, as well as the comfortable
			ambiance make W-JAX a unique experience for software developers, architects, project managers and
			IT strategists.
			<br/><br/>
			Eclipse sessions include <i>Eclipse 4.0: CSS Styling and Workbench Modeling</i> by Kai Toedter and
			<i>The Rebirth of Mylyn: Eclipse, Agile and ALM</i> and <Bringing Open Source Collaboration to the
			Enterprise</i> by Mik Kersten.
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[EclipseDay in Valencia / MOSKittDay]]></name>
		<start-date><![CDATA[November 30, 2010]]></start-date>
		<link><![CDATA[http://www.moskitt.org/eng/3moskittday-eclipseday_2010/]]></link>
		<location><![CDATA[Valencia, Spain]]></location>
		<description>
			<![CDATA[
			<a href="http://www.moskitt.org/eng/3moskittday_contacto/">Register Here</a>
			<br/><br/>
			November 30 - December 1, 2010<br/><br/>
			Conselleria de Infraestructruras y Transporte (CIT) of the Valencian Comunity Regional
			Government is organizing MOSKittDay together with EclipseDay. CIT is a member of
			the Eclipse Foundation and heads the MOSKitt (Modeling Software Kitt) project in the development of
			an open source CASE tool based on Eclipse. 
			<br/><br/>
			The MOSKittDay event has a double goal, on the one hand CIT wants to make known the MOSKitt Project
			and to promote collaboration with other public and private organizations. On the other hand, CIT is
			also interested on making the MOSKitt CASE Tool known to future users beyond its current scope,
			identifying the added value that MOSKitt has as a FREE CASE Tool developed on Eclipse that supports
			gvMetrica (a development methodology defined by the CIT). 
			<br/><br/>
			At the same time, lectures and technical tutorials will bring the Spanish community of Eclipse
			users and developers together.  The proposed theme of the MOSKittDay conference is Modeling,
			Methodologies and Model Driven Development. Other themes related to Eclipse projects might also be
			included within the EclipseDay talks.  Participants are expected come from a wide range of academic,
			institutional and business backgrounds.
			<br/><br/>
			This edition differs from previous ones in that it will devote a day solely to the technical
			seminars. The purpose is to provide attendees a practical approach to tools, both to the technology
			that surrounds it and the uses it can have in IT development.
			]]>
		</description>
	</event>

	<event>
		<priority>1</priority>
		<name><![CDATA[Eclipse Foundation Holiday Pary]]></name>
		<start-date><![CDATA[December 17, 2010]]></start-date>
		<link><![CDATA[http://dev.eclipse.org/blogs/lynngo/2010/12/01/holiday-wine-cheese-beer-potatoes/]]></link>
		<location><![CDATA[Ottawa, ON, Canada]]></location>
		<description>
			<![CDATA[
			<a href="http://eclipseholiday2010.eventbrite.com/">Register Here</a>
			<br/><br/>
			December 17, 2010<br/>
			3:30pm - 6:30pm<br/>
			<a href="http://www.eclipse.org/org/foundation/directions.php" target="blank">Eclipse Foundation Office</a>, 102 Centrepointe Dr.<br/><br/>
			Eclipse committers, users and friends are invited to the Foundation's headquarters in Ottawa for a
			holiday get together.  Since we're not really a wine &amp; cheese crowd, we will instead hold a beer
			&amp; potatoes.  Stop by any time between 3:30pm and 6:30pm for some drinks and chips on us.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[LinkedIn Eclipse Group Social Networking and Presentation Event]]></name>
		<start-date><![CDATA[January 13, 2011]]></start-date>
		<link><![CDATA[http://events.linkedin.com/LinkedIn-Eclipse-Group-Social-Networking/pub/503888]]></link>
		<location><![CDATA[San Francisco, CA, USA]]></location>
		<description>
			<![CDATA[
			<a href="http://events.linkedin.com/LinkedIn-Eclipse-Group-Social-Networking/pub/503888">Register Here</a>
			<br/><br/>
			January 13, 2011<br/>
			8:00am - 6:30pm<br/>
			Oracle, 475 Sansome St., 15th Floor<br/><br/>
			This will be the first San Francisco Eclipse group monthly social networking meeting and
			product/technology presentation forum. Pizza and beverages will be provided compliments of Oracle.
			Planned presentations topics include Java, Eclipse and the Enterprise Cloud, and Mobile.
			<br/><br/>
			The talks at the event will also be broadcast by webinar and recorded for later viewing.  For
			details on the webinar see <a href="http://events.linkedin.com/Webinar-LinkedIn-Eclipse-Group-Meeting/pub/525492"
			target="blank">http://events.linkedin.com/Webinar-LinkedIn-Eclipse-Group-Meeting/pub/525492</a>.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[TOPCASED Days]]></name>
		<start-date><![CDATA[February 2, 2011]]></start-date>
		<link><![CDATA[http://www.topcased.org/index.php/content/view/53]]></link>
		<location><![CDATA[Toulouse, France]]></location>
		<description>
			<![CDATA[
			<a href="http://www.topcased.org/index.php/content/view/53">Register Here</a>
			<br/><br/>
			February 2-4, 2011<br/><br/>
			TOPCASED (Toolkit in OPen-source for Critical Application and SystEms Development) is a modular,
			open-source, Eclipse-based software environment providing methods and tools for critical embedded
			systems development, ranging from system and architecture specifications to software and hardware
			implementation through equipment definition. TOPCASED promotes model-driven engineering and formal
			methods as key technologies. Find out more at www.topcased.org.
			<br/><br/>
			Share your experiences of the TOPCASED environment at the three-day TOPCASED Days conference, which is
			open to industry and research communities and is aimed at users of all levels, including newcomers.
			TOPCASED Days provides an opportunity to exchange views with other users, present your work and learn
			more about TOPCASED capabilities. The conference is open to industry and research communities
			 and is aimed at users of all levels.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Meetup in San Franciso]]></name>
		<start-date><![CDATA[February 10, 2011]]></start-date>
		<link><![CDATA[http://www.meetup.com/sfeclipse/calendar/16120765/]]></link>
		<location><![CDATA[San Francisco, CA, USA]]></location>
		<description>
			<![CDATA[
			<a href="http://www.meetup.com/sfeclipse/calendar/16120765/">Register Here</a>
			<br/><br/>
			February 10, 2011<br/>
			6:30pm<br/>
			TIBCO, 3303 Hillview Ave., Palo Alto<br/><br/>
			The next LinkedIn Eclipse group presentation and networking event is at TIBCO's corporate offices
			in Palo Alto. Listen in as a senior architect describes how TIBCO uses Eclipse and why TIBCO is so
			dedicated to Eclipse and the foundation, and find out about the software engineer career
			prospects that TIBCO has to offer.
			<br/><br/>
			Paul Beusterien of Mobile Developers Solutions will also be doing a presentation on
			"Eclipse's Power and Potential for Mobile Web Developers". 
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[JUG-Chennai Monthly Meet-up]]></name>
		<start-date><![CDATA[February 12, 2011]]></start-date>
		<link><![CDATA[http://jug-c.wikispaces.com/Current+Monthly+Meeting]]></link>
		<location><![CDATA[Chennai, India]]></location>
		<description>
			<![CDATA[
			<a href="http://jug-c.wikispaces.com/Monthly+Meeting+Registry">Register Here</a>
			<br/><br/>
			February 12, 2011<br/>
			10:00am-1:00pm<br/>
			TIDEL Park, 'D' Block, North Wing, 3rd Floor, 4 Rajiv Gandhi Salai<br/><br/>
			The Java User Group in Chennai is hosting a free meet-up.  Planned topics are Eclipse UOMo,
			RCP/Plugins & OSGi - Werner Keil (Eclipse UOMo creator & JCP EC Member), Fantom & Tales Web Framework
			- Kaushik Sathupadi (Tales Web Framework creator) and Discussion on Annual event & 19th JavaFX Event.
			Please register in advance to attend.
			]]>
		</description>
	</event>	

	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Stammtisch in Munich]]></name>
		<start-date><![CDATA[February 22, 2011]]></start-date>
		<link><![CDATA[http://unicase.blogspot.com/2011/01/eclipse-stammtisch-munich-rescheduled.html]]></link>
		<location><![CDATA[Munich, Germany]]></location>
		<description>
			<![CDATA[
			<a href="https://spreadsheets.google.com/viewform?hl=en&formkey=dGg3YU92dml5eHYtaUY0XzVUdkFSekE6MA">Register Here</a>
			<br/><br/>
			February 22, 2011<br/>
			7:00 pm<br/>
			<a href="http://www.unionsbraeu.de/" target="blank">Unionsbrau</a><br/><br/>
			Engage the Eclipse community in Munich at the Eclipse Stammtisch! To get the ideas rolling, we'll
			have a few talks on Eclipse and then there will be plenty of time for some networking over beers.
			Please sign up if you'd like to attend.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Embedded World]]></name>
		<start-date><![CDATA[March 1, 2011]]></start-date>
		<link><![CDATA[http://www.embedded-world.de/en/]]></link>
		<location><![CDATA[Nuremburg, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://www.embedded-world.de/en/">Register Here</a>
			<br/><br/>
			March 1-3, 2011<br/><br/>
			The Embedded World Exhibition & Conference is the world's biggest exhibition of its kind and
			the meeting-place of the international embedded community. Embedded technologies are in action
			everywhere - whether in the car, data and telecommunication systems, industrial and consumer
			electronics, military systems or aerospace. 730 exhibitors and 18,350 visitors are expected.
			Tuesday at the conference will feature 2 sessions on open source projects.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[CeBIT]]></name>
		<start-date><![CDATA[March 1, 2011]]></start-date>
		<link><![CDATA[http://www.cebit.de/homepage_e]]></link>
		<location><![CDATA[Hanover, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://www.cebit.de/7380">Register Here</a>
			<br/><br/>
			March 1-5, 2011<br/>
			Hanover Exhibition Grounds, Hermesallee<br/><br/>
			CeBIT is the world's largest trade fair showcasing digital IT and telecommunications solutions for
			home and work environments. The key target groups are users from industry, the wholesale/retail
			sector, skilled trades, banks, the services sector, government agencies, science and all users
			passionate about technology. CeBIT offers an international platform for comparing notes on current
			industry trends, networking, and product presentations. 
			<br/><br/>
			Make sure you visit the Eclipse island in CeBIT's Open Source Park where Actuate, Bredex, EclipseSource,
			Instincttools, Sopera and Tasktop will be presenting. Other Eclipse members are welcome to join - email
			events@eclipse.org
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[ARS Eclipse Brunch: OSGi Basics and OSGi with WebSphere]]></name>
		<start-date><![CDATA[March 3, 2011]]></start-date>
		<link><![CDATA[http://www.ars.de/web/news/ars_eclipse_brunch_1_osgi_basics_und_osgi_mit_websphere.html]]></link>
		<location><![CDATA[Munich, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://www.ars.de/web/contact/subscription/default?eventId=ARS_EclipseBrunch_ET_110303">Register Here</a>
			<br/><br/>
			March 3, 2011<br/>
			ARS, Ridlerstrasse 55<br/><br/>
			ARS is offering a new series of one-day events on "Modular Applications with OSGi"! It is free
			to participate in the ARS brunches - eat and drink in a cozy atmosphere. In the first brunch,
			you will learn the basic concepts of OSGi with our experts. We will cover all the OSGi basics
			such as developing your first OSGi bundle, best practices and enterprise OSGi.  There will be hands-on
			work under the guidance of our speakers, so don't forget your laptop! 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[TheServerSide Java Symposium]]></name>
		<start-date><![CDATA[March 16, 2011]]></start-date>
		<link><![CDATA[http://javasymposium.techtarget.com/index.html]]></link>
		<location><![CDATA[Las Vega, NV, USA]]></location>
		<description>
			<![CDATA[
			<a href="http://javasymposium.techtarget.com/html/register.html">Register Here</a>
			<br/><br/>
			March 16-18, 2011<br/>
			Caesars Palace<br/><br/>
			TheServerSide Java Symposium 2011 is where architects, developers and managers need to be
			in order to gain the knowledge and Java-based skills required to excel in the mixed
			application environments of today and tomorrow. As an attendee of TheServerSide Java
			Symposium 2011, you learn how Java has matured into the language that holds heterogeneous
			enterprise applications, solutions and environments together. You experience software
			industry experts, users and peers sharing their experiences with modern Java-only and
			Java hybrid enterprise environments. Furthermore, you hear and network with respected
			industry insiders, who will provide their insights into how Java has become the key to the
			modern enterprise mix, and how Java will become the language of transition in the future.
			<br/><br/>
			Mik Kersten from Tasktop Technologies will give a talk on <i>Mylyn 3.4 and the New Face of
			the Java IDE</i>.
			]]>
		</description>
	</event>

	<event>
		<priority>1</priority>
		<name><![CDATA[Orion Summit]]></name>
		<start-date><![CDATA[March 17, 2011]]></start-date>
		<link><![CDATA[http://www.eclipsecon.org/2011/]]></link>
		<location><![CDATA[Palo Alto, CA, USA]]></location>
		<description>
			<![CDATA[
			<a href="http://wiki.eclipse.org/Orion/Planning_Meeting">Register Here</a>
			<br/><br/>
			March 17-18, 2011<br/>
			SAP Labs, 3410 Hillview Ave.<br/><br/>			
			Help chart the future of the Orion open source project. This meeting will bring together
			individuals and organizations that are interested in the future of the Orion open source
			project. We want to build a community of adopters and committers, so if you have a passion
			for better web tools, plan to attend. 		
			]]>
		</description>
	</event>
	
	<event>
		<priority>1</priority>
		<name><![CDATA[EclipseCon 2011]]></name>
		<start-date><![CDATA[March 21, 2011]]></start-date>
		<link><![CDATA[http://www.eclipsecon.org/2011/]]></link>
		<location><![CDATA[Santa Clara, CA, USA]]></location>
		<description>
			<![CDATA[
			<a href="http://www.eclipsecon.org/2011/">Register Here</a>
			<br/><br/>
			March 21-24, 2011<br/>
			Hyatt Regency Santa Clara, 5101 Great America Parkway<br/><br/>			
			EclipseCon is the premier technical and user conference focusing on the power of the Eclipse platform. From implementers to
			users, and everyone in between, if you are using, building, or considering Eclipse, EclipseCon is the conference you need
			to attend.		
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>EGL Conference</name>
		<start-date>April 5, 2011</start-date>
		<link>http://www.eglcon.org/</link>
		<location>Wiesbaden, Germany</location>
		<description>
			<![CDATA[
			<a href="http://www.eglcon.org/#registration">Register Here</a>
			<br/><br/>
			April 5-6, 2011<br/>
			<a href="http://www.radissonblu.com/hotel-wiesbaden" target="blank">Radisson Blu Schwarzer Bock Hotel</a><br/><br/>			
			Come learn about EGL and the Eclipse EGL Development Tools (EDT) project at the 2011 EGL
			Conference in Wiesbaden, Germany. This year's conference offers a variety of technical
			sessions, customer experiences, product demonstrations and a comprehensive view of the
			evolution of EGL technology over the past two years. Whether you are already an EGL user, or
			you are interested in exploring the power of this emerging programming technology, you will
			find this event very valuable.
			<br/><br/>
			Throughout the conference, you will have the opportunity to gather and exchange information
			with fellow developers, current EGL users, IBM Business Partners and IBM Rational architects
			to learn more about specific topics of interest to you.
			<br/><br/>
			More details about EGL can be found here: <a href="http://en.wikipedia.org/wiki/EGL_(programming_language)" target="blank">http://en.wikipedia.org/wiki/EGL_(programming_language)</a>
			or <a href="http://www.eclipse.org/edt/" target="blank">http://www.eclipse.org/edt/</a>. 
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>IBM Rational Jazz Roadshow: Agile Software Projects - from Planning to Testing</name>
		<start-date>April 5, 2011</start-date>
		<link>http://www-05.ibm.com/de/events/jazz/</link>
		<location>Germany</location>
		<description>
			<![CDATA[
			<a href="http://www-05.ibm.com/de/events/jazz/">Register Here</a>
			<br/><br/>
			April 5-12, 2011<br/>
			Munich, Ehningen, Frankfut, Dusseldorf & Hamburg</a><br/><br/>			
			Learn how to optimize team work with the help of Jazz solutions from IBM Rational at the IBM
			Rational Jazz Roadshow 2011.
			<br/><br/>
			Take part in demonstrations and scenarios that provide an informative overview of the Jazz
			platform and how it can help your agile software development. In addition to this, use the
			opportunity to discuss the challenges of smart software development with our experts at IBM. 
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name>ARS Eclipse Brunch # 2: Equinox and Eclipse Basics</name>
		<start-date>April 7, 2011</start-date>
		<link>http://www.ars.de/web/news/ars_eclipse_brunch_2.html</link>
		<location>Munchen, Germany</location>
		<description>
			<![CDATA[
			<br/>
			April 7, 2001<br/>
			Munchen, Germany<br/>
			<br/>
				Im zweiten Teil unserer Eclipse Brunch Reihe widmen wir uns u.a. dem Thema Eclipse Equinox. Equinox ist eine von der Eclipse Foundation 
				entwickelte OSGi-Plattform, welche neben der OSGi Core Specification auch Teile der OSGi Enterprise Specification implementiert. Equinox 
				bildet das GerÃ¼st der integrierten Entwicklungsumgebung Eclipse. Eine grundlegende Besonderheit von Equinox bei der Applikationsentwicklung 
				ist dessen Extension Point Registry. 
			<br/><br/>
			]]>
		</description>
	</event>	

	<event>
		<priority>2</priority>
		<name>JAX London</name>
		<start-date>April 11, 2011</start-date>
		<link>http://jaxlondon.com/</link>
		<location>London, United Kingdom</location>
		<description>
			<![CDATA[
			<a href="http://jaxlondon.com/conferences/Pricing/">Register Here</a>
			<br/><br/>
			April 11-14, 2011<br/>
			Park Plaza Victoria, 239 Vauxhall Bridge Rd.<br/><br/>			
			JAX London will provide an ideal forum for software developers, project managers and
			architects to learn about the latest Technology, Architecture and Agile Methodologies.
			The primary goal of JAX is to showcase technical solutions for today's problems and offer
			visions to the important trends of tomorrow. Delegates will benefit from hand-picked
			technical content with no marketing bushwah.
			<br/><br/>
			Eclipse talks include: <i>Effective Development with Eclipse, Git, Mylyn and Hudson</i> by Chris Aniszczyk from
			Red Hat, <i>Eclipse Virgo New Directions</i> by Hristo Iliev and Borislav Kapuparanov from SAP,
			and <i>OSGI Live-coding Challenge</i> by Neil Bartlett.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name>JAX</name>
		<start-date>May 2, 2011</start-date>
		<link>http://jax.de/2011/</link>
		<location>Mainz, Germany</location>
		<description>
			<![CDATA[
			<a href="https://www.entwickler.com/ssl/formtool/index.php?id=160&lang=de">Register Here</a>
			<br/><br/>
			May 2-6, 2011<br/>
			Rheingoldhalle<br/><br/>			
			JAX is the conference to attend for technical know-how in Java, Enterprise
			Architecture and SOA. The main conference offers over 150 sessions and attendees
			can also attend the Business Technology Days, Special Days, expo and Power Workshops.
			<br/><br/>
			For Eclipse content, there are full 
			Eclipse Modeling, Eclipse Runtime and Eclipse Tools days at the conference.
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[JBoss World]]></name>
		<start-date><![CDATA[May 3, 2011]]></start-date>
		<link><![CDATA[http://www.redhat.com/summit/]]></link>
		<location><![CDATA[Boston, MA, USA]]></location>
		<description>
			<![CDATA[
			<a href="https://redhat.g2planet.com/summitjbw2011/register">Register Here</a>
			<br/><br/>
			May 3-6, 2011<br/><br/>
			The Red Hat Summit and JBoss World bring together engineers, business decision makers,
			developers, and community enthusiasts to learn about the latest and greatest in cloud
			computing, platform, virtualization, middleware, and management technologies. A comprehensive
			agenda allows attendees the unique opportunity to move between both conferences for the price
			of one!
			<br/><br/>
			Of particular note to Eclipse users, Andrew Overholt and Jeff Johnston will present on <i>Eclipse
			in Red Hat Enterprise Linux 6.1 & Beyond</i>.
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Day India]]></name>
		<start-date><![CDATA[May 6, 2011 ]]></start-date>
		<link><![CDATA[http://www.eclipseday.in/]]></link>
		<location><![CDATA[Bangalore, India]]></location>
		<description>
			<![CDATA[
			<a href="http://eclipsedayindia.eventbrite.com/">Register Here</a>
			<br/><br/>
			May 6, 2011<br/>
			SAP Labs India, Whitefield campus
			<br/><br/>			
			The Eclipse Day India is a day-long event that explores Eclipse projects and topics for the local community. Eclipse experts 
			will present innovations in the Eclipse projects and organizations will discuss how they benefit from using Eclipse for their needs. 
			This event will be ideal for software architects, software development managers and senior developers who are interested in using Eclipse. 
			There is no cost to attend the event but you must pre-register.
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Integrated Development Day Berlin 2011]]></name>
		<start-date><![CDATA[May 9, 2011 ]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/Eclipse_Integrated_Development_Day_Berlin_2011]]></link>
		<location><![CDATA[Berlin, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://wiki.eclipse.org/Eclipse_Integrated_Development_Day_Berlin_2011">Register Here</a>
			<br/><br/>
			May 9, 2011<br/>
			Fraunhofer Institut FOKUS<br/><br/>			
			The Eclipse Integrated Development Day 2011 focuses on topics concerned with the collaboration of 
			engineers; the integration of tools, data (i. e. models), and processes; and with the coordination of different lifecycle activities.	
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Day Stuttgart]]></name>
		<start-date><![CDATA[May 10, 2011 ]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/index.php?title=EclipseDayStuttgart2011]]></link>
		<location><![CDATA[Stuttgart, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://wiki.eclipse.org/index.php?title=EclipseDayStuttgart2011">Register Here</a>
			<br/><br/>
			May 10, 2011<br/>
			STEP Engineering Park Stuttgart<br/><br/>			
			Eclipse DVCS/eGit Day 2011 is about distributed software development in transition: changing from centralized to 
			decentralized development processes and technical consequences for the design of the IT environment.
			]]>
		</description>
	</event>
		
	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse India Summit]]></name>
		<start-date><![CDATA[May 24, 2011]]></start-date>
		<link><![CDATA[http://www.developermarch.com/eclipsesummit/index.html]]></link>
		<location><![CDATA[Bangalore, India]]></location>
		<description>
			<![CDATA[
			<a href="http://www.developermarch.com/eclipsesummit/registration.html">Register Here</a>
			<br/><br/>
			May 24-25, 2011<br/>
			NIMHANS Convention Centre, Hosur Rd.<br/><br/>			
			With its release trains adding more wagons, project teams and source code lines each year,
			Eclipse is truly on a roll bringing in to its fold several developer communities including
			Java EE developers, PHP developers, C/C++ developers and more. The 2011 edition of Eclipse
			Summit, India Edition, is Asia's largest Eclipse-only show featuring intensive talks on all
			that you need to know as a developer using Eclipse-based tools and technologies.	
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[Code Generation]]></name>
		<start-date><![CDATA[May 25, 2011]]></start-date>
		<link><![CDATA[http://www.codegeneration.net/cg2011/]]></link>
		<location><![CDATA[Cambridge, United Kingdom]]></location>
		<description>
			<![CDATA[
			<a href="http://www.codegeneration.net/cg2011/">Register Here</a>
			<br/><br/>
			May 25-27, 2011<br/>
			<a href="http://www.murrayedwards.cam.ac.uk/" target="blank">Murray Edwards College</a><br/><br/>			
			CG2011 is for people who want to successfully apply or just learn more
			about the following topics: Xtext, Xpand, Xtend, Eclipse Modeling
			project, Domain-Specific Languages, Domain-Specific Modelling,
			Model-Driven Architecture, Executable UML, Model-Driven Software
			Development, Software Product Lines and other similar approaches.	
			]]>
		</description>
	</event>

	<event>
		<priority>2</priority>
		<name><![CDATA[What's Next Conference]]></name>
		<start-date><![CDATA[May 26, 2011]]></start-date>
		<link><![CDATA[http://www.whatsnextparis.com/]]></link>
		<location><![CDATA[Paris, France]]></location>
		<description>
			<![CDATA[
			<a href="http://www.codegeneration.net/cg2011/">Register Here</a>
			<br/><br/>
			May 26-27, 2011<br/>
			Grand Rex<br/><br/>			
			The What's Next conference will be the biggest Java event ever organized in France, gathering the vibrant
			French community. The goal of this annual conference is to bring to the audience the most up-to-date
			information on coming technologies, mainly around Java.  Developers, architects, project managers and executives
			from all sectors are invited to attend this new and exciting conference.	
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Day Jakarta]]></name>
		<start-date><![CDATA[May 30, 2011 ]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/Eclipse_Day_Jakarta_Indonesia_2011]]></link>
		<location><![CDATA[Jakarta, Indonesia]]></location>
		<description>
			<![CDATA[
			<a href="mailto:mila.yuliani@meruvian.org">Register Here</a>
			<br/><br/>
			May 30, 2011<br/>
			JW Center - Binus International<br/><br/>
			]]>
		</description>
	</event>
		
	<event>
		<priority>2</priority>
		<name><![CDATA[SMILA Conference]]></name>
		<start-date><![CDATA[June 29, 2011]]></start-date>
		<link><![CDATA[http://www.theseus-programm.de/themenkonferenzsmila/default.aspx]]></link>
		<location><![CDATA[Berlin, Germany]]></location>
		<description>
			<![CDATA[
			<a href="mailto:innovationszentrum@theseus-programm.de">Register Here</a>
			<br/><br/>
			June 29, 2011<br/>
			THESEUS - Innovation Center of the Internet services<br/>
			Salzufer 6<br/>
			10587 Berlin<br/><br/>			
			The open-source framework SMILA (www.eclipse.org/smila) offers a 
			future-proof, flexible and highly scalable basis for professional, semantic applications. The free conference 
			features an overview of SMILA, demos, and discussions on SMILA in action. 	
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[Open Forum 2011]]></name>
		<start-date><![CDATA[July 12, 2011 ]]></start-date>
		<link><![CDATA[http://www.open-forum.net/]]></link>
		<location><![CDATA[Stuttgart, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://conference2011.open-change-community.org/home/anmeldung">Register Here</a>
			<br/><br/>
			July 12-13, 2011<br/>
			Haus der Wirtschaft<br/>
			Stuttgart<br/><br/>			
			Open Forum 2011 includes A2A (Apps to Automotive), Embedded Eclipse, and Open Change: three outstanding events with the 
			theme "Software Development in Transition." Experts in the field will discuss the latest ideas, and 
			offer concrete solutions to the pressing challenges of software development.
			]]>
		</description>
	</event>
			
	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Testing Day]]></name>
		<start-date><![CDATA[September 7, 2011 ]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/Eclipse_Testing_Day_2011]]></link>
		<location><![CDATA[Neuss, Germany]]></location>
		<description>
			<![CDATA[
			<a href="http://wiki.eclipse.org/Eclipse_Testing_Day_2011">More Information Here</a>
			<br/><br/>
			September 7, 2011<br/>
			Commundo Tagungshotel<br/>
			HumboldtstraÃe 2<br/>
			41468 Neuss<br/><br/>			
			BREDEX GmbH have teamed up with the Eclipse Foundation to organize Eclipse Testing Day 2011. The Testing Day 
			is a day-long event for technical developers, testers, architects, project leads and managers to learn more 
			about testing. The theme for this year's Testing Day is "Testing: Technology and Process". We will select 
			talks focusing on test processes and the technology to support them. Participants will learn how 
			technology and process fit together, where they can complement each other and where there is potential for improvement.
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[Nuxeo World]]></name>
		<start-date><![CDATA[October 20, 2011 ]]></start-date>
		<link><![CDATA[http://www.nuxeoworld.com/]]></link>
		<location><![CDATA[Paris, France]]></location>
		<description>
			<![CDATA[
			<a href="http://www.nuxeoworld.com/register">Register Here </a>
			<br/><br/>
			October 20-21, 2011<br/>
			ThÃ©Ã¢tre des VariÃ©tÃ©s<br/>
			7, Boulevard Montmartre<br/>
			75002 Paris<br/><br/>			
			Nuxeo World provides multiple opportunities for partners and consumers to discuss ECM topics and share experiences. 
			Presentations will show how Nuxeo solutions have impacted businesses, and attendees will share knowledge and 
			expertise with others in the industry.	
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[BIRT Roadshow India]]></name>
		<start-date><![CDATA[August 26, 2011]]></start-date>
		<link><![CDATA[http://www.birt-exchange.com/be/info/birtroadshowindiaeclipse/]]></link>
		<location><![CDATA[Bangalore, India]]></location>
		<description>
			<![CDATA[
			<a href="http://www.birt-exchange.com/be/info/birtroadshowindiaeclipse/">Register Here </a>
			<br/><br/>
			August 26, 2011<br/>
			Vivanta by Taj<br/>
			41/3, Mahatma Gandhi Road<br/>
			Bangalore<br/>
			Karnataka - 560 001<br/><br/>			
			Meet Actuate in Bangalore to find out all you need to know about BIRT (Business Intelligence Reporting Tools) at a free 
			half-day workshop. Register today to learn how to build a new generation of rich information applications.	
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Embedded Day Spain 2011]]></name>
		<start-date><![CDATA[October 17, 2011 ]]></start-date>
		<link><![CDATA[http://www.tecnalia.com/en/divisions/ict-european-software-institute/software-systems-engineering/events/eclipse-embedded-day-spain-2011.htm]]></link>
		<location><![CDATA[Zamudio, Spain]]></location>
		<description>
			<![CDATA[
			<a href="http://www.tecnalia.com/en/divisions/ict-european-software-institute/software-systems-engineering/events/eclipse-embedded-day-spain-2011.htm">Register Here</a>
			<br/><br/>
			October 17, 2011<br/>
			Tecnalia<br/>
			Parque TecnolÃ³gico de Bizkaia<br/>
			Edificio 202<br/>
			E-48170 Zamudio<br/><br/>			
			Eclipse Embedded Day Spain 2011 aims at bringing together experts, practitioners and researchers, mainly from the Spanish embedded systems community, in a mix of high-quality talks, 
			sessions, and demonstrations.
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[Focus on Eclipse at Oracle OpenWorld]]></name>
		<start-date><![CDATA[October 2, 2011]]></start-date>
		<link><![CDATA[http://www.oracle.com/technetwork/developer-tools/eclipse/overview/focuson-eclipse-oow2011-462721.pdf]]></link>
		<location><![CDATA[San Francisco, CA, USA]]></location>
		<description>
			<![CDATA[
			<a href="http://www.oracle.com/openworld/register/packages/index.html?src=7120737&Act=6&sckw=WWMK10080712MPP001">Register Here</a>
			<br/><br/>
			October 2-6, 2011<br/>
			Moscone Center<br/>
			San Francisco, California<br/><br/>			
			OpenWorld 2011 includes a comprehensive program for developer tools with sessions at both OpenWorld and Develop Stream. This year's event also includes a Demo Pod 
			and several hands-on labs.
			]]>
		</description>
	</event>
	
	Â <event>
		<priority>2</priority>
		<name><![CDATA[fOSSa]]></name>
		<start-date><![CDATA[October 26, 2011 ]]></start-date>
		<link><![CDATA[http://fossa.inria.fr/]]></link>
		<location><![CDATA[Lyon, France]]></location>
		<description>
			<![CDATA[
			<a href="http://fossa.inria.fr/">Register Here</a>
			<br/><br/>
			October 26-28, 2011<br/>
			CITI Laboratory, INSA LyonDomaine Scientifique de la Doua<br/>
			Batiment Claude Chappe<br/>
			6 Avenue des Arts<br/>
			69621 Villeurbanne Cedex<br/><br/>			
			At fOSSa, attendees will discuss issues in an open-minded context: what tech people are doing, the current issues 
			and challenges in open-source development, and how open activities and collaboration benefit academia, education, 
			and industry.	
			]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Day Paris]]></name>
		<start-date><![CDATA[November 8, 2011 ]]></start-date>
		<link><![CDATA[http://www.eclipsedayparis.com/]]></link>
		<location><![CDATA[Paris, France]]></location>
		<description>
			<![CDATA[
			<a href="http://www.eclipsedayparis.com/">Register Here</a>
			<br/><br/>
			November 8, 2011<br/>
			Pavillon Royal<br/>
			Carrefour du bout du Lac<br/>
			Bois de Boulogne<br/>
			Avenue de Suresnes<br/>
			75116 Paris<br/><br/>			
		    Eclipse Day Paris brings together technological and industrial players from the Eclipse ecosystem around the following themes: runtimes,
		    e4, embedded, modeling, and data management.]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[Oracle Virtual Developer Day: WebLogic Server 12c]]></name>
		<start-date><![CDATA[January 24, 2012 ]]></start-date>
		<link><![CDATA[https://oracle.6connex.com/portal/weblogicsuite/login]]></link>
		<location><![CDATA[]]></location>
		<description>
			<![CDATA[
			<a href="https://oracle.6connex.com/portal/weblogicsuite/login">Register Here</a>
			<br/><br/>	
		    Java Developers and Architects will learn about Java EE6, WebLogic Server, 
		    Coherence, Eclipse, NetBeans, Maven and Hudson in hands on labs and sessions 
		    while interacting with Oracle product experts in live, moderated chats.]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[EclipseCon 2012]]></name>
		<start-date><![CDATA[March 26, 2012 ]]></start-date>
		<link><![CDATA[http://www.eclipsecon.org/2012]]></link>
		<location><![CDATA[Reston, Virgina, USA]]></location>
		<description>
			<![CDATA[
			<a href="http://www.eclipsecon.org/2012/registration">Register Here</a>
			<br/><br/>
			March 26 - 29, 2012<br/>
			Hyatt Regency Reston<br/>
			1800 Presidents Street<br/>
			Reston, Virginia<br/>
			United States<br/><br/>			
		    EclipseCon 2012 is the Eclipse community's premier North American event, bringing together a dynamic technical program 
		    and unique social networking opportunities. This year's conference features a new location on the east coast of the U.S., just outside 
		    Washginton, D.C.]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[Code Generation 2012]]></name>
		<start-date><![CDATA[March 28, 2012 ]]></start-date>
		<link><![CDATA[http://www.codegeneration.net/cg2012/index.php]]></link>
		<location><![CDATA[Cambridge, UK]]></location>
		<description>
			<![CDATA[
			<a href="http://www.codegeneration.net/cg2012/index.php">Register Here</a>
			<br/><br/>
			March 28 - 30, 2012<br/>
			Murray Edwards College<br/>
			University of Cambridge<br/>
			Huntingdon Road<br/>
			Cambridge<br/><br/>			
		    The Code Generation conference is Europe's leading event on Code Generation and Model-Driven Software Development. The 
		    event has a strong practical focus and an emphasis on sharing experiences and knowledge.]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[Jubula Training Day]]></name>
		<start-date><![CDATA[May 3, 2012 ]]></start-date>
		<link><![CDATA[http://www.rcp-vision.com/?page_id=2939&lang=en]]></link>
		<location><![CDATA[Florence, Italy]]></location>
		<description>
			<![CDATA[
			<a href="http://www.rcp-vision.com/?page_id=2939&lang=en">Register Here</a>
			<br/><br/>
			May 3, 2012<br/>
			In conjuction with Eclipse Day Florence (4 May)<br/>
			Palazzo dei Congressi<br/>
			Piazza Adua, 1<br/>
			50123 Florence<br/>
			Italy<br/><br/>			
		    <br/>In conjunction with Eclipse Day Florence, BREDEX GmbH and RCP Vision are offering a 
		    workshop where participants can learn from the Jubula experts in an intensive one-day course.]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Day Florence]]></name>
		<start-date><![CDATA[May 4, 2012 ]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/Eclispe_Day_Florence_2012]]></link>
		<location><![CDATA[Florence, Italy]]></location>
		<description>
			<![CDATA[
			<a href="http://www.eclipsedayflorence.com/">Register Here</a>
			<br/><br/>
			May 4, 2012<br/>
			Palazzo dei Congressi<br/>
			Piazza Adua, 1<br/>
			50123 Florence<br/>
			Italy<br/><br/>			
		    ]]>
		</description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[BPW Inspire Channel Days]]></name>
		<start-date><![CDATA[March 21, 2012]]></start-date>
		<link><![CDATA[http://www.channel-days.de/]]></link>
		<location><![CDATA[Kommandeursburg]]></location>
		<description><![CDATA[
		<a href="http://de.amiando.com/INSPIRE.html?page=570444">Register Here</a>
		<br/><br/>
		March 21 - 22, 2012<br/>
		Commander Castle Kerpen near Cologne<br/>
		DÃ¼renerstrasse 231<br/>
		50171 Kerpen - Blatzheim<br/>
		Germany<br/>
		<br/>"Channel Days" is a special event for IT service and software companies around the issue of process management (BPM) and current IT topics with numerous practical examples.]]></description>
	</event>
	
		<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Integrated Development Day]]></name>
		<start-date><![CDATA[May 30, 2012]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/index.php?title=Eclipse_IDD_2012]]></link>
		<location><![CDATA[Berlin]]></location>
		<description><![CDATA[
		<a href="http://wiki.eclipse.org/index.php?title=Eclipse_IDD_2012#REGISTRATION">Register Here</a>
		<br/><br/>
		May 30, 2012<br/>
		Fraunhofer-Forum Berlin<br/>
		Anna-Louisa-Karsch-Str. 2<br/>
		10178 Berlin<br/>
		Germany<br/>
		<br/>Eclipse Integrated Development Day in Berlin is a day-long event for technical developers, 
		architects and managers interested in tool and process integration as well as automation 
		in development processes. Attendees will have the chance to hear speakers from leading 
		organizations and experts from the Eclipse community.]]></description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Testing Day]]></name>
		<start-date><![CDATA[September 5, 2012]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/Eclipse_Testing_Day_2012]]></link>
		<location><![CDATA[Darmstadt (Neuss)]]></location>
		<description><![CDATA[
		<a href="http://eclipsetestingday2012.eventbrite.com/">Agenda and Registration</a>
		<br/><br/>
		September 5, 2012<br/>
		Commundo Tagungshotel, Neuss<br/>
		Humboldtstr. 2<br/>
		41468 Neuss<br/>
		Germany<br/>
		<br/>Eclipse Testing Day will give you insight into testing for Eclipse applications and in the Eclipse community, including talks from Eclipse users and companies, lightning talks on 
		areas "beyond" testing, and an interactive panel discussion with three experts from the Eclipse and Testing communities. Questions for the panel may be added ahead of time on the
		<a href="http://wiki.eclipse.org/Eclipse_Testing_Day_2012_Talks#Advance_questions_for_panel">Talks wiki page</a>.]]></description>
	</event>
	
	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Day Toulouse]]></name>
		<start-date><![CDATA[May 24, 2012]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/Eclipse_Day_Toulouse_2012]]></link>
		<location><![CDATA[Toulouse]]></location>
		<description><![CDATA[
		<a href="http://wiki.eclipse.org/Eclipse_Day_Toulouse_2012#Attendee_Registration">Register Here</a>
		<br/><br/>
		May 24, 2012<br/>
		Toulouse<br/>
		France<br/>
		<br/>The Eclipse Foundation, together with the M2M and Polarsys Industry Working Groups, 
		invite you to a day of exchanges around two topics strongly anchored in 
		Toulouse and its area: Machine 2 Machine and Embedded Systems Engineering.]]></description>
	</event>
	<event>
		<priority>2</priority>
		<name><![CDATA[SMILA &dash; Unified Information Access Architecture Tutorial]]></name>
		<start-date><![CDATA[May 14, 2012]]></start-date>
		<link><![CDATA[http://theseus-programm.de/de/veranstaltungentiz.php]]></link>
		<location><![CDATA[Berlin (Germany)]]></location>
		<description><![CDATA[
		Registration via email <a href="mailto:innovationszentrum@theseus-programm.de">innovationszentrum@theseus-programm.de</a><br/><br/>
		May 14, 2012, 13:00-17:30<br/>
		Theseus Innovation Centre<br/>
		Am Salzufer 5<br/>
		Berlin<br/>
		Germany<br/>
		<br/>Demand for SMILA tutorials is growing, so we decided to organize another one in May. This time the tutorial will take place in Berlin, 
		Germany at TIZ on 14th May starting at 13:30. The participation is free, but since the number of participants is limited, 
		make sure to register early at <a href="mailto:innovationszentrum@theseus-programm.de">innovationszentrum@theseus-programm.de</a>.]]></description>
	</event>
	<event>
		<priority>2</priority>
		<name><![CDATA[SMILA Themenkonferenz (in German)]]></name>
		<start-date><![CDATA[May 15, 2012]]></start-date>
		<link><![CDATA[http://www.theseus-programm.de/de/1867.php]]></link>
		<location><![CDATA[Berlin (Germany)]]></location>
		<description><![CDATA[
		Registration via email <a href="mailto:innovationszentrum@theseus-programm.de">innovationszentrum@theseus-programm.de</a><br/><br/>
		May 15, 2012, 13:00-17:00<br/>
		Theseus Innovation Centre<br/>
		Am Salzufer 5<br/>
		Berlin<br/>
		Germany<br/>
		<br/>Curious about what has been done in SMILA in the last two releases and who and how has been using SMILA? Then you should visit our SMILA conference in Berlin on 15th May. Make sure to register early at <a href="mailto:innovationszentrum@theseus-programm.de">innovationszentrum@theseus-programm.de</a>, since the number of participants is limited.]]></description>
	</event>
	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Day Delft]]></name>
		<start-date><![CDATA[September 27, 2012]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/Eclipse_Day_Delft_2012]]></link>
		<location><![CDATA[Delft (The Netherlands)]]></location>
		<description><![CDATA[
		<a href="http://wiki.eclipse.org/Eclipse_Day_Delft_2012#Call_for_Papers">Call for Papers</a> via email to <a href="mailto:yuri.kok@industrial-tsi.com">Yuri Kok</a></br>
		<a href="http://wiki.eclipse.org/Eclipse_Day_Delft_2012#Sponsoring_Packages">Sponsorship Packages</a><br/><br/>
		September 27, 2012, 8:30-18:00<br/>
		Aula Congress Center TU Delft<br/>
		Mekelweg 5, 2628 CC<br/>
		Delft<br/>
		The Netherlands<br/>
		<br/>Eclipse Day Delft will focus on interaction and stimulating discussion among participants. Talks and discussion rounds will inform about new and noteworthy 
		Eclipse technologies, with demos and drinks in the afternoon to facilitate networking.]]></description>
	</event>
	<event>
		<priority>2</priority>
		<name><![CDATA[Red Hat Developer Day]]></name>
		<start-date><![CDATA[June 26, 2012]]></start-date>
		<link><![CDATA[http://www.redhat.com/summit/developerday/]]></link>
		<location><![CDATA[Boston (USA)]]></location>
		<description><![CDATA[
		<a href="https://www.redhatsummit2012.com/Login.aspx">Register Here</a><br/><br/>
		June 26, 2012<br/>
		Hynes Convention Center<br/>
		900 Boylston Street<br/>
		Boston, MA 02115<br/>
		United States<br/>
		<br/>The Red Hat Developer Day is a new, one-day event for application developers who want to learn advanced technical details 
		about Red Hat offerings, including Red Hat Enterprise Linux, Red Hat Cloud, Red Hat Enterprise Virtualization, and Red Hat Storage.]]></description>
	</event>	
	
	<event>
		<priority>2</priority>
		<name><![CDATA[Fluent Conference]]></name>
		<start-date><![CDATA[May 29, 2012]]></start-date>
		<link><![CDATA[http://fluentconf.com]]></link>
		<location><![CDATA[San Francisco (USA)]]></location>
		<description><![CDATA[
		<a href="https://en.oreilly.com/fluent2012/public/register">Register Here</a><br/><br/>
		May 29-31, 2012<br/>
		Hilton San Francisco, Union Square<br/>
		333 O'Farrell Street<br/>
		San Francisco, CA 94102<br/>
		United States<br/>
		<br/>The Eclipse Foundation will be showing Orion at Fluent. For a 20% discount, register with the code ECLIPSE.]]></description>
	</event>	
	
	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Day Naples]]></name>
		<start-date><![CDATA[September 20, 2012]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/Eclipse_IT_2012_Day_Naples%2C]]></link>
		<location><![CDATA[Pozzuoli (Italy)]]></location>
		<description><![CDATA[		
		<a href="http://2012.eclipse-it.org/">More Information Here</a><br/><br/>
		September 20-21, 2012<br/>
		Accademia Aeronautica<br/>		
		Pozzuoli (NA)<br/>
		Italy<br/>
		<br/>The seventh annual event for the Italian Eclipse Community includes universities, public institutions and industries, researchers and 
		practitioners, students and professionals, all joined by an interest in promoting, experimenting, extending, and supporting the Eclipse platform.]]></description>
	</event>	
	<event>
		<priority>2</priority>
		<name><![CDATA[Eclipse Finance Day]]></name>
		<start-date><![CDATA[October 16, 2012]]></start-date>
		<link><![CDATA[http://wiki.eclipse.org/Eclipse_Finance_Day_2012]]></link>
		<location><![CDATA[Zurich (Switzerland)]]></location>
		<description><![CDATA[		
		<a href="http://wiki.eclipse.org/Eclipse_Finance_Day_2012">More Information Here</a><br/><br/>
		October 16, 2012<br/>
		UBS Offices<br/>		
		Zurich<br/>
		Switzerland<br/>
		<br/>The seventh annual event for the Italian Eclipse Community includes universities, public institutions and industries, researchers and 
		practitioners, students and professionals, all joined by an interest in promoting, experimenting, extending, and supporting the Eclipse platform.]]></description>
	</event>						
</events>