<?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 8, 2012 Conference
	Call</title>
</head>


<body>
	<h1>WTP PMC Agenda/Minutes for May 8, 2012 Conference Call</h1>
	<h2>Call Info </h2>
	<p>
		Toll free (in US and Canada): 888-426-6840 <br /> Access code:
		5019600# <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=08
&amp;year=2012
&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;">Chuck
			Bridgham: 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;">David
			Williams: Y</li>
	</ul>
-->
	 
	<h2>Announcements and General Business</h2>
	
	<h4>Congratulations on successful Creation Review of m2e-wtp!</h4> 
	
	<h4>RC1 progress/ Quality push...</h4>
	<p>  
	<ul>
		<li>How are we doing?  Keep up pressure in Thursday's meeting.</li>
		<li>No declared build this week - WTP M7 driver added to aggregation today</li>
		<li><a href="http://www.eclipse.org/webtools/plans/3.4.0RC1/pmc-bug-approval.php">PMC approval list (+1 needed)</a></li>
		<li><a href="https://bugs.eclipse.org/bugs/report.cgi?x_axis_field=target_milestone&y_axis_field=product&z_axis_field=&query_format=report-table&classification=WebTools&target_milestone=3.4&target_milestone=3.4+M1&target_milestone=3.4+M2&target_milestone=3.4+M3&target_milestone=3.4+M4&target_milestone=3.4+M5&target_milestone=3.4+M6&target_milestone=3.4+M7&target_milestone=3.4+RC1&target_milestone=3.4+RC2&target_milestone=3.4+RC3&target_milestone=3.4+RC4&target_milestone=3.1&target_milestone=3.1+M1&target_milestone=3.1+M2&target_milestone=3.1+M3&target_milestone=3.1+M4&target_milestone=3.1+M5&target_milestone=3.1+M6&target_milestone=3.1+M7&target_milestone=3.1+RC1&target_milestone=3.1+RC2&target_milestone=3.1+RC3&target_milestone=3.1+RC4&bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&format=table&action=wrap">Remaining 3.4 defects</a></li>
	</ul>
	</p>
	<p>
		We need to start following / promoting our Juno Ramp-down plan - especially M7 exceptions
		<a href="http://wiki.eclipse.org/WTP_3.4_Ramp_down_Plan_for_Juno">Juno Rampdown plan</a>
	
	</p>	
	
	
	<h3>Longterm Sticky items</h3>
	
	<h4>Concerns of quality with e4 - Continue to review and provide feedback.</h4>
	<p>  
		<a href="http://wiki.eclipse.org/WTP_e4_Feedback">Feedback/issues page</a>
	</p>
	
	<h4>Git / Build transition plans</h4>
	<p>  
		<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=376211">WTP Git bug</a>
		<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=376002">WTP Maven/Tycho bug</a>
	</p>
	
	<h4>M2E-WTP Proposal/ Schedule</h4> 
	<p>  	
		<a href="http://www.eclipse.org/proposals/technology.m2e.m2e-wtp/">M2E-WTP proposal</a>
	</p>
	
	<h4>Provisional API cleanup</h4>
	<p>
		<a href="http://wiki.eclipse.org/WTP_Provisional_API_Reduction">Wiki for provisional api reduction</a>
	</p>
	
	<h4>3.4 Release Planning</h4>
	<p>  
		<a href="http://www.eclipse.org/projects/project-plan.php?projectid=webtools">Top-level plan</a>
	</p>
	
	<h4>CQ PMC approvals...  </h4>
	<p>
		<a href="https://dev.eclipse.org/ipzilla/buglist.cgi?query_format=advanced&short_desc_type=allwordssubstr&short_desc=&product=webtools&long_desc_type=substring&long_desc=&bug_file_loc_type=allwordssubstr&bug_file_loc=&keywords_type=allwords&keywords=&bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&emailassigned_to1=1&emailtype1=substring&email1=&emailassigned_to2=1&emailreporter2=1&emailcc2=1&emailtype2=substring&email2=&bugidtype=include&bug_id=&chfieldfrom=&chfieldto=Now&chfieldvalue=&cmdtype=doit&order=Reuse+same+sort+as+last+time&field0-0-0=noop&type0-0-0=noop&value0-0-0=">Open CQ entries</a>
	</p>
	
	<h3>Other Business ... ?</h3>
	
	<p>Git adoption progress    Continue polling -
	- investigate a subproject that could "pilot" a git repo feeding into our overall PDE build.
	- Carl or volunteer? Can start investigating building existing Git project like Libra?
	- More discussion on CVS - GIT transition - should replace CVS feature for feature
	- Tentative schedule for CVS -> Git migration post Juno (July)
	- Platform HAS put a stake in the ground....
	<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=358980"> CVS Retirement bug (Target: December 21, 2012)</a>
	</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>
		<li>
		<a href="http://wiki.eclipse.org/WTP_API_Change_History">API Change history, guidelines</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 Chuck Bridgham.</p>
</body>
</html>