<?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 February 02, 2010 Conference
Call</title>
</head>
<body>
<h1>WTP PMC Agenda/Minutes for February 02, 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=02
&amp;day=02
&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; 1600 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: R</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:
	R</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>New logo?
	<p>1/12/2010 Naci volunteered that he'd consider, and propose a
	plan. For at least web page WTP logo (perhaps Java EE IDE Intro page
	too?).</p>
	<p>Naci reported he has opened bugs to discuss 2 things: 1) some
	rework of webpages (many no longer used); 2) potential new web logo.
	He'll attach a few possibilities and request review and dsicussion.</p>
	</li>

	<li>Discuss Common Project and leadership.
	<p>Notes from meeting: Discussed final nomination. Discussed
	Konstantin's final feedback and advice to "... break up the Common
	project". We acknowledged the nature of the Common Project, but saw no
	advantage to breaking it up at this time, and thought best to leave as
	is, for now, but monitor for future to re-visit alternatives and
	improvements long term. While it has less of a specific, common
	technical focus than other projects, that alone would not mean a
	virtual team could not be formed and work together towards common
	goals.</p>
	</li>

	<li>mixed version project interoperability requirement
	<p>Notes from meeting: pending.</p>
	</li>

	<li><a
		href="http://www.eclipse.org/helios/planning/EclipseSimultaneousRelease.php">Accessibilty
	Requirement</a>: Can we agree on which checklist to use? I'm assuming each
	project will complete one, even though we will "rollup" into one, for
	the Helios requirement. Better if all subprojects use the same one?

	<p>For reference or evaluation, here is a general page from IBM on
	<a href="http://www-03.ibm.com/able/guidelines/index.html">Accessibilty
	Guidelines for Developers.</a> With three checklists:</p>
	<ul>
		<li><a
			href="http://www-03.ibm.com/able/guidelines/software/accesssoftware.html">Software</a></li>
		<li><a
			href="http://www-03.ibm.com/able/guidelines/documentation/accessdoc.html">Documentation</a></li>
		<li><a
			href="http://www-03.ibm.com/able/guidelines/web/accessweb.html">Web</a></li>
	</ul>
	<p>Notes from meeting: Neil, who was on original PC committee, will
	examine lsits, and come up with a recommendation.</p>
	</li>

	<li>Review WTP and Eclipse principles of open source development
	and governance.
	<p>For reference, please re-read the <a
		href="http://www.eclipse.org/projects/dev_process/Eclipse_Standard_TopLevel_Charter_v1.0.php">Eclipse
	Standard Charter</a>. In particular, read the section titled "The
	Development Process". I'd like to make sure we all have the same
	understanding of that section? Here's mine:</p>
	<ul>
		<li>The status quo is the rule. Change is the exception.</li>
		<li>Committers of a sub-project must all agree to change code
		base. (Isn't this the fundamental part of Eclispe governance?)</li>
		<li>PMC defines the process. Which we haven't done!?</li>
	</ul>
	<p>Notes from meeting: Pending. It was agreed to continue to
	discuss this to make sure at least we, the PMC, agree.</p>
	</li>

	<li>New year resolutions?
	<p>There is a need, and interest!, to discuss high level, big
	picture aspects of the WTP project. Some possible items are listed
	below. Remember, to actually do anything, will require someone to
	volunteer to do the work.</p>
	<ul>
		<li>Discuss W4 incubator project. (Raghu)</li>
		<li>API, stability</li>
		<li>scope? osgi spec's?</li>
		<li>more "press"? as it is popular</li>
		<li>e4? Can we sign up for "be compatible with e4 in 2011"
		<p>Notes from meeting: This was only "new years resolution"
		discussed. We mentioned 4 points:</p>
		<ul>
			<li>need feedback from adopter products on
			importance/explotation of e4</li>
			<li>needed nonAPI scans first to see how far off we are, from
			using compatibility layer.</li>
			<li>may need help from Platform to provide more API?</li>
			<li>we ourselves may need to provide more API!? Are any of our
			functions sensitive to e4?</li>
		</ul>
		</li>
		<li><a
			href="http://wiki.eclipse.org/Team_thoughts_on_continuous_improvement_31">Continuous
		Improvement Notes</a></li>
	</ul>
	<p>We'll have next agenda too.</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>
