<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"><channel><title>Eclipse Web Tools Platform Project: News</title><link>http://www.eclipse.org/webtools/</link><description>
					This RSS feed contains the latest news from the Eclipse Web Tools Platform (WTP) project. The 
                    Eclipse WTP project contains Web tools and frameworks for the Eclipse platform.
				</description><language>en-us</language><copyright>
					Copyright (c) 2001, 2004 IBM Corporation and others.
                    All rights reserved. This program and the accompanying materials
                    are made available under the terms of the Eclipse Public License v1.0
                    which accompanies this distribution, and is available at
                    http://www.eclipse.org/legal/epl-v10.html
  
                    Contributors:
                    IBM Corporation - initial API and implementation
				</copyright><lastBuildDate>Sat, 27 Jan 2007 16:42:10-05:00</lastBuildDate><category>Eclipse Web Tools Platform (WTP) Project: News</category><item><title>Reminder: EclipseCon short talks and demo proposals due January 31st</title><pubDate>Tue, 9 Jan 2007 19:00:00 UTC</pubDate><link>http://www.eclipsecon.org</link><description>
		Short talks and demos are a great way to get the word out about what you're doing,
		and preparation is easy.
	</description></item><item><title>The Development Power of Open Source AJAX Tooling Article Published</title><pubDate>Wed, 20 Dec 2006 19:00:00 UTC</pubDate><link>http://java.sys-con.com/read/313546.htm</link><description>
		
			The Development Power of Open Source AJAX Tooling
		
		article by Kevin Sawicki published on
		
			Java Developer's Journal
		
		.
	</description></item><item><title>Valentin Baciu elected as WTP committer</title><pubDate>Wed, 20 Dec 2006 19:00:00 UTC</pubDate><link/><description>
		Congratulations to our newest committer,
		
			Valentin Baciu
		
		from IBM. Valentin is part of the XML Web services team.
	</description></item><item><title>Consuming Web Services Using Eclipse Web Tools</title><pubDate>Mon, 27 Nov 2006 12:00:00 UTC</pubDate><link>http://www.eclipsereview.com/issues/eclipsereview_200612.pdf</link><description>
    	
			Consuming Web Services Using Eclipse Web Tools
		
		article by 
		
			Christopher Judd 
		
		published in
		
			Eclipse Review
		
		.
    </description></item><item><title>WTP 1.5.2 Released!</title><pubDate>Tue, 31 Oct 2006 12:00:00 UTC</pubDate><link>http://download.eclipse.org/webtools/downloads/drops/R1.5/R-1.5.2-200610261841/</link><description>
        WTP 1.5.2 has been released to fix serious bugs and performance problems
        that were found too late to fix in the previous maintenance
        release. Those with 1.5.1 already installed need only use
        Update Manager to "find updates for currently installed features".
        
        All-in-one zip files, SDKs, and minimal runtimes are also
        available from the download site.
    </description></item><item><title>Java Web Application Development with Eclipse published on Safari Rough Cuts</title><pubDate>Fri, 13 Oct 2006 17:50:00 UTC</pubDate><link>http://my.safaribooksonline.com/0321396855</link><description>
		
		
		Java Web Application Development with Eclipse, the latest book in the Eclipse 
		series, by Naci Dai, 
		Lawrence Mandel, and 
		Arthur Ryman is now available
		in rough form from Safari Rough Cuts.
	</description></item><item><title>HTTP Connection Tracer diagnosic utility posted</title><pubDate>Tue, 3 Oct 2006 18:50:00 UTC</pubDate><link>http://www.eclipse.org/webtools/development/httptracerutility/index.html</link><description>
		Having trouble with network connectivity in Eclipse/WTP? Try the new
		HTTP connection tracer diagnostic utility.
	</description></item><item><title>WTP 1.5.1 Released as part of Callisto update pack</title><pubDate>Fri, 29 Sep 2006 20:30:00 UTC</pubDate><link>http://download.eclipse.org/webtools/downloads/drops/R1.5/R-1.5.1-200609230508/</link><description>
		WTP 1.5.1
		was released as part of the fall Callisto maintenance release. WTP Zips and all-in-one
		bundles for frequently downloaded configurations are also available.
	</description></item><item><title>EclipseWorld 2006 Presentations Available</title><pubDate>Thu, 7 Sep 2006 20:30:00 UTC</pubDate><link>http://www.eclipse.org/webtools/community/presentations.html</link><description>
		EclipseWorld 2006
		is currently underway in Cambridge, MA, with plenty of WTP
		content. Check out the
		
			WTP Presentation Archive
		
		for EclipseWorld 2006 material, including programming examples.
		Presenters are invited to post their material to the WTP archive
		by attaching files to
		
			bug 126597.
		
	</description></item><item><title>WTP Website Owner and Website Developers Needed</title><pubDate>Tue, 8 Aug 2006 17:00:00 UTC</pubDate><link>https://bugs.eclipse.org/bugs/show_bug.cgi?id=153085</link><description>
		WTP is looking for people willing to help maintain and enhance
		our website, including:
		
			
			
			
			
			
		
		If you're interested in helping or leading this effort, please
		comment on
		
			bug 153085
		
		or e-mail the WTP dev list - wtp-dev@eclipse.org.
	</description></item><item><title>Sybase Contributes Graphical Page Designer to WTP</title><pubDate>Tue, 8 Aug 2006 17:00:00 UTC</pubDate><link>https://bugs.eclipse.org/bugs/show_bug.cgi?id=152533</link><description>
		Sybase has contributed a graphical page designer for HTML, JSP
		and JSF pages to WTP. The initial contribution can be download
		from
		
			bug 152533
		
		.
	</description></item><item><title>Bob Goodman elected as WTP committer</title><pubDate>Tue, 8 Aug 2006 17:00:00 UTC</pubDate><link/><description>
		Congratulations to our newest committer,
		
			Bob Goodman
		
		from IBM. Bob is the new ATF project lead and will work closely
		with the WTP PMC to align ATF with WTP.
	</description></item><item><title>WTP voted top Eclipse project by Eclipse Magazine</title><pubDate>Wed, 12 Jul 2006 18:15:00 UTC</pubDate><link>http://www.eclipse-magazin.de/umfrage/em/rc_2006/index.xhtml</link><description>
		WTP has been recognized with the
		
			Eclipse Magazine Reader's Choice 2006 award
		
		for best Eclipse top level project. Congratulations to all the
		WTP committers and contributors!
	</description></item><item><title>WTP 1.5 Released!</title><pubDate>Fri, 30 Jun 2006 20:30:00 UTC</pubDate><link>http://www.eclipse.org/webtools/releases/1.5/</link><description>
		WTP 1.5 is now available. You can read about the release and
		find out how to get it
		here
		.
	</description></item><item><title>Cameron Bateman elected as WTP committer</title><pubDate>Tue, 27 Jun 2006 17:50:00 UTC</pubDate><link/><description>
		Congratulations to our newest committer,
		
			Cameron Bateman
		
		from Oracle. Cameron Bateman is a prolific contributor to the
		JSF Tools project. He is the author of the JSF 1.1 EL validation
		functionality and contributed the Design-time Application
		Manager Framework as part of implementing the above
		functionality. He has also raised and fixed numerous issues in
		the JSF Tools Project.
	</description></item><item><title>WTP 1.5 RC6 Declared!</title><pubDate>Fri, 23 Jun 2006 04:44:00 UTC</pubDate><link>http://download.eclipse.org/webtools/committers/drops/S-1.5RC6-200606230444/</link><description>
		WTP 1.5 RC6 is available for
		
			download
		
		. It will likely be the final release candidate.
	</description></item><item><title>Peter Moogk elected as WTP committer</title><pubDate>Tue, 20 Jun 2006 14:20:00 UTC</pubDate><link/><description>
		Congratulations to our newest committer,
		
			Peter Moogk
		
		from IBM. Peter built the Environment Command Framework, was
		instrumental in the convergance of the Web service and J2EE
		tools teams' wizard frameworks and is responsible for the
		internet proxy page.
	</description></item><item><title>WTP 1.5 RC5 Declared!</title><pubDate>Fri, 16 Jun 2006 16:50:00 UTC</pubDate><link>http://download2.eclipse.org/webtools/downloads/drops/S-1.5RC5-200606161055/</link><description>
		WTP 1.5 RC5 is available for
		
			download
		
		!
	</description></item><item><title>WTP 1.5 RC4 Declared!</title><pubDate>Wed, 31 May 2006 16:50:00 UTC</pubDate><link>http://download2.eclipse.org/webtools/downloads/drops/S-1.5RC4-200605310507/</link><description>
		WTP 1.5 RC4 is available for
		
			download
		
		!
	</description></item><item><title>Developing and Profiling Web Services Webinar</title><pubDate>Fri, 26 May 2006 16:50:00 UTC</pubDate><link>http://www.eclipse.org/callisto/webinars.php</link><description>
		Join the WTP/TPTP Eclipse webinar on June 12 from
		11:00am-12:00pmET.
		
			Click here
		
		to register.
	</description></item><item><title>WTP 1.5 RC3 Declared!</title><pubDate>Thu, 18 May 2006 16:50:00 UTC</pubDate><link>http://download.eclipse.org/webtools/downloads/drops/S-1.5RC3-200605182217/</link><description>
		WTP 1.5 RC3 is available for
		
			download
		
		!
	</description></item><item><title>Bringing Together Eclipse, WTP, Struts, and Hibernate Article Published</title><pubDate>Wed, 10 May 2006 19:51:00 UTC</pubDate><link>http://java.sys-con.com/read/216320.htm</link><description>
		
			Bringing Together Eclipse, WTP, Struts, and Hibernate
		
		article by Boris Minkin published on
		
			Java Developer's Journal
		
		.
	</description></item><item><title>WTP 1.5 RC2 Declared!</title><pubDate>Fri, 5 May 2006 18:36:00 UTC</pubDate><link>http://download.eclipse.org/webtools/downloads/drops/S-1.5RC2-200605051426/</link><description>
		WTP 1.5 RC2 is available for
		
			download
		
		!
	</description></item><item><title>WTP 1.0.2 Released!</title><pubDate>Thu, 27 Apr 2006 21:32:00 UTC</pubDate><link>http://www.eclipse.org/webtools/releases/1.0.2/</link><description>
		WTP 1.0.2 is now available! Information about the release is
		available on the
		
			WTP 1.0.2 release page
		
		.
	</description></item><item><title>WTP 1.5 RC1a Declared!</title><pubDate>Fri, 21 Apr 2006 07:53:00 UTC</pubDate><link>http://download.eclipse.org/webtools/downloads/drops/S-1.5RC1a-200604210753/</link><description>
		WTP 1.5 RC1a is available for
		
			download
		
		!
	</description></item><item><title>Creating Database Web Applications with Eclipse Article Published</title><pubDate>Mon, 10 Apr 2006 19:35:00 UTC</pubDate><link>http://www.eclipse.org/articles/Article-EclipseDbWebapps/article.html</link><description>
		
			Creating Database Web Applications with Eclipse
		
		article by Stephen Schaub published on
		
			Eclipse Corner
		
		.
	</description></item><item><title>Develop Web Applications FASTER with WTP Article Published</title><pubDate>Mon, 27 Mar 2006 18:00:00 UTC</pubDate><link>http://www.eclipsereview.com/issues/eclipsereview_200603.pdf?page=25</link><description>
		
			Develop Web Applications FASTER with WTP
		
		article by
		
			Tim Wagner
		
		published in
		
			Eclipse Review
		
		.
	</description></item><item><title>ATF Initial Contribution Available for Evaluation</title><pubDate>Wed, 22 Mar 2006 01:00:00 UTC</pubDate><link>https://bugs.eclipse.org/bugs/show_bug.cgi?id=132238</link><description>
		The source code for the initial IBM contribution to the AJAX
		Toolkit Framework incubator has been posted to bug
		
			132238
		
		by project lead Craig Becker. Potential contributors are
		encouraged to download and evaluate this code now. Users can
		download a binary version that runs on WTP 1.0.1 from
		
			alphaWorks
		
		where demos are also available.
	</description></item><item><title>WTP Project Sprint - Mon. Mar. 20, 6:30-8:30pm</title><pubDate>Sun, 19 Mar 2006 06:20:00 UTC</pubDate><link>http://www.eclipse.org/webtools/</link><description>
		Join the WTP team at EclipseCon for the WTP project sprint. Hear
		first-hand from those leading and developing the project about
		WTP's achievements during the past year and direction for the
		upcoming 1.5 release.
		
		Monday, March 20, 6:30-8:30pm, EclipseCon, Room 203.
	</description></item><item><title>WTP Logo Unveiled</title><pubDate>Thu, 16 Mar 2006 19:41:00 UTC</pubDate><link>http://www.eclipse.org/webtools/</link><description>
		
		
		WTP has a new look in a new logo. Thanks to Artur Filipiak for
		creating and contributing the new WTP logo.
	</description></item><item><title>WTP 1.0.1 Released!</title><pubDate>Tue, 28 Feb 2006 21:15:00 UTC</pubDate><link>http://www.eclipse.org/webtools/releases/1.0.1/</link><description>
		WTP 1.0.1 is now available! Information about the release is
		available on the
		
			WTP 1.0.1 release page
		
		.
	</description></item><item><title>Developing Web Services Eclipse Web Tools Project Article Published</title><pubDate>Tue, 21 Feb 2006 17:00:00 UTC</pubDate><link>http://java.sys-con.com/read/180402.htm</link><description>
		
			Developing Web Services Eclipse Web Tools Project
		
		article by Boris Minkin published on
		
			Java Developer's Journal
		
		.
	</description></item><item><title>Eclipse WTP User Experience Study Announced</title><pubDate>Tue, 21 Feb 2006 17:00:00 UTC</pubDate><link>http://ws.cs.ubc.ca/~lkf/antoine/</link><description>
		In partnership with IBM, the Department of Computer Science at
		the University of British Columbia is running a study to improve
		the Eclipse IDE user experience. Help improve the WTP user
		experience by
		
			participating in the study
		
		.
	</description></item><item><title>EclipseCon Web Tools Track Announced</title><pubDate>Mon, 20 Feb 2006 22:28:00 UTC</pubDate><link>http://www.eclipsecon.org/2006/Sub.do?id=338</link><description>
		
			
		
		
		The
		
			Web Tools Track
		
		has been announced for EclipseCon 2006. The track includes talks
		and tutorials about WTP and related to Web development.
	</description></item><item><title>Eclipse TPTP Strengthens Integration with BIRT and WTP</title><pubDate>Wed, 8 Feb 2006 21:00:00 UTC</pubDate><link>http://www.eclipse.org/tptp/groups/Marketing/pressroom/pressreleases/BIRT%20and%20WTP.htm</link><description>
		Eclipse TPTP Strengthens Integration with BIRT and WTP. Read the
		press release
		
			here
		
		.
	</description></item><item><title>Authoring with Eclipse Article Published on Eclipse Corner</title><pubDate>Tue, 31 Jan 2006 19:19:00 UTC</pubDate><link>http://www.eclipse.org/articles/Article-Authoring-With-Eclipse/AuthoringWithEclipse.html</link><description>
		
			Authoring with Eclipse
		
		article by Chris Aniszczyk and Lawrence Mandel published on
		
			Eclipse Corner
		
		. This article features WTP's XML tools.
	</description></item><item><title>WTP Logo Contest</title><pubDate>Fri, 23 Dec 2005 00:00:00 UTC</pubDate><link>http://www.eclipse.org/webtools/wtplogocontest.php</link><description>
		WTP's logo (the default screen seen on the WTP home page) is in
		need of an update. Announcing the WTP logo contest! Submit your
		logos for WTP and comment and vote on existing submissions on
		
			bug 122593
		
		. Submission deadline is Jan. 31. Voting deadline is Feb. 16.
	</description></item><item><title>WTP 1.0 Release</title><pubDate>Fri, 23 Dec 2005 00:00:00 UTC</pubDate><link>http://www.eclipse.org/webtools/releases/1.0/</link><description>
		WTP 1.0 is now available. You can read about the release and
		find out how to get it
		here
		.
	</description></item><item><title>WTP 1.0 Release</title><pubDate>Tue, 20 Dec 2005 00:00:00 UTC</pubDate><link>http://www.eclipse.org/webtools/releases/1.0/</link><description>
		The release of WTP 1.0 is planned for 2005-12-23. You can read
		about the release and get early access to it
		here
		.
	</description></item><item><title>WTP 1.0 Featured on InfoWorld</title><pubDate>Tue, 20 Dec 2005 00:00:00 UTC</pubDate><link>http://www.infoworld.com/article/05/12/19/HNeclipsewebtools_1.html</link><description>
		WTP 1.0 is featured on InfoWorld! Read the article
		
			here
		
		.
	</description></item><item><title>WTP 1.0 Featured on Business Wire</title><pubDate>Tue, 20 Dec 2005 00:00:00 UTC</pubDate><link>http://home.businesswire.com/portal/site/google/index.jsp?ndmViewId=news_view&amp;newsId=20051219005407&amp;newsLang=en</link><description>
		WTP 1.0 is featured on Business Wire! Read the article
		
			here
		
		.
	</description></item><item><title>WTP 1.0 Featured on eWeek</title><pubDate>Tue, 20 Dec 2005 00:00:00 UTC</pubDate><link>http://www.eweek.com/article2/0,1895,1903446,00.asp</link><description>
		WTP 1.0 is featured on eWeek! Read the article
		
			here
		
		.
	</description></item><item><title>Build rich Internet applications tutorial Published on developerWorks</title><pubDate>Fri, 16 Dec 2005 00:00:00 UTC</pubDate><link>http://www.ibm.com/developerworks/edu/os-dw-os-laszlo-i.html</link><description>
		
			Build rich Internet applications
		
		tutorial by Christopher Judd published on
		
			developerWorks
		
		.
	</description></item><item><title>WTP 1.0 RC5 available for download</title><pubDate>Fri, 16 Dec 2005 00:00:00 UTC</pubDate><link/><description>
		WTP 1.0 RC5 is available for
		
			download
		
		!
	</description></item><item><title>WTP 1.0 RC4 available for download</title><pubDate>Mon, 12 Dec 2005 00:00:00 UTC</pubDate><link/><description>
		WTP 1.0 RC4 is available for
		
			download
		
		!
	</description></item><item><title>WTP 1.0 RC3 available for download</title><pubDate>Sun, 11 Dec 2005 00:00:00 UTC</pubDate><link/><description>
		WTP 1.0 RC3 is available for
		
			download
		
		!
	</description></item><item><title>WTP 1.0 RC2 available for download</title><pubDate>Fri, 9 Dec 2005 00:00:00 UTC</pubDate><link/><description>
		WTP 1.0 RC2 is available for
		
			download
		
		!
	</description></item><item><title>WTP 1.0 RC1 available for download</title><pubDate>Fri, 2 Dec 2005 00:00:00 UTC</pubDate><link/><description>
		WTP 1.0 RC1 is available for
		
			download
		
		!
	</description></item><item><title>WTP 1.0 M9 available for download</title><pubDate>Wed, 23 Nov 2005 00:00:00 UTC</pubDate><link/><description>
		WTP 1.0 M9 is available for
		
			download
		
		! A description of New and Noteworthy features can be found
		
			here
		
		.
	</description></item><item><title>Creating Web Applications with the Eclipse Web Tools Project Article Published on Java Developer's Journal</title><pubDate>Tue, 22 Nov 2005 00:00:00 UTC</pubDate><link>http://java.sys-con.com/read/152270.htm</link><description>
		
			Creating Web Applications with the Eclipse Web Tools Project
		
		article by Boris Minkin published on
		
			Java Developer's Journal
		
		.
	</description></item><item><title>John Lanuti and Amy Wu elected as WTP committers</title><pubDate>Thu, 17 Nov 2005 00:00:00 UTC</pubDate><link/><description>
		Congratulations to our newest committers,
		
			John Lanuti
		
		and
		
			Amy Wu
		
		, both from IBM. John already works on many aspects of WTP
		including the EJB bean and servlet wizards, flexible component
		API, and server API. Amy is also very involved in WTP working on
		new file wizard templates and the configuration extension
		points, moving WTP editors to the "hyperlink" API, opening and
		fixing many, many bugs, and responding to questions on the
		newsgroup.
	</description></item><item><title>Persisting EMF models with WTP Published on Eclipse Corner</title><pubDate>Wed, 12 Oct 2005 00:00:00 UTC</pubDate><link>http://www.eclipse.org/articles/Article-WTP-Persisting-EMF/persisting.html</link><description>
		
			Persisting EMF models with WTP
		
		article by Daniel Rohe published on
		
			Eclipse Corner
		
		.
	</description></item><item><title>Overview of the Eclipse Web Tools Platform Published on dev2dev</title><pubDate>Thu, 6 Oct 2005 00:00:00 UTC</pubDate><link>http://dev2dev.bea.com/pub/a/2005/09/eclipse_web_tools_platform.html</link><description>
		
			Overview of the Eclipse Web Tools Platform
		
		article by Tim Wagner, Ted Bashor, Paul Meijer, and Pieter
		Humphrey published on
		dev2dev
		.
	</description></item><item><title>Eclipse Web Tools Article Published on OnJava.com</title><pubDate>, NaN Jun 200510  UTC</pubDate><link>http://www.onjava.com/pub/a/onjava/2005/10/05/eclipse-web-tools.html</link><description>
		
			Eclipse Web Tools
		
		article by Jeffrey Liu and Lawrence Mandel published on
		
			O'Reilly OnJava.com
		
		.
	</description></item><item><title>WTP 1.0 M8 available for download</title><pubDate>Fri, 23 Sep 2005 00:00:00 UTC</pubDate><link/><description>
		WTP 1.0M8 is available for
		
			download
		
		! A description of New and Noteworthy features can be found
		
			here
		
		.
	</description></item><item><title></title><pubDate>Sun, 11 Sep 2005 00:00:00 UTC</pubDate><link/><description>
		
			Building a CMP Based School Schedule Web Application
			tutorial
		
		posted.
	</description></item><item><title></title><pubDate>Tue, 6 Sep 2005 00:00:00 UTC</pubDate><link/><description>
		
			Building Web Applications with Eclipse, WTP, and Derby
		
		article by Susan L. Cline published on
		
			developerWorks
		
		.
	</description></item><item><title></title><pubDate>Fri, 26 Aug 2005 00:00:00 UTC</pubDate><link/><description>
		The
		
			JavaServer Faces Tools Project
		
		has been created!. The Creation Review was held today and the
		project was approved. The project will incubate during the WTP
		1.0 development cycle and then become a component of the JST
		subproject in WTP 1.5.
	</description></item><item><title></title><pubDate>Wed, 10 Aug 2005 00:00:00 UTC</pubDate><link/><description>
		WTP 0.7 can now be
		
			installed
		
		from the Eclipse.org update site
	</description></item><item><title></title><pubDate>Fri, 29 Jul 2005 00:00:00 UTC</pubDate><link/><description>
		The WTP 0.7 release is available for
		
			download
		
		!
	</description></item><item><title></title><pubDate>Thu, 28 Jul 2005 00:00:00 UTC</pubDate><link/><description>
		
			WTP 0.7RC5
		
		is available for download.
	</description></item><item><title></title><pubDate>Wed, 27 Jul 2005 00:00:00 UTC</pubDate><link/><description>
		
			WTP 0.7RC4
		
		is available for download.
	</description></item><item><title></title><pubDate>Mon, 25 Jul 2005 00:00:00 UTC</pubDate><link/><description>
		Check out the recent
		
			articles
		
		featuring WTP in Dr. Dobb's Journal and Java Developer Journal.
	</description></item><item><title></title><pubDate>Mon, 25 Jul 2005 00:00:00 UTC</pubDate><link/><description>
		Congratulations to our newest committer,
		
			Dirk le Roux
		
		, Versant! Dirk is working on the Data Tools components of WTP
		and has contributed support for MySQL.
	</description></item><item><title></title><pubDate>Mon, 25 Jul 2005 00:00:00 UTC</pubDate><link/><description>
		
			WTP 0.7RC3
		
		is available for download. RC3 is built with the new JEM 1.1
		release making all of the dependencies Release builds.
	</description></item><item><title></title><pubDate>Fri, 22 Jul 2005 00:00:00 UTC</pubDate><link/><description>
		
			WTP 0.7RC2
		
		is available for download. RC2 includes fixes for many critical
		and annoying bugs.
	</description></item><item><title></title><pubDate>Fri, 15 Jul 2005 00:00:00 UTC</pubDate><link/><description>
		
			WTP 0.7RC1
		
		is available for download. RC1 contains UI polish and important
		bug fixes.
	</description></item><item><title></title><pubDate>Fri, 1 Jul 2005 00:00:00 UTC</pubDate><link/><description>
		
			WTP Milestone M5
		
		is available for download. M5 updates WTP to work with the
		Eclipse 3.1 release and contains numerous
		
			enhancements and bug fixes
		
		.
	</description></item><item><title></title><pubDate>Wed, 29 Jun 2005 00:00:00 UTC</pubDate><link/><description>
		Two new committers were recently elected to WTP.
		
			Larry Isaacs
		
		, SAS, is contributing to the Tomcat server support and
		
			Susan Yeshin
		
		, IBM, is writing the online Help. Congratulations Larry and
		Susan!
	</description></item><item><title></title><pubDate>Wed, 1 Jun 2005 00:00:00 UTC</pubDate><link/><description>
		The WTP project is hosting a series of
		
			component open houses
		
		. These open houses are aimed at those looking to extend the
		platform provided by the WTP project.
	</description></item><item><title></title><pubDate>Mon, 16 May 2005 00:00:00 UTC</pubDate><link/><description>
		The WTP
		
			contributors
		
		page has been expanded and revamped. Now all contributors get
		their own page. If you currently have a page, please review it
		for accuracy and completeness. If someone you know deserves to
		be recognized for their contributions, send a note nominating
		them to their component lead or a PMC member.
	</description></item><item><title></title><pubDate>Mon, 9 May 2005 00:00:00 UTC</pubDate><link/><description>
		
		
		
			Apache Geronimo server adapter
		
		available for M4!. Now you can use WTP 1.0 M4 to develop Web
		applications for Apache Geronimo.
	</description></item><item><title></title><pubDate>Sat, 30 Apr 2005 00:00:00 UTC</pubDate><link/><description>
		
			WTP Milestone M4
		
		available for download! M4 updates WTP to work with Eclipse
		3.1M6 and contains numerous enhancements and bug fixes.
	</description></item><item><title></title><pubDate>Mon, 11 Apr 2005 00:00:00 UTC</pubDate><link/><description>
		
			WTP Presentation Archive
		
		created. This page lists WTP presentations that you can use when
		you talk about WTP. Contribute your own WTP presentations too.
	</description></item><item><title></title><pubDate>Sat, 26 Feb 2005 00:00:00 UTC</pubDate><link/><description>
		
			WTP Milestone M3
		
		available for download! M3 contains Web services and ejb tools,
		and flexible project layouts.
	</description></item><item><title></title><pubDate>Wed, 23 Feb 2005 00:00:00 UTC</pubDate><link/><description>
		Six new Web service tutorials posted on the
		
			community page
		
		.
	</description></item><item><title></title><pubDate>Tue, 22 Feb 2005 00:00:00 UTC</pubDate><link/><description>
		
			
		
		
		BEA Joins Eclipse Foundation as a Board Member and Strategic
		Developer; Elected as Lead for Web Tools Platform Project.
		
			Read the complete press release here
		
		.
	</description></item><item><title></title><pubDate>Tue, 22 Feb 2005 00:00:00 UTC</pubDate><link/><description>
		
			WTP Roadmap
		
		posted. This document outlines the plan for WTP 1.0, WTP 1.1,
		and beyond.
	</description></item><item><title></title><pubDate>Mon, 21 Feb 2005 00:00:00 UTC</pubDate><link/><description>
		
			Developing the WTP with Eclipse
		
		tutorial posted. This tutorial provides an introduction to WTP
		plug-in development using Eclipse.
	</description></item><item><title></title><pubDate>Tue, 15 Feb 2005 00:00:00 UTC</pubDate><link/><description>
		
			Help Wanted
		
		page posted. If you would like to contribute to the project,
		read this page to find work items.
	</description></item><item><title></title><pubDate>Tue, 8 Feb 2005 00:00:00 UTC</pubDate><link/><description>
		
			Eclipse API Scanner
		
		posted. Learn how to describe the API of a component and scan
		plug-ins for API violations.
	</description></item><item><title></title><pubDate>Mon, 24 Jan 2005 00:00:00 UTC</pubDate><link/><description>
		
			
		
		
		The WTP team is presenting three technical sessions, a tutorial,
		and a project sprint at
		
			EclipseCon
		
		. This is a great opportunity to meet the people and learn about
		the project. Feb 28th-Mar 1st.
	</description></item><item><title></title><pubDate>Mon, 24 Jan 2005 00:00:00 UTC</pubDate><link/><description>
		
			Building a Student Schedule Web Application tutorial
		
		posted.
	</description></item><item><title></title><pubDate>Mon, 24 Jan 2005 00:00:00 UTC</pubDate><link/><description>
		XML Schema Editor demo
		
			viewlet
		
		posted.
	</description></item><item><title></title><pubDate>Mon, 24 Jan 2005 00:00:00 UTC</pubDate><link/><description>WTP site updated!</description></item><item><title></title><pubDate>Thu, 23 Dec 2004 00:00:00 UTC</pubDate><link/><description>
		
			Milestone M2
		
		available for download.
	</description></item></channel></rss>