<?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 June 8, 2010 Conference Call</title>
</head>
<body>
<h1>WTP PMC Agenda/Minutes for June 8, 2010 Conference Call</h1>
<h2>Call Info</h2>
<p>Tollfree in the US: 877-421-0030 <br />
Alternate: 770-615-1247<br />
Access code: 173098# <br />
<a
	href="http://wiki.eclipse.org/images/f/f6/WTP_status_phone_access.pdf">Full
list of phone numbers</a><br />
<br />
<a
	href="http://www.timeanddate.com/worldclock/custom.html?cities=224,207,1440,107
&amp;month=06
&amp;day=08
&amp;year=2010
&amp;hour=11
&amp;min=0&amp;sec=0&amp;p1=207">Call
Time: 8:00 AM Pacific; 11:00 AM Eastern; 1500 UTC</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: 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:
	Y</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>PMC Review for RC4 <a
		href="http://www.eclipse.org/webtools/plans/3.2.0RC4/pmc-bug-approval.php">PMC
	Approval Summary page</a>.</li>

	<li>Any other release issues? Final build today?</li>

	<li>Docuware and IP Log submitted on time.
	<p>I did receive query about JSDT ... IP Staff surprised they were
	releasing/graduating. (remember to communicate that seperately, next
	time)</p>
	<p>Still not listed on <a
		href="http://www.eclipse.org/projects/whatsnew.php">what's new</a>
	page. They said we would be once IP docs approved.</p>
	<ul>
		<li><a
			href="http://www.eclipse.org/webtools/releaseReviews/201006/WebTools3.2ReleaseOverview.pdf">Overview</a>
		</li>
		<li><a
			href="http://www.eclipse.org/webtools/releaseReviews/201006/WebTools3.2.pdf">Details</a>
		</li>
	</ul>
	</li>
	<li><a href="http://www.eclipse.org/helios/heliosinaction.php">Helios
	in Action (2 slots!)</a></li>



	<li>Discuss Konstantin's request to PMC:
	<p>See <a
		href="http://dev.eclipse.org/mhonarc/lists/wtp-pmc/msg01667.html">original
	message.</a></p>

	<p>This is a request to have a move review. June 8 meeting for
	questions and discussion, and the PMC will make a decision/position
	within a few weeks after that.</p>
	<p>Related information and links:</p>
	<ul>

		<li><a
			href="http://www.eclipse.org/projects/dev_process/development_process.php#6_3_7_Move_Review">Dev.
		Process: Move Review</a></li>
		<li><a
			href="http://www.eclipse.org/projects/dev_process/Eclipse_Standard_TopLevel_Charter_v1.0.php">PMC
		Responsibilities</a></li>
		<li><a
			href="http://www.eclipse.org/projects/project_summary.php?projectid=technology.fproj">technology.fproj</a></li>

		<li><a href="http://www.eclipse.org/proposals/fproj/">The
		original Technology Project Proposal for Faceted Projects</a></li>
		<li>Others?</li>
	</ul>
	</li>

	<li id="movenotes">Rough notes from meeting.
	<p>Konstantin presented the reasons he'd like the Faceted project
	code outside of WTP.</p>

	<p>Partially for appearance and visibility as a generally useful
	framework, not specific to webtools. Broaden appeal, broaden adoption.
	</p>
	<p>He was pretty direct that the move was to have independent
	governance, that in his view of open source development, the individual
	person who works on some framework code should have final say in what
	they do with that code (that they could not be vetoed by other
	committers in the project). </p>
	<p>He sees the framework's 2.x code as a fresh start, with his own
	API Policy (not WTP's) which would include removing all the currently
	deprecated API The current API would be renamed to its own package
	namespace. (The current/continued 1.x stream would keep same namespace
	and API as it has now, and he'd try to maintain compatibility, having
	the old code call out to the new code.)</p>
	<p>The new v2 framework would offer some new UI work. clean API (no
	deprecated API). No "core api" additions or concepts were mentioned.</p>
	<p>He said there were no other adopters, beyond WTP. Some recent
	discussions came from PDT (who prereq WTP). He has discussed with CDT,
	but Doug said "interesting, but no time or people to do right now".
	Konstantin would also like to pitch to PDE team, if he had independent
	project.</p>
	<p>As to why "more efficient" to do both old and new code in one
	project, he mentioned then they could have a common build.</p>
	<p>He acknowledged the incubating state of current Faceted Project
	project, and thought it would not take much to get graduated. (He
	mentioned work on build).</p>
	<p>He acknowledged there was not much community in the new
	Incubating project,, in terms of adoption, mailing lists, newsgroups,
	bugzilla, which he attributes to the "chicken and egg" phenomena.</p>
	<p>When asked about having other committers in the new project, he
	said he would like very much if others made substantial contributions
	to the code (but no one has so far, and no one has shown much
	interest).</p>
	<p>He said he could not think of any alternatives, such as (my
	offhand suggestion) having a sub-sub-project of WTP's Common Tools
	project would not solve the governance problem, he said.</p>
	<p>Overall, I think the meeting/discussion accomplished what it
	should have (increased our understanding, give him a chance to
	explain).</p>
	</li>



</ul>

<h2>Handy Links from past meetings</h2>
<h3>References</h3>
<ul>



	<li><a
		href="http://wiki.eclipse.org/Team_thoughts_on_continuous_improvement_31">Continuous
	Improvement Notes</a></li>
	<li><a href="http://www.eclipsecon.org/2010/">EclipseCon 2010</a></li>

	<li>FYI ... Eclipse Foundation has a relatively new <a
		href="http://www.eclipse.org/home/categories/index.php?category=enterprise">"enterprise
	page"</a>.</li>
	<li><a
		href="http://www.eclipse.org/projects/project-plan.php?projectid=webtools">WTP
	3.2 Plans</a></li>
</ul>
<h3>Other projects to watch:</h3>
<ul>
	<li>WTP @ GSoC 2009. There are two project accepted:
	<ul>
		<li>Index search for Java EE metadata. See <a
			href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=233505">bug
		233505</a></li>
		<li>Embed OpenEJB in J2EE Preview server adapter. See <a
			href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=265952">bug
		265952</a></li>
	</ul>
	</li>
	<li><a href="http://www.eclipse.org/proposals/sca-tools/">SCA
	Tools</a></li>
	<li><a
		href="http://dev.eclipse.org/mhonarc/lists/wtp-pmc/msg01400.html">EMFT
	Texo project proposal</a></li>
	<li><a
		href="http://dev.eclipse.org/mhonarc/lists/wtp-dev/msg06011.html">Maven
	Integration</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>
