<html>
<head>
<title>WTP PMC Minutes for March 28, 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 - March 28, 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],
		Arthur Ryman [AR],
		Naci Dai [ND]
		
		<P>PMC Member Regrets: Jochen Krause
		
		<P>Invited Guests:
		Craig Becker [CB]

        <P>Others:
        Lawrence Mandel [LM]		

<!--PMC MEMBERS NOT PRESENT ON THIS CALL:
-->

<h1>WTP PMC Minutes for March 28, 2006 Conference Call</h1>

<h2>Community Update [LM] </h2>
<ul>
  <li>EclipseCon went well, lots of interest in WTP, including the tutorials,
      talks well attended.
  <li>Feedback for improvement:
    <ul>
      <li>All-in-one ZIP for Macs (Mac users have a hard time with installing;
          each unZip wants to create a new folder, and then they have to manually
          merge).
      <li>Quality (hopefully addressed further in 1.5)
      <li>Support for "small" adopters (hard to understand this one)
      <li>Ongoing requests for more granularity of features (will track and consider)
    </ul>
    <li>Looking for feedback from PHP project folks
    <li>Talked to RadRails implementers, and encouraged them to reconsider WTP/SSE
        infrastructure
    </ul>
<!--  <li>RSS feed being tested; planned to go live along with Phoenix conversion. -->
</ul>

<h2>Procedural [TW] </h2>
<ul>
  <li>[held over] David to investigate granting releng access to Dali committers to enable build
      and release coordination for 1.5. Naci will publish a note on the newsgroup regarding
      the Dali build plans. Initial plan is to build it but not incorporate into our ZIP
      yet (will pursue the same course for ATF and JSF). Raghu and Craig to send list of
      committers to David who should have access to the WTP releng bits.
  <li>Versioning - agreed to 2.0 for the June 2007 (coordinated) release. This will refer to the
      WTP features and marketing version; plugins will follow the API "increment" rules.
  <li>Maintenance schedule - WTP strongly prefers a single street date coordindated with the
      platform. We will
      <ul>
        <li>Strongly request that the platform establish firm maintenance release dates on
            an ongoing basis.
        <li>Request that the platform and our prerequisites agree to a single, coordinated street
            date in the same fashion as the Callisto release for at least our projects (others
            may not elect to opt in). (This in preference to our approach last year of have
            "fast follow on" releases that track the platform.)
        <li>Expect to support both update site (including discovery via the Callisto discovery
            site) and ZIPs (see packaging discussion above) for maintenance releases.
      </ul>
  <li>Packaging in WTP download area for 1.5:
    <ul>
      <li>All-in-one w/ TP
      <li>All-in-one w/ core bits
      <li>Usual separate pieces
    </ul>
</ul>

<h2>1.0.2 Status </h2>
<ul>
  <li>Builds proceeding smoothly
  <li>Need to do a final triage/review this Thursday on the status meeting - component leads
      should come prepared with recommendations to fix/postpone
  <li>Checkins going forward require PMC approval (via email dev list)
  <li>Code freeze is 4/14; ship date is 4/21 (assuming no stop-ship issues).
</ul>

<h2>Callisto / 1.5 Status </h2>
<ul>
  <li>Testing Callisto versus "standalone" WTP - will attempt testing on Callisto bits at
      each milestone/RC; David to investigate easiest way for people to get the bits for testing
  <li>M6 progress
  <li>[held over] Need to bump our (feature) version numbers to 1.5.
  <li>Build infrastructure updated to latest version from the platform (will take effect this week).
</ul>

<h2>Architecture [DW] </h2>
<ul>
  <li>Packages that have "*internal*" in the name will have "x-internal" set in the manifest.
</ul>

<h2>JSF Status [RS] </h2>
<ul>
  <li>Focus on builds, working on integration with Naci.
</ul>

<h2>ATF Status [CB] </h2>
<ul>
  <li>Source code available in Bugzilla
  <li>Still waiting for Godot...
</ul>

<h2>Hot (Adopter) Bug List Process Proposal </h2>
<ul>
  <li>Approval vote held over due to time constraints; previous notes below.
  <li>Goal: Generate hot list from Bugzilla query, control promotion of hot bug request
      to actual hot bug, enable self subscription for requests and simultaneously
      minimize "wtp-dev" noise.
  <li>See proposal text at 
      <a href="http://www.eclipse.org/webtools/adopters/hot_bug_process.html">
       http://www.eclipse.org/webtools/adopters/hot_bug_process.html</a>.
      PMC members should review and be prepared to move on the process vote next week.
</ul>

<h2>Action Items </h2>
<ul>
  <li>[TW] Planning Council discussion about concrete maintenance release dates.
  <li>[DW] Work with webmaster to see if we can get Dali access to the releng component
      of WTP.
  <li>[RS] Track Dali progress on builds and release review for the PMC.
  <li>[TW] Check with Bjorn on ATF provisioning (did this; Bjorn requested that we
           verify filing of the appropriate paperwork)
  <li>[TW] File committership paperwork for newly elected committers (DONE)
  <li>[TW] Check with Janet Campbell on IP review for ATF and IP update status in general.
  <li>[ALL/Held over] Work with JSF and Dali on incubation exit review dates and criteria.
</ul>

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