<?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 6, 2011 Conference
	Call</title>
</head>


<body>
	<h1>WTP PMC Agenda/Minutes for September 6, 2011 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=08
&amp;day=25
&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;">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>
	
	<h3>Release 3.3.1 enters +2 PMC approval stage</h3>
	
	<p>
		<a href="http://www.eclipse.org/webtools/plans/3.3.1/pmc-bug-approval.php">Approval list</a>.
	</p>
	
	<h3>Webtools.website project</h3>
	
	<p>
		Do we still use this?  Can we retire it?  David has had some discussions with Wayne B. on this subject.
		Possibly time for some "fall cleaning".  David discussed Wayne's suggestion to start using the top-level project
		for administrating the project website, as most top level projects are run this way.  We can retire the website project,
		and initially make all PMC members and project leads members of top-level project for access to web artifacts.
	</p>
	
	<h3>3.4 Release planning</h3>
	
	<p>
		Some cleanup needed around primary platform, rampdown, and general themes
		<a href="http://www.eclipse.org/projects/project-plan.php?projectid=webtools">Top-level plan</a>
		We discussed the 3.8 platform section, as we are dedicated to support both the 4.2 and 3.8 platform's in the Juno release.
	</p>

	<h3>Other Business ... ?</h3>
	
	<p style="font-style: italic;">Last week's 3.3.1 build late</p>
	<p>
		Some late re-spins may have not have been necessary - all fixed now
	</p>
		
	<p style="font-style: italic;">Action items for migrating to Git</p>
	
	<ul>
		<li>Wiki page for education  - Raghu created, Kaloyan to add content</li>
		<li>Setup Task force (Kaloyan)</li> 
		<li> Mailing list entry encouraging experimentation?</li>
	</ul>
	
	<p style="font-style: italic;">Progress moving WTP 3.4 builds "officially" to 4.2 platform as the default.
	Carl has been working on 3.3.1 build first.  Has some changes lined up to commit after 3.3.1 declares.  
	Still planning on smoke testing on 4.2 based builds after we have resolved these issues.  
	Our target is by M2 we will be using 4.2 based builds.</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 Chuck Bridgham.</p>
</body>
</html>