<?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 10, 2009 Conference Call</title>
</head>
<body>
<h1>WTP PMC Agenda/Minutes for February 10, 2009 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=11
&amp;day=04
&amp;year=2008
&amp;hour=11
&amp;min=0&amp;sec=0&amp;p1=207">Call
Time: 1500 UTC</a></p>
 
<h2>Attendees</h2>
<h3>PMC Members</h3>
<ul>
    <li>David Williams: Y</li>
    <li>Naci Dai: R</li>
    <li>Raghunathan Srinivasan: Y</li>
    <li>Neil Hauge: Y</li>
    <li>Tim deBoer: Y</li>
    <li>Kaloyan Raev: Y</li>
</ul>
 -->
<!--
<h3>Invited Guests</h3>
<ul>
<li>Philippe Ombredanne (ATF): N</li>
</ul>
-->
<h2>Announcements and General Business</h2>
<ul>
    <li>Committer approvals ... Eric Peters, Keith Chong<p>approved</p></li>
    <li>Any objections to moving 3 bundles from common to webservices?><p>we did discuss what initiated the change now, since it's been this way a while.</p></li>
    <li>Suggestions for an opening at EclipseCon (a one hour talk)?<p>Raghu might have a possibility</p></li>
</ul>
<!-- 

Reports, Actions, Issues

 -->
<h2>Reports, Actions, Issues</h2>
<!-- 

    Rotate topics by taking last one and putting it on top 
    
-->
<!-- 

    Planning
 
 -->
<h3>Planning: David Williams</h3>

<ul>
    <li>Final 3.0.4 build this week.</li>
    <li>No declared build in 3.1 stream this week. (planning week)</li>
</ul>
<h4>Reference</h4>
<ul>
    <li><a href="http://wiki.eclipse.org/WTP_Planning_Lead">WTP Planning Role</a></li>
</ul>
<!-- 

    User Experience

 -->
<h3>WTP User Experience Lead: Kaloyan Raev</h3>
<ul>
    <li>Had <a href="http://wiki.eclipse.org/JavaEE_Perspective_UIWG_Walkthrough">UI Walkthrough</a></li>
    <li>Started collecting <a href="http://wiki.eclipse.org/JavaEE_Perspective_Usage_Screenshots">usage data</a></li>
</ul>
<h4>References</h4>
<ul>
    <li><a href="http://wiki.eclipse.org/WTP_User_Experience_Lead">WTP User Experience Lead</a></li>
</ul>
<!-- 

    Quality

 -->
<h3>Quality: Neil Hauge</h3>
<li>Focus items in status meetings:
<p>Good progress ... switch to something new in week or two.</p>
</li>
<li>Neil investigating a blanket "close old bugs" policy -- to present to the group for review and approval.</li>
<li>Neil has estimated approximately 800 bugs (of 2000 untargeted bugs) could be considered "old bugs". He'll
prepare a table and note to send to project with encouragement to PLs to handle ... something like either triage
individually and assign a target, or mark with 'helpwanted' or mark in mass with a kind comment to re-open if still an
issue (with reason for the mass update, etc.).</li>
</ul>
<h4>Reference:</h4>
<ul>
    <li><a href="http://wiki.eclipse.org/WTP_Quality_Lead">WTP Quality Lead</a></li>
    <li>See also <a href="http://wiki.eclipse.org/WTP_Quality">Quality Page</a></li>
</ul>
<!-- 

    Architecture

 -->
<h3>Architecture: Tim deBoer</h3>
<ul>
    <li>API Tools. Tim to investigate and make recommendations to teams.</li>
</ul>
<h4>Reference</h4>
<ul>
    <li><a href="http://wiki.eclipse.org/WTP_Architecture_Lead">WTP Architecture Lead Role</a></li>
    <li>Tracking meetings and work at <a href="http://wiki.eclipse.org/WTP_Architecture_Working_Group">WTP
    Architecture Working Group</a></li>
</ul>
<!-- 

    Education

 -->
<h3>Education: Naci Dai</h3>
<p>Naci reports web pages for education materials are about ready. He is writing article, as deadline is in
December. Raghu was only response he got for being interested in contributing too.</p>

<p>Please review: <a href="http://www.eclipse.org/webtools/community/resources/">Resource Page Proposal</a></p>
<h4>Reference</h4>
<ul>
    <li><a href="http://wiki.eclipse.org/WTP_Education_Lead">WTP Education Lead</a></li>
</ul>
<!-- 

    Requirements

 -->
<h3>Requirements: Raghu Srinivasan</h3>
<p>Raghu noted we should remind PLs to update plans every milestone.</p>

<h4>Reference</h4>
<ul>
    <li><a href="http://wiki.eclipse.org/WTP_3.1_Project_Plan">Planning Process Document</a> has been started.</li>
    <li>Eclipse-level dates and requirements have been clarified in a <a
        href="http://dev.eclipse.org/mhonarc/lists/eclipse.org-planning-council/msg01422.html">Planning Council
    message</a> (and elsewhere).</li>
    <li><a href="http://wiki.eclipse.org/WTP_Requirements_Lead">WTP Requirements Lead Role</a></li>
</ul>

<!-- 

General business

 -->
<h2>General business?</h2>
<h3>Other projects to watch:</h3>
<ul>
    <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>
<h2>PMC Calendar</h2>
<ul>
    <li><a href="http://www.eclipsecon.org/2009/">EclipseCon 2009</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>
