<html>
<head>
<title>WTP PMC Minutes for May 30, 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 - May 30, 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],
		Arthur Ryman [AR],
        Naci Dai [ND]
		
		<P>PMC Member Regrets: Jochen Krause [JK]

		<P>Invited Guests: Neil Hauge

        <P>Others:
        Lawrence Mandel [LM]

<!--NOT PRESENT ON THIS CALL:
		Raghunathan Srinivasan [RS],
-->

<h1>WTP PMC Minutes for May 30, 2006 Conference Call</h1>

<h2>Community Update [LM] </h2>
<ul>
  <li>JavaOne update: see minutes for last week's status call. Lots of
      interest in 1.5 and 2.0/Java EE 5. Lots of confusion around Callisto.
  <li>JDJ article on Callisto being written (Tim provided quote to author)
  <li>LinuxWorld conference - if any WTP members are attending could give
      demos of WTP in the Eclipse booth (Aug, SF).
  <li>Tim being interviewed by Daryl Taft for Callisto article on Thursday; opportunity
      to address some of the Callisto confusion (see J1 feedback above).
  <li>Arthur presenting on WTP at the Rational conference next week
  <li>Eclipse Webinar (WTP and TPTP joint) coming up on June 12th
  <li>Callisto stats (Ian's request): 
<!--  1.5 site coverage: do this in 2 weeks! -->
<!--  <li>RSS feed being tested; planned to go live along with Phoenix conversion. -->
</ul>

<h2>Procedural [TW] </h2>
<ul>
  <li>Internal Dali/JSF release review scheduling: invitation will be open to
      entire WTP community. Time: Noon PDT / 3 EDT on Wednesday, June 7th.
  <li>External (EMO) Dali/JSF release review scheduling: Wednesday, June 21st.
</ul>

<h2>1.0.3 and 1.5 Status </h2>
<ul>
  <li>No change in 1.0.3 (no build) since last week. <em>Please review approval list.</em>
      Next weekly I-build planned for one week from now.
  <li>1.5 component-level triage planned for Thursday status call
  <li>PMC-level triage begins Thursday, June 1st
  <li>Naci will set up IRC channel for PMC approval actions
</ul>

<h2>Dali Status [NH] </h2>
<ul>
  <li>See email for information going into release review (docs, etc.)
  <li>Preparing for internal and external release reviews
</ul>

<h2>Action Items </h2>
<ul>
  <li>[all PMC members, held over] Work through Dali and JSF tutorials and prepare list of
      questions for internal review
  <li>[TW] send email followup reminding all PMC members of JSF and Dali internal review date/time;
      if this slot works for a quorum, then expand invite to entire community [in flight]
  <li>[TW] Press calls (Daryl Taft, etc.)
  <li>[Jeffrey] LOC count for Ian's press activities
  <li>[TW] Work on other stats for Ian
  <li>[TW/AR] Continue EclipseWorld f2f planning (Tim to research travel budget)
  <li>[AR] Send out component-level triage request in advance of Thursday's status call
</ul>

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