<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
<title>WTP PMC Agenda/Minutes for January 19, 2010 Conference
Call</title>
</head>
<body>
<h1>WTP PMC Agenda/Minutes for January 19, 2010 Conference Call</h1>
<h2>Call Info</h2>
<p>Tollfree in the US: 877-421-0030 <br />
Alternate: 770-615-1247<br />
Access code: 173098# <br />
<a
	href="http://wiki.eclipse.org/images/f/f6/WTP_status_phone_access.pdf">Full
list of phone numbers</a><br />
<br />
<a
	href="http://www.timeanddate.com/worldclock/custom.html?cities=224,207,1440,107
&amp;month=01
&amp;day=05
&amp;year=2010
&amp;hour=11
&amp;min=0&amp;sec=0&amp;p1=207">Call
Time: 1600 UTC</a></p>


<h2>Attendees</h2>
<h3>PMC Members</h3>
<ul>
	<li style="margin: 0em 0.2em 0em 0em; padding: 0.0em;">David
	Williams: Y</li>
	<li style="margin: 0em 0.2em 0em 0em; padding: 0.0em;">Naci Dai: N</li>
	<li style="margin: 0em 0.2em 0em 0em; padding: 0.0em;">Raghunathan
	Srinivasan: Y</li>
	<li style="margin: 0em 0.2em 0em 0em; padding: 0.0em;">Neil Hauge:
	Y</li>
	<li style="margin: 0em 0.2em 0em 0em; padding: 0.0em;">Tim deBoer:
	Y</li>
	<li style="margin: 0em 0.2em 0em 0em; padding: 0.0em;">Kaloyan
	Raev: Y</li>
</ul>


