<?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 August 02, 2011 Conference
	Call</title>
</head>
<body>
	<h1>WTP PMC Agenda/Minutes for August 02, 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=08
&amp;day=02
&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>PMC approval of Elson Yuen as Server Tools Lead?</p>

	<p style="font-style: italic;">PMC discussed and approved. dw to
		send note to EMO.</p>

	<p>Planning: Review standard format plan files</p>

	<p style="font-style: italic;">Comments: probably should not have
		milestone dates, since redundant and error prone. Suggested just
		mentioning we are +2 project in Juno Sim Release plan, and reference
		our wtp google calendar.</p>
	<p style="font-style: italic;">Some confusion over where Libra plan
		was, since in different repo location. As long as linked in all the
		right places, it doesn't really matter.</p>
	<p style="font-style: italic;">We should have an explicit statement about 3.8 support, in main
		WTP Plan. dw to add.</p>

	<p>"Ownership" of EPP Packages? Thanks, for the wtp-dev msg,
		Kaloyan. I suggest in about a month, we "open up" the invitation, if
		no wtp committers come forward. In about two months, we'd "cancel"
		them, if no one somes forward. Other suggestions?</p>

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

	<p style="font-style: italic;">Kaloyan asked about some IBM
		contributions to Libra. Chuck will follow up with Zina.</p>

	<p style="font-style: italic;">Neil asked ""what's happening with
		maven integration plans?" Chuck responded he has talked to Jason van
		Zyl. At first, some interest, maybe an incubator in m2e project. But
		... later, not so much. Chuck mentioned some (in maven project) may
		have more interest in "webby" project. Chuck will continue to pursue
		as he can, Complements to Fred (from JBoss) who is currently "doing a
		lot of the work". Neil mentioned Fred (via patches?) is making Dali
		more maven friendly, but those changes might not apply (or help) all
		of JEE functions.</p>

	<p style="font-style: italic;">Chuck to run retrospective on
		Thursday's status call. Will send out reminder.</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>