<html>
<head>
<title>WTP PMC Minutes for August 15, 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 - August 15, 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],
		David Williams [DW],
		Raghunathan Srinivasan [RS]
		<P>PMC Member Regrets: Jochen, Naci
		<P>Invited Guests: Robert Goodman (ATF),
		                   Neil Hauge (Dali)
        <P>Others:
        Lawrence Mandel [LM]

<h1>WTP PMC Minutes for August 15, 2006 Conference Call</h1>

<h2>Community [LM] </h2>
<ul>
  <li>Tim and Lawrence continuing to look for website supporters - support from member companies,
      advertising on the WTP website, etc.
  <li>Planning continues for Eclipse Summit Europe.
</ul>

<h2>Process [TW] </h2>
<ul>
  <li>Dali and JSF 0.5 release paperwork has been completed and this issue closed.
  <li>Instantiations researching open source project EULA; no new information to report.
  <li>Committer permission review continues; new spreadsheet received from Sharon Corbett.
      Four committers removed (see next item), plus ongoing corrections for sub-project leads.
  <li>Inactive committer update: Four committers resigned of the six we attempted communication
      with. One we have been unable to contact so far, the other expressed some interest in future
      involvement.
</ul>

<h2>Requirements and Planning [TW] </h2>
<ul>
  <li><a href="http://wiki.eclipse.org/index.php/WTP_and_STP_Collaboration">WTP/STP Collaboration Wiki</a> created.
  <li>Next stage in requirements and planning will likely occur the first / second week of September;
      this will include additional detail from component leads as well as an open community requirements call.
  <li>Sybase visual editor code has been deposited into Bugzilla. Tim to follow up with Sybase on
      creation and staffing of component to support and integrate this code drop.
</ul>

<h2>1.5.1 and 2.0 Status [DW] </h2>
<ul>
  <li>1.5.1 builds ok. Rampdown plan included in agenda and will be distributed to wider WTP team.
  <li>Plugin ranges still being adjusted for 2.0; no successful build yet for 3.3 base. Ongoing push
      for accuracy here (including a reflection of where non-APIs are required.)
</ul>

<h2>JSF Status [RS] </h2>
<ul>
  <li>0.5.1 to be released using the WTP 1.5.1 rampdown schedule.
  <li>Still gathering requirements for 2.0 release.
</ul>

<h2>Dali Status [NH] </h2>
<ul>
  <li>0.5.1 plans TBD based on community feedback regarding critical or blocking issues.
  <li>Executing to plan from last month's planning cycle.
  <li>Ongoing conversation with JDT UI and Core on annotation support.
</ul>

<h2>ATF Status [RG] </h2>
<ul>
  <li>ATF internal review as part of planning process. Next minor release targeting end of August
      or beginning of September.
  <li>Complaints about installation (particularly the large number of 3rd party dependencies
      and the difficulty of getting those) are leading to a request to redistribute these
      dependencies as part of the ATF distribution. These will be shared with other Eclipse projects
      where that makes sense.
  <li>Ongoing discussions with 3rd parties who may be able to cooperate, including student interns
      possibly interested in ATF.
</ul>

<h2>Action Items and Owners </h2>
<ul>
  <li>Tim to follow up with Sybase on visual editor contribution and staffing plans for it.
  <li>Tim to post 1.5.1 rampdown to dev group, Wiki, and project metadata.
  <li>Tim to continue working with Sharon Corbett on permissions review and policy adherence.
</ul>

<small>Minutes taken by Tim Wagner, August 15, 2006. Please notify me of any corrections needed.
Amended 8/22/2006 to correct date in title.
</small>
</tr>
</tbody></table>
</html>