<h2>Announcements and General Business</h2>
<ul>
	<li>EclipseCon
	<ul>
		<li>Congratulations! (and thanks)
		<ul>
			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1233">1233
			WTP Uncovered - All you need to know about building applications with
			WTP</a></li>
			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1111">1111
			Building Server-Side Eclipse based web applications</a></li>

			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1226">1226
			Java EE 6 application development, OSGi and Eclipse users</a></li>

			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1254">1254
			OSGi Enterprise for Java EE Developers</a></li>
			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1290">1290
			Apache Aries: Enterprise OSGi in Action</a></li>
			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1333">1333
			The state of the art in Spring and Grails developer tooling</a></li>
			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1352">1352
			JPA 2.0 and Dali: Developing for Java EE 6 </a></li>

			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1316">1316
			Using JPA in OSGi</a></li>

			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1372">1372
			Building JSF 2.0 Web Application with the JSF Tools Project</a></li>
			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1392">1392
			OSGi &amp; Java EE in GlassFish</a></li>
			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1125">1125
			Gemini - Helping Shape the Future of Enterprise Java</a></li>

			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1088">1088
			OSamI Tools for OSGi Application Developers</a></li>

			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1109">1109
			Teaching XSL Tools New Tricks</a></li>
			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1163">1163
			XQDT - XQuery Getting Momentum in Eclipse</a></li>
			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1413">1413
			Down the Rabbit Hole: A Single Character in the XML Editor</a></li>
			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1419">1419
			Binding EMF object to existing data models</a></li>


			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1293">1293
			Developing Eclipse Plug-ins with JavaScript</a></li>
			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1295">1295
			JavaScript Debugged</a></li>

			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1440">1440
			Inside/Outside: Editor Templates and WTP\'s Snippets View</a></li>
		</ul>
		</li>
		<li>Regrets not all good proposals could be accepted
		<ul>
			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1075">1075
			Java EE 6 development with Eclipse and GlassFish</a></li>
			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1112">1112
			Developing Multi-Tenant SaaS Applications</a></li>
			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1194">1194
			Developing and running web-apps in OSGi with Jetty</a></li>
			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1216">1216
			Click out your JPA model</a></li>
			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1238">1238
			dm Server 2.0</a></li>
			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1288">1288
			Developing Equinox OSGi Applications with EclipseLink---Even Better
			in Helios!</a></li>
			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1314">1314
			JPA with EclipseLink for more than just Java</a></li>
			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1353">1353
			Migrating from JPA 1.0 to 2.0 with Dali</a></li>
			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1361">1361
			Modular Web Application Development with OSGi</a></li>
			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1396">1396
			Some Assembly Required</a></li>
			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1423">1423
			Solving ALL your Persistence Needs with EclipseLink</a></li>
			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1434">1434
			A new way of creating web services from database resources using
			EclipseLink DBWS</a></li>
			<li><a
				href="https://www.eclipsecon.org/submissions/2010/view_talk.php?id=1460">1460
			Developing Simple OpenJPA applications in Eclipse </a></li>
		</ul>
		</li>
	</ul>
	</li>
	<li>New logo?
	<p>1/12/2010 Naci volunteered that he'd consider, and propose a
	plan. For at least web page WTP logo (perhaps Java EE IDE Intro page
	too?).</p>
	</li>

	<li>TODO: create "works with" CQs (all done!)
	<p>See "3rd party" section of <a
		href="http://www.eclipse.org/webtools/releaseReviews/200906/WebTools3.1-ip-log.pdf">last
	year's IP Log</a> for areas we need to cover:</p>
	<ul>
		<li><a
			href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=3694">Application
		Servers</a></li>
		<li><a
			href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=2775">Java
		Persistence Frameworks</a></li>
		<li><a
			href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=3696">JSF
		Runtimes and Component Libraries</a></li>
		<li><a
			href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=3695">Axis2
		Runtimes</a></li>
		<li><a
			href="https://dev.eclipse.org/ipzilla/show_bug.cgi?id=3701">XDoclet</a></li>
		<li>ICU: let's skip this one (unless we hear otherwise) since we
		just use what's in the platform. I don't think anyone else lists it.
		Should be an "exempt pre-req" for everyone. (though technically, even
		exempt pre-req's should be listed).</li>
	</ul>

	<p>For reference, see the <a
		href="http://www.eclipse.org/org/documents/Eclipse_Policy_and_Procedure_for_3rd_Party_Dependencies_Final.pdf">Board
	Resolution</a>.</p>

	<p>Do these show up properly in Auto IP Logs?</p>
	<ul>
		<li><a
			href="http://www.eclipse.org/projects/ip_log.php?projectid=webtools.servertools">Server
		Tools</a></li>
		<li><a
			href="http://www.eclipse.org/projects/ip_log.php?projectid=webtools.webservices">Webservices</a></li>
		<li><a
			href="http://www.eclipse.org/projects/ip_log.php?projectid=webtools.jsf">JSF</a></li>
		<li><a
			href="http://www.eclipse.org/projects/ip_log.php?projectid=webtools.ejbtools">EJB
		Tools</a></li>
		<li><a
			href="http://www.eclipse.org/projects/ip_log.php?projectid=webtools.dali">Dali</a></li>
	</ul>
	</li>

	<li>Let's Review some WTP and Eclipse principles of open source
	development and governance.
	<p>For reference, please re-read the <a
		href="http://www.eclipse.org/projects/dev_process/Eclipse_Standard_TopLevel_Charter_v1.0.php">Eclipse
	Standard Charter</a>. In particular, read the section titled "The
	Development Process". I'd like to make sure we all have the same
	understanding of that section? Here's mine:</p>
	<ul>
		<li>The status quo is the rule. Change is the exception.</li>
		<li>Committers of a sub-project must all agree to change code
		base. (Isn't this the fundamental part of Eclispe governance?)</li>
		<li>PMC defines the process. Which we haven't done!?</li>
	</ul>
	<p>Noted from meeting: It was agreed to (continue to) discuss this more later.</p>
	</li>


	<li>Let's establish "mixed version project interoperability
	requirement"
	<p>Noted from meeting: It was agreed to (continue to) discuss this more later.</p>

	<p>For background, see <a
		href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=298906">bug
	298906</a> where the co-existence requirement is broken. The <a
		href="http://wiki.eclipse.org/Web_Tools_Platform_2.0_Plan#Compatibility_with_Other_WTP_Releases">
	2.0 plan requirement</a> where the co-existence requirement was first
	expressed. The <a
		href="http://wiki.eclipse.org/Web_Tools_Platform_Release_3.0_Requirements#Upgrade_Path">3.0
	plan</a> had some upgrade path requirements, apparently taken directly from
	that year's <a
		href="http://wiki.eclipse.org/RequirementsCouncilThemesAndPriorities#Upgrade_Path">Requirements
	Council's Theames and Priorities</a>. We left blank for 3.1 plan, and (so
	far) for <a
		href="http://www.eclipse.org/projects/project-plan.php?projectid=webtools#compatibility">3.2
	plan</a>. See also the <a
		href="http://www.eclipse.org/projects/project-plan.php?projectid=eclipse#compatibility">Platform's
	Plan statement of "no gaurentee"</a>, but in reality (historically, for
	many years) they do support, as described per their latest release's <a
		href="http://www.eclipse.org/eclipse/development/readme_eclipse_3.5.1.html#Interoperability%20with%20Previous%20Releases">readme
	file</a>.</p>
	</li>

	<li>Discuss W4 incubator project.</li>

	<li>New year resolutions?
	<p>There is a need, and interest!, to discuss high level, big
	picture aspects of the WTP project. Some possible items are listed
	below. Remember, to actually do anything, will require someone to
	volunteer to do the work.</p>
	<ul>
		<li>API, stability</li>
		<li>scope? osgi spec's?</li>
		<li>more "press"? as it is popular</li>
		<li>e4? Can we sign up for "be compatible with e4 in 2011"</li>
		<li><a
			href="http://wiki.eclipse.org/Team_thoughts_on_continuous_improvement_31">Continuous
		Improvement Notes</a></li>
	</ul>
	<p>We'll have next agenda too.</p>
	</li>

</ul>

<h2>Handy Links from past meetings</h2>
<h3>References</h3>
<ul>

	<li><a
		href="http://wiki.eclipse.org/Team_thoughts_on_continuous_improvement_31">Continuous
	Improvement Notes</a></li>
	<li><a href="http://www.eclipsecon.org/2010/">EclipseCon 2010</a></li>

	<li>FYI ... Eclipse Foundation has a relatively new <a
		href="http://www.eclipse.org/home/categories/index.php?category=enterprise">"enterprise
	page"</a>.</li>
	<li><a
		href="http://www.eclipse.org/projects/project-plan.php?projectid=webtools">WTP
	3.2 Plans</a></li>
</ul>
<h3>Other projects to watch:</h3>
<ul>
	<li>WTP @ GSoC 2009. There are two project accepted:
	<ul>
		<li>Index search for Java EE metadata. See <a
			href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=233505">bug
		233505</a></li>
		<li>Embed OpenEJB in J2EE Preview server adapter. See <a
			href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=265952">bug
		265952</a></li>
	</ul>
	</li>
	<li><a href="http://www.eclipse.org/proposals/sca-tools/">SCA
	Tools</a></li>
	<li><a
		href="http://dev.eclipse.org/mhonarc/lists/wtp-pmc/msg01400.html">EMFT
	Texo project proposal</a></li>
	<li><a
		href="http://dev.eclipse.org/mhonarc/lists/wtp-dev/msg06011.html">Maven
	Integration</a></li>
</ul>
<hr />
<p>Back to <a href="../index_pmc_call_notes.php">meeting list</a>.</p>
<p>Please send any additions or corrections to David Williams.</p>
</body>
</html>
