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


<body>
	<h1>WTP PMC Agenda/Minutes for May 1, 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=01
&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>M7 progress/ Quality push...</h4>
	<p>  
	<ul>
		<li>How are we doing?  Keep up pressure in Thursday's meeting.</li>
		<li><a href="http://www.eclipse.org/webtools/plans/3.4.0M7/pmc-bug-approval.php">PMC approval list is ready for M7</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>
	<h4>JPT provisional API changes</h4>
	<p>  
		Some of the changes going into M6 were recently discovered by a few adopters.  Changes were made to <a href="http://wiki.eclipse.org/New_Help_for_Old_Friends_VII">New Help for old friends</a> post M6.
		Although the changes made it into M6, some adopters were caught off guard again of the nature of the breaking changes.  Specifically IBM was relying on reflection techniques
		to resolve some differences, but the latest round has made this difficult, and changing build schemes is very hard at this point in the cycle. Can we discuss options?
		
	</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>