<?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 March 30, 2010 Conference Call</title>
</head>
<body>
<h1>WTP PMC Agenda/Minutes for March 30, 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=03
&amp;day=30
&amp;year=2010
&amp;hour=11
&amp;min=0&amp;sec=0&amp;p1=207">Call
Time: 8:00 AM Pacific; 11:00 AM Eastern; 1500 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>Q: PMC approval of changes to provisional API?<br />
	A: Yes (best to document same way).
	<p>TODO: udpate approval doc. API Doc already mentions.</p>
	</li>

	<li>EclipseCon feedback?
	<p>Web tools Tutorial well attended. 3 hours too short for content.
	(3 major topics too much. 2 topics would be ok).</p>
	<p>Other?</p>
	<p>Some 25 minute talks didn't fit well. Perhaps ok for "grouped"
	or related content. Some of them could have been "lightening" talks.
	Speakers will have to adjust better, too, if used in future.</p>
	<p>Liked having tutorials each day.</p>
	<p>Since Neil is long winded, next year, put Raghu's talk before Neils :) </p>
	</li>

	<li>PMC Review and approval of 3.1.2 Patch (for public update
	site).
	<p>See <a
		href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=305306">bug
	305306</a>.</p>
	</li>



	<li>Is M7 in trouble?
	<ul>

		<li>Review <a
			href="http://wiki.eclipse.org/WTP/Accessibility/Helios/webtools">Accessibility
		checklist (summary)</a>
		<p>WPE and Faces Config editor are only "large" functions not
		accessible. Need to check if enough of Faces Config fixed to count as
		"accessible". WPE won't be for release. Raghu says maybe in
		maintenance release.</p>
		</li>

		<li>We need to rampdown.
		<p>Discuss</p>
		<ul>
			<li><a
				href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=304654">bug
			304654</a></li>
			<li><a
				href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=307148">bug
			307148</a></li>
		</ul>
		<p>Everyone understood and agreed. These are some big areas that
		were known to be "coming in late" but almost done. Neil had a few from
		Dali yet to put in rampdown plan.</p>
		</li>

		<li>Java EE 6 annotation-based wizards
		<p>Deadline? Point of no return? We decided 4/15 was hard cutoff.</p>
		</li>

		<li>Dali and EclipseLink
		<p>new function coming? cross-packaging needed?</p>
		</li>

		<li>JSF
		<p>Many defects deferred from M6 to M7, "at last minute"?</p>
		<p>feature restructuring desired</p>
		<p>Accessibility bugs outstanding since last year?</p>
		</li>

	</ul>
	</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>
