<?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 June 21, 2011 Conference Call</title>
</head>
<body>
	<h1>WTP PMC Agenda/Minutes for June 21, 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=06
&amp;day=21
&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: R</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>Another year, another release ... congratulations and thanks!</p>


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

	<p>WTP Incubator Project Lead ....</p>
	<p style="font-style: italic;">The PMC agreed Dave Carver would be
		a great lead for WTP Incubator. It recognizes what he's already done
		(meritocracy) and with any luck, might help keep him interested in
		continuing to do it! dw to start mailing list vote.</p>

	<p>Next meeting ... 7/19? (6/28, just released, 7/5 near US
		Holiday, 7/12 I'm (still) on vacation)</p>
	<p style="font-style: italic;">It was aggreed, 7/19 is reasonable,
		for next scheduled weekly call. Business doesn't stop of course, and
		we'll deal with things on mailing lists or email, if necessary, if
		anything comes up. Juno M1 is some time in August.</p>

	<p style="font-style: italic;">We also briefly discussed EPP
		Packages (Java EE and JavaScript) and wondered if others would be
		willing/interested in being the "package maintaners". Its not really
		PMC business, per se, but seems to PMC to be worth while to have them.
		Unclear who might be interested in being "new" owner. It has to be an
		Eclipse Committer, but not neccessarily from WTP. We'll discuss again
		in July to see if anything new is learned about who uses it, who might
		be motivated to maintain/test it. Kaloyan will try to blog about it,
		see if we can get some indication of who uses it, etc.</p>

	<!-- 
	<p style="font-style: italic;">Discussed, some, the planning
		process for Juno release. Mostly that "it is up to each subproject"
		when to start, we usually ask for a draft around RC2, fairly firm
		version by RC3, and final plan by RC4 (December). There is only so
		much we, as the PMC, can "require" in terms of time-line, since most
		teams need to review internally before committing publically.</p>

	<p style="font-style: italic;">Briefly discussed "maintenance
		plans", but mostly to say "not ready to propose details" yet Maybe
		next week.</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>