<?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 February 22, 2011 Conference
	Call</title>
</head>
<body>
	<h1>WTP PMC Agenda/Minutes for February 22, 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=02
&amp;day=22
&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: Y</li>
		<li style="margin: 0em 0.2em 0em 0em; padding: 0.0em;">Kaloyan
			Raev: Y</li>
	</ul>


	<h2>Announcements and General Business</h2>

	<p>Apologies for last minute cancellation last week (and, thanks
		for covering)</p>

	<p>
		11:00 - 11:30: Discuss <a
			href="pmcPresentations/ECLIPSE Research Proposal Overveiw 110211.ppt">research
			proposal</a> with Tony O'Driscoll and Jonathon Cummings, from Fuqua
		School of Business, Duke University.
	</p>

	<p style="font-style: italic;">Interesting meeting/interview. Turns
		out they only wanted the interview with us, for now. They are "fine
		tuning" their more quantitative questionaires. They said they'd send
		an 5-10 page executive summary to Mike and participants. They had been
		through their University's "research review" which checks for things
		like confidentiality safegaurds, ethical behavior, etc. They said this
		research is "funded through their business school" (that is, not paid
		for be another third party ... like when the Milk Association funds
		research showing how good milk is for you.)</p>



	<p>11:30 - 12:00: Other PMC business</p>
	<ul>
		<li>Ready to release?</li>
		<li>Other PMC Business?

			<p style="font-style: italic;">
				PMC membership: We discussed Chuck being nominated and joining the
				PMC. I followed up with Naci via email, and he confirmed, so that
				made it unananamous agreement. I <a
					href="http://dev.eclipse.org/mhonarc/lists/wtp-pmc/msg01789.html">announced,
				</a> Mike approved. Wayne updated databases. And now shows up at <a
					href="http://www.eclipse.org/projects/project_summary.php?projectid=webtools">Foundation
					Portal</a>
			</p>
		</li>




	</ul>

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

		<li>Retrospect Helios quick maintenance release. Does it mean we
			weren't ready to release? Any way to improve timing in future?</li>
		<li>Disuss our model and assignments of "PMC Roles". Do they
			still make sense?</li>


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