<?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 January 11, 2011 Conference
Call</title>
</head>
<body>
<h1>WTP PMC Agenda/Minutes for January 11, 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=01
&amp;day=11
&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: Y</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>
</ul>

<h2>Announcements and General Business</h2>

<ul>

	<li>Should we really try and _release_ Libra for Indigo? Plans to
	use in a product? Ready to use in a product?
	<p>Yes, there are some pieces thought stable enough, and yes there
	will be a neeed/use of them (at least some of them).</p>
	<p>A fall back plan is that if can not be simultaneious with
	Indigo, could be, say, a month later.</p>
	<p>Kaloyan will do/lead builds, etc. Will reside in GIT. Libra
	build will produce feature repository. Using Hudson, Maven, GIT. It is
	"tagged" (conceptually) by a change list ... rebuilds could be done per
	change list. Signed. Four part version numbers.</p>
	<p>But many parties involved ... has taken longer to get going with
	release review ... might take longer than planned for other pieces to
	come together.</p>
	</li>

	<li>Thoughts/discussion of long term support for 3.2.x (Helios)
	stream?
	<p>IBM adopters/committers would probably like addtional
	maintenance releases. Oracle probably has no need. SAP probably has no
	need.</p>
	<p>Pros/cons mentioned during meeting.</p>
	<ul>
		<li>will it interfere with indigo schedules?</li>
		<li>Extra work for more unified smoke testing.</li>
		<li>But good to do unified smoke testing (each project could
		decide what to do, if anything).</li>
		<li>Each project would decide how much (if at all) to
		participate.</li>
	</ul>
	<p>Next step: dw to come back with more detailed proposal/dates.</p>
	</li>



	<li>Reminder that <a
		href="http://www.eclipse.org/webtools/plans/3.2.3/pmc-bug-approval.php">PMC
	Review</a> starts after this weeks build.</li>

	<li>JPA Diagram Editor Committers:
	<p>Neil will start process today.</p>
	</li>

	<li>Naci's yearly report :)
	<p>Eureka: OSAMI: Mostly Coorporations (some universities) in
	?consortium? to foster innovation. Using hybird WTP and OSGi. Naci in
	second year of three year grant.</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>
