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


<body>
	<h1>WTP PMC Agenda/Minutes for September 25, 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=09
&amp;day=25
&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;">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>Kepler , Juno SR2 planning/ progress?</h4>
	
	<ul>
		<li>Current top level Kepler <a href="http://www.eclipse.org/projects/project-plan.php?planurl=http://www.eclipse.org/webtools/standard-project-plans/kepler/wtp-plan.xml">draft</a></li>
		<li>M2: Initial Planning document should be due - Can we discuss a possible "planning meeting"? - Project leads can take us through draft plans...</li>
		<li>Juno SR2   Feb 22 GA  (Our 3.4.2)  Do we need any other releases?</li>
		<li>Updating project metadata for Kepler release...  Having problem changing top-level project through portal</li>
	
	
	<h4>Discuss "State of the Platform"</h4>
	<ul>
		<li>Perceived performance problems</li>
		<li>Growing platform resources</li>
		<li>Discussed performance test framework revival - need non-platform projects to contribute</li>
		<li>What can/should we do to help?</li>
	</ul>

	
	<h3>Long term Sticky items</h3>
	
	<h4>Git / Build transition</h4>
	
	<p> Continuing feedback needed and best practices captured...
	<ul>
		<li><a href="http://wiki.eclipse.org/WTP_Git_Workflows">WTP Git Workflows</a></li>
	</ul>
	</p>
	
	<h4>Incubating projects...</h4>
	 
	<ul>
		<li><a href="http://eclipse.org/m2e-wtp/">M2E-WTP website</a></li>
		<li><a href="http://www.eclipse.org/projects/project.php?id=webtools.vjet">VJet website</a></li>
	</ul>
	</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>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>


	<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>