<?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 October 21, 2008 Conference Call</title>
</head>
<body>
<h1>WTP PMC Agenda/Minutes for October 21, 2008 Conference Call</h1>
<h2>Call Info</h2>
<p>Tollfree in the US: 877-421-0030 <br />
Alternate: 770-615-1247<br />
Access code: 269746# <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=10
&amp;day=16
&amp;year=2007
&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: N</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>An interesting <a href="http://www.sdtimes.com/MICROSOFT_CO_SPONSORS_ECLIPSE_PROJECT_FOR_SILVERLIGHT/About_OPENSOURCE_and_SILVERLIGHT_and_ECLIPSE_and_MICROSOFT_and_SOYATEC/32968">article on Eclipse and Silverlight and Microsoft</a></li>
    <li>Any further reactions to the proposal to have <a
        href="http://dev.eclipse.org/mhonarc/lists/technology-pmc/msg01118.html">Faceted Project Framework move to
    Technology Project</a>?
    <p>None. But clarified to some that there would be no names changes required, no mass updates from adopters,
    etc. May or may not incorporate in WTP (may or may not in Galileo).</p>
    </li>
    <li>No Phone meeting next week? Meet at Eclipse World? Breakfast, Lunch, Dinner?
    <p>no phone meeting on Tuesday. Those of us at Eclipse World will meet for lunch or breakfast.</p>
    </li>
    <li>Dali and Automated IP Log?
    <p>Neil and I investigating and will report findings in a few weeks.</p>
    </li>
</ul>
<!-- 

Reports, Actions, Issues

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

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

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

    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>Please review: <a href="http://www.eclipse.org/webtools/community/resources/">Resource Page Proposal</a></p>
<p>Naci was approached (and countered) with some proposed articles for Eclipse (online) magazine [need link. only
one I found last published in 2007?] Naci will invite authors for a series of articles for "WTP Uncovered":</p>
<ol>
    <li>web developer tools (xml, xsl, html, css)</li>
    <li>web applications with Java (jsf, jsp, server)</li>
    <li>enterprise application (jpa/ejb)</li>
    <li>soa, webservices</li>
    <li>adopters/extending (maybe)</li>
</ol>
<p>Naci updated us today: Publisher would like all articles in one issue (for an issued focused on WTP). Online
version would be in English. Print version would be translated to German. They'd like one overview article less than
20,000 words, and 4 shorter, but more focused article on specific areas, each less than 10,000 words</p>
<p>Naci will have some Eductation site/materials ready next week.</p>
<p>New Bugzilla component created: "Education".</p>
<p>We will publish education materials under <a href="http://creativecommons.org/licenses/by-sa/3.0/">Creative
Commons -- Attribution Share Alike</a> but still EPL for sample code, examples and snippets.</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><a href="http://wiki.eclipse.org/WTP_3.1_Project_Plan">Planning Process Document</a> has been started.</p>
<p>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).</p>
<hr />
<p>Raghu's Preliminary Note (to PMC PLs)</p>
<p>As you all know, we need to create the project plan for WTP-Galileo in the standard project plan format provided
by the Foundation. We also need to create a plan for each subproject. So I have created the first cut of the plan for
most of the active subprojects in WTP.</p>
<p>I need you to update the projectplanurl field for your project from the Eclipse Portal. For help, see the <a
    href="http://wiki.eclipse.org/Development_Resources/HOWTO/Project_Meta-Data">HOWTO/Project_Meta-Data</a>. I don't
have the permission to update this for all the subprojects. Once you do that, you can view the plan by going to the
standard home for your project, For example, see the one for <a
    href="http://www.eclipse.org/projects/project_summary.php?projectid=webtools">webtools as a whole</a>, scroll down
to the Project Plan section and click on the link that says, "pending standard form".</p>
<p>I would appreciate if you could try this and report your findings at the PMC call tomorrow. I (and David) have
had mixed experiences in viewing this file and hence I want you to test it out before I mail this to all the other
leads.</p>
<p>Following are the URLs to use for each of the subprojects:</p>
<ul>
    <li>EJB Tools: <code>http://www.eclipse.org/webtools/standard-project-plans/galileo/ejb-tools-plan.xml</code></li>
    <li>Dali: <code>http://www.eclipse.org/webtools/standard-project-plans/galileo/dali-plan.xml</code></li>
    <li>Server Tools: <code>http://www.eclipse.org/webtools/standard-project-plans/galileo/server-tools-plan.xml</code></li>
    <li>Releng: <code>http://www.eclipse.org/webtools/standard-project-plans/galileo/releng-plan.xml</code></li>
</ul>
<p>For the community to consume, I am hoping I can aggregate the plans to one plan.</p>
<hr />
<h4>Reference</h4>
<ul>
    <li><a href="http://wiki.eclipse.org/WTP_Requirements_Lead">WTP Requirements Lead Role</a></li>
</ul>
<!-- 

    Planning
 
 -->
<h3>Planning: David Williams</h3>
<h4>long term items to track</h4>
<ul>
    <li>?Pre 1.0 release of ATF component mid October?</li>
    <li>JPT 2.1 (need release review)</li>
    <li>2009, Galileo Release</li>
</ul>
<!-- 
<dl>
    <dt>Notes:</dt>
    <dd>Reminder to be sure to check for <a href="http://www.eclipse.org/webtools/plans/3.0.1/pmc-bug-approval.php">"PMC
    Review" bugs</a>.</dd>
    <dd>Reminded to be consistent in approving defects (such as getting project lead review, documenting "stop
    ship" need, etc.</dd>
</dl>
 -->
<h4>Reference</h4>
<ul>
    <li><a href="http://wiki.eclipse.org/WTP_Planning_Lead">WTP Planning Role</a></li>
    <li><a href="http://wiki.eclipse.org/WTP_Patches_for_Release_2.0.2">patch process document</a></li>
</ul>
<!-- 

    Quality

 -->
<h3>Quality: Neil Hauge</h3>
<dl>
    <dt>Notes:</dt>
    <dd>Current stats:
    <p>1068 opened, since 3.0 release ~ half resolved</p>
    <p>900 opened same period last year ~ similar resolved</p>
    <p>steady "bug growth"</p>
    <p>comparable with other Top Level Projects</p>
    <p>Neil may do more detailed analysis eventually. In particular, it may be important for us to do by
    'sub-project' to compare within our own projects, as well as to other top level ones</p>
    </dd>
    <dd>Neil investigating "close old bugs" policy.</dd>
    <dd>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.).</dd>
</dl>
<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>
<!-- 

General business

 -->
<h2>General business?</h2>
<h3>bugs to watch</h3>
<ul>
    <li style="text-decoration: line-through;">Discussed need for <a
        href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=152461">bug 152461</a></li>
    <li style="text-decoration: line-through;">Also need to watch <a
        href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=245645">bug 245645</a></li>
    <li style="text-decoration: line-through;">Also need to watch <a
        href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=245573">bug 245573</a></li>
</ul>
<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.eclipseworld.net/">Eclipse World</a><br />
    Raghu and Neil have submitted.</li>
    <li><a href="http://www.eclipsecon.org/summiteurope2008/">Eclipse European Summit</a>. <br />
    Kaloyan "wtp project" <br />
    Naci will attend but (probably) not present. <br />
    Neil has submitted for Dali (and Eclipse link) <br />
    Cameron and JSF</li>
    <li><a href="http://www.eclipsecon.org/2009/">EclipseCon 2009</a>. September we'll start recruiting talks.</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>
