<html>
<head>
<title>WTP PMC Minutes for June 20, 2006 Conference Call</title>
</head>

<body alink="#ff0000" bgcolor="#ffffff" link="#0000ee" text="#000000" vlink="#551a8b">
<table border="0" cellpadding="2" cellspacing="5" width="100%">
  <tbody><tr> 
    <td colspan="2" align="left" bgcolor="#0080c0" valign="top"><b>
    <font color="#ffffff" face="Arial,Helvetica">PMC Conference Call - June 20, 2006</font></b></td>

  </tr>
  </tbody></table>
<table border="0" cellpadding="2" cellspacing="5" width="100%">
  <tbody><tr> 
    <td> 
		PMC Members Attending:
		Tim Wagner [TW],
		Arthur Ryman [AR],
		David Williams [DW],
		Raghunathan Srinivasan [RS],
		
		<P>PMC Member Regrets: none

		<P>Invited Guests: Neil Hauge (Dali), Bob Goodman (ATF),
		Kaloyan Raev (SAP representative addressing Java EE 5 extension points)

        <P>Others:
        Lawrence Mandel [LM]

<!--NOT PRESENT ON THIS CALL:
        Naci Dai [ND]
--><h1>WTP PMC Minutes for June 20, 2006 Conference Call</h1>

<h2>Community Update [LM] </h2>
<ul>
  <li>Site volunteer call will go out this week.
  <li>Inactive committer list drafted; next step is to verify with component leads.
  <li>Tim's interview with Daryl Taft finally happened.
  <li>Callisto launch page being constructed; working with Wayne Beaton to create a simple
      launchpad for web application developers. A demo for WTP install/configure/getting started
      already exists.
<!--  <li>RSS feed being tested; planned to go live along with Phoenix conversion. -->
</ul>

<h2>Procedural [TW] </h2>
<ul>
  <li>Introduction of Bob Goodman from the ATF sub project
  <li>Peter Moogk committership passed
  <li>Dali and JSF review reminder
  <li>Bug milestone targeting: need to drive for realistic targeting,
      versus the "M1 to M2 to M3..." drift.
  <li>Will revisit "expired" bugs post 1.5.
</ul>

<h2>SAP Request for Extension Points </h2>
<ul>
  <li>Review of SAP request for extension points (see Kaloyan's writeup in PMC
      email archives from 6/16/2006).
  <li>PMC wants to support SAP's request, but needs a concrete proposal for
      technical review for 1.5.1 or 2.0. SAP to open a bug and attach design for
      extension points and sample code for evaluation by WTP committers.
      Patches for 1.5.1 should be the minimum change to enable SAP's product goals;
      API/extension point changes for Java EE 5 should go into the 2.0 stream.
</ul>

<h2>1.0.3 and 1.5 Status </h2>
<ul>
  <li>We will archive old release and milestone builds to free up mirror space for Callisto;
      specific list TBD based on download stats.
</ul>

<h2>JSF Status [RS] </h2>
<ul>
  <li>Working on RC5; code freeze except for serious issues.
  <li>Demo on Friday of Sybase visual JSF page designer (11am PDT). This would be
      targeting WTP 2.0 (i.e., not a 1.5.x item).
  <li>Raghu on vacation in July; Gerry Kessler will be available for PMC calls.
</ul>

<h2>Dali Status [NH] </h2>
<ul>
  <li>Last period of bug fixing, scheduled to freeze tomorrow (6/21).
  <li>Repackaging will occur post 0.5 release
  <li>Download should be on the WTP site, but does not require build integration.
      (We will postpone build integration until after the June 30th releases.)
      Manual touchups of download pages may be required; fallback will be a link to
      the Dali 0.5 download page.
</ul>

<h2>ATF Status [Bob Goodman] </h2>
<ul>
  <li>Working on "vnext" milestone planning
  <li>Driving outreach to other companies/potential participants
</ul>

<h2>Action Items </h2>
<ul>
  <li>[LM] 1.5 rollout coverage plan
  <li>[DW/Jeffrey] Old release/milestone archive plan
  <li>SAP will open bugs for 1.5.1 patches to enable their product release and
      2.0 enhancement release for Java EE 5 support
</ul>

<small>Minutes taken by Tim Wagner, June 20, 2006. Please notify me of any corrections needed.
</small>
</tr>
</tbody></table>
</html>
