<?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 May 17, 2011 Conference Call</title>
</head>
<body>
	<h1>WTP PMC Agenda/Minutes for May 17, 2011 Conference Call</h1>
	<h2>Call Info</h2>
	<p>
		Toll free (in US and Canada): 888-426-6840 <br /> Access code:
		6460142# <br /> Caller pay alternative number: 215-861-6239<br /> <a
			href="https://www.teleconference.att.com/servlet/glbAccess?process=1&accessCode=6460142&accessNumber=2158616239">Full
			list of global access numbers</a><br /> <br /> <a
			href="http://www.timeanddate.com/worldclock/custom.html?cities=224,207,1440,107
&amp;month=05
&amp;day=17
&amp;year=2011
&amp;hour=11
&amp;min=0&amp;sec=0&amp;p1=207">Call
			Time: 11:00 AM Eastern</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: N</li>
		<li style="margin: 0em 0.2em 0em 0em; padding: 0.0em;">Kaloyan
			Raev: Y</li>
		<li style="margin: 0em 0.2em 0em 0em; padding: 0.0em;">Chuck
			Bridgham: Y</li>
	</ul>

	<h2>Announcements and General Business</h2>

	<p>
		Remember to monitor <a
			href="http://www.eclipse.org/webtools/plans/3.3.0RC/pmc-bug-approval.php">PMC
			review list for 3.3.0 end game.</a>.
	</p>
	<p>
		Remember to monitor <a
			href="http://www.eclipse.org/webtools/plans/3.2.4/pmc-bug-approval.php">PMC
			review list for 3.2.4 end game</a>.
	</p>

	<p>Any concerns remaining about releasing 3.2.4 on Friday?</p>

	<p style="font-style: italic;">There were no concerns.</p>

	<p>
		The <a
			href="http://www.eclipse.org/projects/ip_log.php?projectid=webtools.common,webtools.dali,webtools.ejbtools,webtools.jeetools,webtools.jsdt,webtools.jsf,webtools.libra,webtools.servertools,webtools.sourceediting,webtools.webservices">IP
			Log</a> to be submitted on 5/18. Who wants to push submit button?
		Volunteers?
	</p>
	<p style="font-style: italic;">dw to "press submit" once jdom issue
		settled. Next step, dw to make copy of last years release docs, then
		ask PLs to review/edit.</p>

	<h3>Other Business ... ?</h3>

	<p style="font-style: italic;">Chuck will send reminder, and
		pointer to udpated queries, about large number of bugs still targeted
		to Indigo RC, and remind teams to triage those lists, to be realistic
		and accurate.</p>

	<p style="font-style: italic;"></p>

	<h2>Future Agenda items</h2>
	<!--  <ul style="text-indent: 5em; font-style: italic;"> -->
	<ul style="font-style: italic;">


		<li>Discuss our model and assignments of "PMC Roles". Do they
			still make sense?</li>


	</ul>
	<h2>References</h2>
	<ul>
		<li><a
			href="http://wiki.eclipse.org/Team_thoughts_on_continuous_improvement_32">Continuous
				Improvement Notes</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>