<?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="2006-09-06" enddate="2006-09-08"
		organization="Eclipse World"
		link="http://www.eclipseworld.net/"
		logo="images/EclipseWorld-129.gif">
		<presentation type="Tutorial"
			link="http://www.eclipseworld.net/wednesday.htm"
			title="Develop Better J2EE Applications With the Web Tools Platform">
			<presenter name="Christopher M. Judd"/>
		</presentation>
		<presentation type="Tutorial"
			link="http://www.eclipseworld.net/wednesday.htm"
			title="Callisto Boot Camp: Ten Projects. One Day.">
			<presenter name="Instructor TBA"/>
		</presentation>
		<presentation type="Tutorial"
			link="http://www.eclipseworld.net/wednesday.htm"
			title="Building XSLT Applications With Eclipse">
			<presenter name="Doug Tidwell"/>
		</presentation>
		<presentation type="Class"
			link="http://www.eclipseworld.net/thursday_am.htm"
			title="Quick Tour of the Eclipse Web Tools Platform">
			<presenter name="Arthur Ryman"/>
		</presentation>
		<presentation type="Class"
			link="http://www.eclipseworld.net/thursday_am.htm"
			title="Leveraging JSF Components">
			<presenter name="Max Katz"/>
		</presentation>
		<presentation type="Class"
			link="http://www.eclipseworld.net/thursday_am.htm"
			title="How to Build Java Web Applications With The Web Tools Platform">
			<presenter name="Arthur Ryman"/>
		</presentation>
		<presentation type="Class"
			link="http://www.eclipseworld.net/thursday_am.htm"
			title="Interacting With Relational Databases">
			<presenter name="Christopher M. Judd"/>
		</presentation>
		<presentation type="Class"
			link="http://www.eclipseworld.net/thursday_pm.htm"
			title="Facing JavaServer Faces Development With JSF Tools">
			<presenter name="Jonas Jacobi"/>
		</presentation>
		<presentation type="Class"
			link="http://www.eclipseworld.net/thursday_pm.htm"
			title="Consuming and Producing Web Services With Web Tools">
			<presenter name="Christopher M. Judd"/>
		</presentation>
		<presentation type="Class"
			link="http://www.eclipseworld.net/friday_am.htm"
			title="Developing Java Web Services With the Web Tools Platform">
			<presenter name="Arthur Ryman"/>
		</presentation>
		<presentation type="Class"
			link="http://www.eclipseworld.net/friday_am.htm"
			title="Developing Rich Applications With JSF and AJAX">
			<presenter name="Max Katz"/>
		</presentation>
		<presentation type="Class"
			link="http://www.eclipseworld.net/friday_am.htm"
			title="Extending the Web Tools Platform With Ant and PDE">
			<presenter name="Hakeem Shittu"/>
		</presentation>
	</event>
	<event startdate="2006-06-12" enddate="2006-06-12"
		organization="Eclipse Webinars"
		link="http://www.eclipse.org/callisto/webinars.php"
		logo="http://www.eclipse.org/artwork/images/eclipse_pos_logo_fc_sm.jpg">
		<presentation type="Webinar"
			link="http://www.eclipse.org/callisto/webinars.php"
			title="Developing and Profiling Web Services">
			<presenter name="Kathy Chan"/>
			<presenter name="Valentina Popescu"/>
		</presentation>
	</event>
	<event startdate="2006-06-04" enddate="2006-06-08"
		organization="IBM Rational Software Development Conference 2006"
		link="https://1bosweb3.conferon.com/Events/Rational/RSDC2006/Agenda/agenda_main_page.cfm"
		logo="images/ibmrationalconference2006.gif">
		<presentation type="Long Talk"
			link="https://1bosweb3.conferon.com/Events/Rational/RSDC2006/Agenda/agenda_by_track.cfm?track=OC&amp;#OC02"
			title="The Eclipse Web Tools Platform Project: Supporting Open Standards with Open Source Tools">
			<presenter name="Arthur Ryman"/>
		</presentation>
	</event>
	<event startdate="2006-05-16" enddate="2006-05-19"
		organization="JavaOne 2006"
		link="http://java.sun.com/javaone/sf/"
		logo="images/javaone2006.jpg">
		<presentation type="Long Talk"
			link="https://www28.cplan.com/javaone06_cv_124_1/session_details.jsp?isid=278160&amp;ilocation_id=124-1&amp;ilanguage=english"
			title="Create, Test, and Consume Web Services With the Eclipse Web Tools Platform">
			<presenter name="Jeffrey Liu"/>
		</presentation>
	</event>
	<event startdate="2006-05-08" enddate="2006-05-11"
		organization="Eclipse Forum Europe 2006"
		link="http://www.eclipseforumeurope.com/"
		logo="images/eclipseforumeurope2006.gif">
		<presentation type="Long Talk"
			link="http://www.eclipseforumeurope.com/konferenzen/psecom,id,493,track,3,nodeid,,_language,uk.html#session-dev2"
			title="Eclipse Web Tools 1.5 and AJAX">
			<presenter name="Jochen Krause"/>
		</presentation>
	</event>
	<event startdate="2006-03-20" enddate="2006-03-24"
		organization="EclipseCon 2006"
		link="http://www.eclipsecon.org"
		logo="images/eclipsecon2006.gif">
		<presentation type="Recommended Track"
			link="http://www.eclipsecon.org/2006/Sub.do?id=338"
			title="Web Tools Track">
			<presenter name=""/>
		</presentation>
		<presentation type="Project Sprint"
			title="WTP Project Sprint - Mon., Mar. 20, 6:30-8:30pm, Rm 203">
			<presenter name=""/>
		</presentation>
		<presentation type="Tutorial"
			link="http://www.eclipsecon.org/2006/Sub.do?id=8"
			title="Java Web Application Development with Eclipse WTP">
			<presenter name="Naci Dai"/>
			<presenter name="Lawrence Mandel"/>
			<presenter name="Arthur Ryman"/>
		</presentation>
		<presentation type="Tutorial"
			link="http://www.eclipsecon.org/2006/Sub.do?id=186"
			title="Extending the XML and JSP editors from the WTP Project">
			<presenter name="Nitin Dahyabhai"/>
			<presenter name="David Williams"/>
		</presentation>
		<presentation type="Tutorial"
			link="http://www.eclipsecon.org/2006/Sub.do?id=241"
			title="Extending the Web Tools Platform, Part 1">
			<presenter name="Tim deBoer"/>
			<presenter name="Gorkem Ercan"/>
			<presenter name="Konstantin Komissarchik"/>
		</presentation>
		<presentation type="Tutorial"
			link="http://www.eclipsecon.org/2006/Sub.do?id=180"
			title="Extending the Web Tools Platform, Part 2">
			<presenter name="Chuck Bridgham"/>
			<presenter name="John Lanuti"/>
		</presentation>
		<presentation type="Tutorial"
			link="http://www.eclipsecon.org/2006/Sub.do?id=103"
			title="Problem Determination of J2EE Web Applications Using the Eclipse Test and Performance Tools Platform (TPTP)">
			<presenter name="Paul Slauenwhite"/>
		</presentation>
		<presentation type="Tutorial"
			link="http://www.eclipsecon.org/2006/Sub.do?id=130"
			title="Data Tools Platform Project Tutorial">
			<presenter name="Hui Cao"/>
			<presenter name="Rob Cernich"/>
			<presenter name="Linda Chan"/>
			<presenter name="Brian Payton"/>
		</presentation>
		<presentation type="Long Talk"
			link="http://www.eclipsecon.org/2006/Sub.do?id=49"
			title="What's New in Web Tools 1.0 and 1.5">
			<presenter name="Arthur Ryman"/>
		</presentation>
		<presentation type="Long Talk"
			link="http://www.eclipsecon.org/2006/Sub.do?id=74"
			title="Build JavaServer Faces applications with the JSF Tools Project">
			<presenter name="Jean Choi"/>
			<presenter name="Jonas Jacobi"/>
			<presenter name="Raghu Srinivasan"/>
		</presentation>
		<presentation type="Long Talk"
			link="http://www.eclipsecon.org/2006/Sub.do?id=118"
			title="Consuming and producing web services with WST and JST">
			<presenter name="Christopher M. Judd"/>
		</presentation>
		<presentation type="Long Talk"
			link="http://www.eclipsecon.org/2006/Sub.do?id=210"
			title="Using And Extending the Eclipse Web Tools Platform (WTP)">
			<presenter name="Hakeem Shittu"/>
		</presentation>
		<presentation type="Long Talk"
			link="http://www.eclipsecon.org/2006/Sub.do?id=63"
			title="EJB 3.0 Persistence and the Dali EJB ORM Project">
			<presenter name="Neil Hauge"/>
			<presenter name="Mike Keith"/>
			<presenter name="Shaun Smith"/>
		</presentation>
		<presentation type="Long Talk"
			link="http://www.eclipsecon.org/2006/Sub.do?id=105"
			title="Web Services component level tracing with TPTP">
			<presenter name="Valentina Popescu"/>
		</presentation>
		<presentation type="Long Talk"
			link="http://www.eclipsecon.org/2006/Sub.do?id=258"
			title="Developing data tools with the DTP SQL models and parsers">
			<presenter name="Brian Payton"/>
		</presentation>
		<presentation type="Short Talk"
			link="http://www.eclipsecon.org/2006/Sub.do?id=32"
			title="Authoring in Eclipse">
			<presenter name="Chris Aniszczyk"/>
			<presenter name="Lawrence Mandel"/>
		</presentation>
		<presentation type="Short Talk"
			link="http://www.eclipsecon.org/2006/Sub.do?id=179"
			title="Eclipse and Apache Derby - a powerful combination for building database applications with ease">
			<presenter name="Rajesh Kartha"/>
		</presentation>
		<presentation type="Short Talk"
			link="http://www.eclipsecon.org/2006/Sub.do?id=413"
			title="Ajax, OpenLaszlo and Eclipse">
			<presenter name="Max Carlson"/>
		</presentation>
		<presentation type="Short Talk"
			link="http://www.eclipsecon.org/2006/Sub.do?id=454"
			title="The AJAX Toolkit Framework">
			<presenter name="Craig Becker"/>
		</presentation>
		<presentation type="Short Talk"
			link="http://www.eclipsecon.org/2006/Sub.do?id=148"
			title="Managing APIs with Eclipse API Scanner">
			<presenter name="Jeffrey Liu"/>
		</presentation>
	</event>
	<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>
