<?xml version="1.0" encoding="UTF-8"?>
<events xmlns="http://www.eclipse.org/webtools/events"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.eclipse.org/webtools/events schemas/events.xsd ">
	<event startdate="2005-10-23" enddate="2005-10-28"
		organization="Colorado Software Summit 2005"
		link="http://softwaresummit.com"
		logo="images/coloradosoftwaresummit.gif">
		<presentation type="Presentation"
			link="http://softwaresummit.com/2005/speakers/ryman.htm"
			title="Developing Web Service with Eclipse">
			<presenter name="Arthur Ryman"/>
		</presentation>
		<presentation type="Presentation"
			link="http://softwaresummit.com/2005/speakers/ryman.htm"
			title="What's New in WSDL 2.0">
			<presenter name="Arthur Ryman"/>
		</presentation>
	</event>
	<event startdate="2005-08-29" enddate="2005-08-31"
		organization="EclipseWorld 2005" link="http://www.eclipseworld.net"
		logo="images/EclipseWorld-129.gif">
		<presentation type="Technical Classes" 
					  title="Creating Your First J2EE Web Application With Eclipse in 90 Minutes"
					  link="http://www.bzmedia.com/eclipseworld/tuesday.htm">
			<presenter name="Lawrence Mandel"/>
			<presenter name="Jason Sholl"/>
		</presentation>
		<presentation type="Technical Classes" 
					  title="Consuming and Producing Web Services With WST and JST"
					  link="http://www.bzmedia.com/eclipseworld/tuesday.htm">
			<presenter name="Christopher M. Judd"/>
		</presentation>
		<presentation type="Technical Classes" 
					  title="Interacting With Relational Databases"
					  link="http://www.bzmedia.com/eclipseworld/tuesday.htm">
			<presenter name="Christopher M. Judd"/>
		</presentation>
		<presentation type="Technical Classes" 
					  title="Developing Web Services With Eclipse"
					  link="http://www.bzmedia.com/eclipseworld/tuesday.htm">
			<presenter name="Arthur Ryman"/>
		</presentation>
		<presentation type="Technical Classes" 
					  title="Java Annotations in Eclipse: Enhancing the JDT Experience"
					  link="http://www.bzmedia.com/eclipseworld/tuesday.htm">
			<presenter name="Tim Wagner"/>
		</presentation>
		<presentation type="Technical Classes" 
					  title="XML Editing With Eclipse"
					  link="http://www.bzmedia.com/eclipseworld/tuesday.htm">
			<presenter name="Elliotte Rusty Harold"/>
		</presentation>
		<presentation type="Technical Classes" 
					  title="Developing Web Services With the Web Tools Platform"
					  link="http://www.bzmedia.com/eclipseworld/tuesday.htm">
			<presenter name="David Gallardo"/>
		</presentation>
		<presentation type="Technical Classes" 
					  title="Developing Enterprise JavaBeans With J2EE Standard Tools"
					  link="http://www.bzmedia.com/eclipseworld/wednesday.htm">
			<presenter name="Christopher M. Judd"/>
		</presentation>
		<presentation type="Technical Classes" 
					  title="Web Application Development With Web Tools Platform, Part I"
					  link="http://www.bzmedia.com/eclipseworld/wednesday.htm">
			<presenter name="Tim Wagner"/>
		</presentation>
		<presentation type="Technical Classes" 
					  title="Web Application Development With Web Tools Platform, Part II: Advanced Topics and Extension Points"
					  link="http://www.bzmedia.com/eclipseworld/wednesday.htm">
			<presenter name="Tim Wagner"/>
		</presentation>
		<presentation type="Technical Classes" 
					  title="Building With the Data Tools Project"
					  link="http://www.bzmedia.com/eclipseworld/wednesday.htm">
			<presenter name="John Graham"/>
			<presenter name="Der-Ping Chou"/>
		</presentation>
		<presentation type="Tutorial" 
					  title="Developing J2EE Applications With the Web Tools Platform Project"
					  link="http://www.bzmedia.com/eclipseworld/monday.htm">
			<presenter name="Christopher M. Judd"/>
		</presentation>
	</event>
	<event startdate="2005-05-30" enddate="2005-06-01"
		organization="Holland Open Software Conference 2005"
		link="http://www.hollandopen.nl/"
		logo="images/hollandopen.gif">
		<presentation type="Presentation"
			link="http://www.hollandopen.nl/index.jsp?nr=1704"
			title="Eclipse and the Web Tools Platform">
			<presenter name="Naci Dai"/>
		</presentation>
	</event>
	<event startdate="2005-05-22" enddate="2005-05-26"
		organization="IBM Rational Software Development Conference 2005"
		link="https://www.conferonreg.com/RationalSpeaker2005/Agenda/agenda_main_page.cfm"
		logo="images/rsdc05.gif">
		<presentation type="Presentation"
			link="https://www.conferonreg.com/RationalSpeaker2005/Agenda/agenda_by_track.cfm?track=SDP&#38;#SDP28"
			title="Introduction to the Eclipse Web Tools Platform Project">
			<presenter name="Craig Salter"/>
			<presenter name="Keith Chong"/>
		</presentation>
	</event>
	<event startdate="2005-05-12" enddate="2005-05-12"
		organization="Le club des utilisateurs java"
		link="http://www.club-java.com/"
		logo="images/LogoPetit.gif">
		<presentation type="Presentation"
			link="http://enews.naos.com/servlets/com.naos.enews.HtmlFileFilter?id=183555096&#38;filter=true"
			title="ObjectWeb and Eclipse - the WTP project and beyond">
			<presenter name="Christophe Ney"/>
		</presentation>
	</event>
	<event startdate="2005-05-09" enddate="2005-05-13"
		organization="JAX 2005" link="http://www.jax.de"
		logo="images/jax05-logo.jpg">
		<presentation type="Presentation"
			link="http://www.jax.de/konferenzen/psecom,id,277,nodeid,,.html#EC1"
			title="Eclipse: What's new in 3.1">
			<presenter name="Erich Gamma" />
			<presenter name="Jochen Krause"/>
		</presentation>
		<presentation type="Presentation"
			link="http://www.jax.de/konferenzen/psecom,id,277,nodeid,,.html#EC12"
			title="Extending the SSE">
			<presenter name="Jens Lukowski"/>
		</presentation>
	</event>

	<event startdate="2005-02-15" enddate="2005-02-17"
		organization="Web Service Edge 2005 East"
		link="http://www.sys-con.com/edge2005east/index.cfm">
		<presentation type="Case Study"
			link="http://www.sys-con.com/story/?storyid=47527"
			title="Developing Web Services with Eclipse">
			<presenter name="Arthur Ryman"/>
		</presentation>
	</event>

	<event startdate="2005-02-23" enddate="2005-02-23"
		organization="&#201;cole de technologie sup&#233;rieure"
		link="http://www.etsmtl.ca/"
		logo="images/ecoledetechnologie.gif">
		<presentation type="Presentation"
			link="http://www.etsmtl.ca/zone2/departements/logti/evenements/conference5.pdf"
			title="Formal Specification at W3C">
			<presenter name="Arthur Ryman"/>
		</presentation>
	</event>

	<event startdate="2005-02-28" enddate="2005-03-03"
		organization="EclipseCon"
		link="http://www.eclipsecon.org/?ID=EclipseWTP"
		logo="images/eclipsecon.gif">
		<presentation type="Technical Sessions"
			link="http://www.eclipsecon.org/sessions.php"
			title="Extend web tools server tooling for your application server">
			<presenter name="Gorkem Ercan"/>
			<presenter name="Tim deBoer"/>
		</presentation>
		<presentation type="Technical Sessions"
			link="http://www.eclipsecon.org/sessions.php"
			title="Eclipse Web Tools Platform Project Overview">
			<presenter name="Naci Dai"/>
			<presenter name="Arthur Ryman"/>
		</presentation>
		<presentation type="Technical Sessions"
			link="http://www.eclipsecon.org/sessions.php"
			title="Web Services Dev. with Eclipse Web Tools Platform Project">
			<presenter name="Jeffrey Liu"/>
			<presenter name="Lawrence Mandel"/>
		</presentation>
		<presentation type="Tutorials"
			link="http://www.eclipsecon.org/tutorials.php"
			title="Introduction to the Web Tools Platform">
			<presenter name="Chuck Bridgham"/>
			<presenter name="Lawrence Mandel"/>
		</presentation>
	</event>

	<event startdate="2005-03-01" enddate="2005-03-01"
		organization="SDForum" link="http://www.sdforum.org/"
		logo="images/sdforum.jpg">
		<presentation type="Presentation" time="6:30pm"
			link="http://www.sdforum.org/SDForum/Templates/Level1.aspx?pid=10108&#38;sid=7"
			title="Eclipse Web Tools Platform Project Overview">
			<presenter name="Tim deBoer"/>
		</presentation>
	</event>

	<event startdate="2005-01-25" enddate="2005-01-25"
		organization="Portland Java User's Group" link="http://www.pjug.org/"
		logo="images/pjug.gif">
		<presentation type="Presentation" title="Eclipse Web Tools" time="6:30pm">
			<presenter name="Sean C. Sullivan" />
		</presentation>
	</event>

	<event startdate="2005-01-20" enddate="2005-01-22"
		organization="CUTC 2005 : Canadian Undergraduate Technology Conference"
		link="http://www.cutc.ca"
		logo="images/cutc2005.gif">
		<presentation type="TechShop"
			title="Dive into Eclipse and the Web Tools Platform Project">
			<presenter name="Jeffrey Liu"/>
			<presenter name="Lawrence Mandel"/>
			<material type="Tutorial"
				name="Building a School Schedule Web Application"
				link="http://www.eclipse.org/webtools/testtutorials/M2/webapptutorial/BuildingAScheduleWebApp.html" />
		</presentation>
	</event>
	<event startdate="2005-01-19" enddate="2005-01-21"
		organization="ObjectWebCon'05"
		link="http://www.objectweb.org/ObjectWebCon05"
		logo="images/objectwebcon.jpg">
		<presentation type="Speaker Sessions"
			title="Eclipse Web Tools Platform Project Overview">
			<presenter name="Naci Dai"/>
		</presentation>
		<presentation type="Speaker Sessions"
			title="Eclipse Web Tools - Extending the Structured Source Editor">
			<presenter name="Jochen Krause"/>
		</presentation>
	</event>

    <event startdate="2005-04-07" enddate="2005-04-07"
		organization="Web Services &amp; SOA China 2005"
		link="http://www.webserviceschina.com/"
		logo="images/wssoachina2005.gif">
		<presentation type="Presentation"
			title="Developing Web Services with Eclipse">
			<presenter name="Arthur Ryman"/>
		</presentation>
	</event>
	<event startdate="2005-06-02" enddate="2005-06-02"
		organization="WTP Open House"
		link="../development/arch_and_design/arch_page.html">
		<presentation type="Presentation"
			title="Common Components">
			<presenter name="Craig Salter"/>
			<material name="Presentation" type="PowerPoint" link="http://www.eclipse.org/downloads/download.php?file=/webtools/downloads/presentations/2005/06-02-wtp-open-house/common-tools-06-02-1530-highlighted2.ppt"/>
		</presentation>
	</event>
	<event startdate="2005-06-09" enddate="2005-06-09"
		organization="WTP Open House"
		link="../development/arch_and_design/arch_page.html">
		<presentation type="Presentation"
			title="WTP Editors (XML, JSP, etc)">
			<presenter name="David Williams"/>
			<material name="Presentation" type="PowerPoint" link="http://www.eclipse.org/downloads/download.php?file=/webtools/downloads/presentations/2005/06-09-wtp-open-house/sse-openhouse-6-9.ppt"/>
		</presentation>
	</event>
    <event startdate="2005-06-16" enddate="2005-06-16"
		organization="WTP Open House"
		link="../development/arch_and_design/arch_page.html">
		<presentation type="Presentation"
			title="J2EE">
			<presenter name="Chuck Bridgham"/>
			<material name="Presentations" type="PowerPoint" link="http://www.eclipse.org/downloads/download.php?file=/webtools/downloads/presentations/2005/06-16-wtp-open-house/j2ee-tools-06-16.ppt"/>
		</presentation>
	</event>
    <event startdate="2005-05-19" enddate="2005-05-19"
		organization="WTP Open House"
		link="../development/arch_and_design/arch_page.html">
		<presentation type="Presentations"
			title="Server and Database Components">
			<presenter name="Tim deBoer"/>
			<presenter name="Der-Ping Chou"/>
			<material name="Server Presentation" type="PowerPoint" link="http://www.eclipse.org/downloads/download.php?file=/webtools/downloads/presentations/2005/05-19-wtp-open-house/server-tools.ppt"/>
			<material name="Database Presentation" type="PowerPoint" link="http://www.eclipse.org/downloads/download.php?file=/webtools/downloads/presentations/2005/05-19-wtp-open-house/data-tools.ppt"/>
		</presentation>
	</event>
	<event startdate="2005-05-26" enddate="2005-05-26"
		organization="WTP Open House"
		link="../development/arch_and_design/arch_page.html">
		<presentation type="Presentations"
			title="Web Services">
			<presenter name="Chris Brealey"/>
			<material name="Presentations" type="PowerPoint" link="http://www.eclipse.org/downloads/download.php?file=/webtools/downloads/presentations/2005/05-26-wtp-open-house/web-service-tools.ppt"/>
		</presentation>
	</event> 
	<event startdate="2005-06-27" enddate="2005-06-30"
		organization="JavaOne 2005"
		link="http://java.sun.com/javaone/sf/index.jsp">
		<presentation type="Presentations"
			title="What's New in Eclipse? A Java™ Technology IDE and a Whole Lot More"
			link="https://www28.cplan.com/javaone05_93_1/session_details.jsp?isid=271654&amp;ilocation_id=93-1&amp;ilanguage=english">
			<presenter name="Mike Milinkovich"/>
			<presenter name="Bjorn Freeman-Benson"/>
		</presentation>
		<presentation type="Presentations"
			title="Introduction to the Web Tools Platform Project"
			link="https://www28.cplan.com/javaone05_93_1/session_details.jsp?isid=271909&amp;ilocation_id=93-1&amp;ilanguage=english">
			<presenter name="Tim Wagner"/>
		</presentation>
	</event> 
	<event startdate="2005-10-16" enddate="2005-10-20"
		organization="OOPSLA 2005"
		link="http://www.oopsla.org/2005/ShowPage.do?id=Home"
		logo="images/oopsla05.jpg">
		<presentation type="Demonstrations"
			title="Eclipse Web and J2EE Development"
			link="http://www.oopsla.org/2005/ShowEvent.do?id=624">
			<presenter name="Lawrence Mandel"/>
		</presentation>
	</event> 
	<event startdate="2005-10-17" enddate="2005-10-20"
		organization="CASCON 2005"
		link="http://cas.ibm.com/cascon"
		logo="images/cascon05.gif">
		<presentation type="Workshops"
			title="Hands-On: Dive into Eclipse and the Web Tools Platform Project"
			link="https://www-927.ibm.com/ibm/cas/cascon/workshops/mon.shtml">
			<presenter name="Jeffrey Liu"/>
			<presenter name="Ella Belisario"/>
		</presentation>
		<presentation type="Workshops"
			title="Hands-On: Using Web Services in the Web Tools Platform (WTP)"
			link="https://www-927.ibm.com/ibm/cas/cascon/workshops/mon.shtml">
			<presenter name="Peter Moogk"/>
			<presenter name="Rupam Kuehner"/>
			<presenter name="Seng Phung-Lu"/>
		</presentation>
	</event> 
	<event startdate="2005-09-19" enddate="2005-09-19"
		organization="Java Teknolojileri Derneği"
		link="http://java.org.tr/"
		logo="images/javateknolojileridernegi.gif">
		<presentation type="Presentation"
			title="Eclipse Web Tools Platform Projesi (Turkish)"
			link="http://java.org.tr/seminer.jsp?k=15">
			<presenter name="Gorkem Ercan"/>
		</presentation>
	</event> 
	<event startdate="2005-09-28" enddate="2005-09-28"
		organization="Java Teknolojileri Derneği"
		link="http://java.org.tr/"
		logo="images/javateknolojileridernegi.gif">
		<presentation type="Presentation"
			title="Eclipse için plug-in geliştirmek (Turkish)"
			link="http://java.org.tr/seminer.jsp?k=16">
			<presenter name="Gorkem Ercan"/>
		</presentation>
	</event> 
	<event startdate="2005-10-24" enddate="2005-10-24"
		organization="Free Software and Open Source Symposium"
		link="http://cs.senecac.on.ca/sos/2005/">
		<presentation type="Presentation"
			title="Teaching Web and J2EE Development with Eclipse"
			link="http://cs.senecac.on.ca/soss/2005/presentations/lawrence-jeff.php">
			<presenter name="Jeffrey Liu"/>
			<presenter name="Lawrence Mandel"/>
		</presentation>
	</event> 
	<event startdate="2005-10-11" enddate="2005-10-12"
		organization="BEA World 2005 - London"
		link="http://www.bea.com/beaworld/uk/index.jsp?PC=12EMWP"
		logo="images/beaworld2005.gif">
		<presentation type="Presentation"
			title="Eclipse Web Tool Platform Overview"
			link="http://secure.beaworld2005.com/uk/index.cfm?fuseaction=content.Agenda&amp;day=2">
			<presenter name="Naci Dai"/>
		</presentation>
	</event> 
	<event startdate="2005-10-18" enddate="2005-10-19"
		organization="BEA World 2005 - Prague"
		link="http://www.bea.com/beaworld/cz/index.jsp?PC=12EMWP"
		logo="images/beaworld2005.gif">
		<presentation type="Presentation"
			title="Eclipse Web Tool Platform Overview"
			link="http://secure.beaworld2005.com/cz/index.cfm?fuseaction=content.Agenda&amp;day=2">
			<presenter name="Naci Dai"/>
		</presentation>
	</event>
</events>
