<HTML>
<HEAD>
</HEAD>
<BODY LANG="en-US" TEXT="#000000" DIR="LTR">
<DIV TYPE=HEADER>
	<P ALIGN=CENTER STYLE="margin-bottom: 0in"><BR>
	</P>
	<P ALIGN=RIGHT STYLE="margin-bottom: 0.3in"><BR>
	</P>
</DIV>
<P CLASS="western" STYLE="margin-bottom: 0in"><FONT SIZE=4><B>NOTE: </B></FONT>
</P>
<P CLASS="western" STYLE="margin-bottom: 0in"><BR>
</P>
<P CLASS="western" STYLE="margin-bottom: 0in"><FONT SIZE=4><B>This
document is a project plan <I>draft</I>, and, as such, is subject to
change by the PMC.</B></FONT></P>
<P CLASS="western" STYLE="margin-bottom: 0in"><BR>
</P>
<P CLASS="western" STYLE="margin-bottom: 0in">During the DTP
face-to-face meeting in April, we identified the following components
and rough milestone schedule:</P>
<P CLASS="western" STYLE="margin-bottom: 0in"><BR>
</P>
<P CLASS="western" STYLE="margin-bottom: 0in"><IMG SRC="../f2fmeeting/dtp_block.jpg" NAME="Graphic1" ALIGN=BOTTOM WIDTH=746 HEIGHT=780 BORDER=0></P>
<P CLASS="western" STYLE="margin-bottom: 0in"><BR>
</P>
<P CLASS="western" STYLE="margin-bottom: 0in">We also mentioned the
following high-level goals:</P>
<P CLASS="western" STYLE="margin-bottom: 0in"><BR>
</P>
<UL>
	<LI><P CLASS="western" STYLE="margin-bottom: 0in">We&rsquo;d like to
	have the first release of DTP before EclipseCon 2006 (EclipseCon06),
	which will be the week of March 20<SUP>th</SUP>.</P>
	<LI><P CLASS="western" STYLE="margin-bottom: 0in">To get a release
	out before EclipseCon06, we could divide the milestone releases
	above into two during Q4/05 and two during Q1/06.</P>
</UL>
<P CLASS="western" STYLE="margin-bottom: 0in"><BR>
</P>
<P CLASS="western" STYLE="text-indent: 0.25in; margin-bottom: 0in">The
purpose of this document is to investigate the assumptions above in
greater detail, with a goal toward adjusting them as necessary, and
providing a fairly detailed project plan for the first DTP release.</P>
<P CLASS="western" STYLE="margin-bottom: 0in"><BR>
</P>
<P CLASS="western" STYLE="text-indent: 0.25in; margin-bottom: 0in">First,
a note about the idea of a &ldquo;numbered release&rdquo; for DTP: By
&ldquo;numbered release,&rdquo; I mean a release designated by a
version number. I hesitate to talk about the &ldquo;DTP 1.0&rdquo;
release until further investigation is conducted because:</P>
<P CLASS="western" STYLE="margin-bottom: 0in"><BR>
</P>
<UL>
	<LI><P CLASS="western" STYLE="margin-bottom: 0in">The definition of
	API tends to be a painstaking process in Eclipse, especially for
	projects that are expected to have a large user community. Following
	the WTP lead, we might want to consider the first release as
	something like &ldquo;0.7,&rdquo; which indicates that the API are
	not final.</P>
	<LI><P CLASS="western" STYLE="margin-bottom: 0in">The desire to
	synchronize major Eclipse project releases: If we go out with a
	point release first, we can then later in FY06 aim to synchronize
	with other major Eclipse projects for a &ldquo;1.0&rdquo; release.
	If the synchronization does not occur in FY06, we can still have a
	&ldquo;1.0&rdquo; release around the time when other Eclipse
	projects tend to release, positioning ourselves better for future
	synchronization. (This argument assumes that an Eclipse
	platform-like release trajectory of roughly one major release per
	year is desirable for DTP as well.)</P>
</UL>
<P CLASS="western" STYLE="margin-left: 0.25in; margin-bottom: 0in"><BR>
</P>
<P CLASS="western" STYLE="margin-left: 0.25in; margin-bottom: 0in">Let&rsquo;s
assume for the moment that the first numbered release of DTP is the
week before EclipseCon06 and work backwards from that.</P>
<P CLASS="western" STYLE="margin-left: 0.25in; margin-bottom: 0in"><BR>
</P>
<P CLASS="western" STYLE="margin-left: 0.25in; text-indent: 0.25in; margin-bottom: 0in">
The last milestone (the fourth) will essentially be the DTP numbered
release in beta form, and the time between the fourth milestone and
the numbered release will be for bug fixes to this milestone. Let&rsquo;s
assume three weeks of bug fixes between the last milestone and the
numbered release. This means that milestone four should be released
during the week of February 20<SUP>th.</SUP></P>
<P CLASS="western" STYLE="margin-left: 0.25in; margin-bottom: 0in"><BR>
</P>
<P CLASS="western" STYLE="margin-left: 0.25in; text-indent: 0.25in; margin-bottom: 0in">
The remaining three milestones form a dependency chain: components in
later milestones depend on those in earlier ones, and hence there is
a limit to the amount of parallel development that can occur. Let&rsquo;s
assume that it will take 5 weeks to build the components added
between milestone 3 and 4. Hence this means that milestone three will
be released during the week of January 9<SUP>th.</SUP></P>
<P CLASS="western" STYLE="margin-left: 0.25in; margin-bottom: 0in"><BR>
</P>
<P CLASS="western" STYLE="margin-left: 0.25in; text-indent: 0.25in; margin-bottom: 0in">
The work between milestone 2 and 3 is substantial, and further is
occurs around the year-end holidays. Let&rsquo;s assume 8 weeks
(including holidays) to complete this work. The means that milestone
2 will be released during the week of November 7<SUP>th</SUP>, 2005.</P>
<P CLASS="western" STYLE="margin-left: 0.25in; margin-bottom: 0in">	</P>
<P CLASS="western" STYLE="margin-left: 0.25in; margin-bottom: 0in">	The
work between milestone 1 and 2 is largely a matter of adding
additional models to DTP. This is one place where parallel
development (milestone 1 and milestone 2) can probably occur, so
let&rsquo;s assume only 2 weeks to go from milestone 1 to milestone
2. This would mean that milestone one would be released during the
week of October 24<SUP>th.</SUP></P>
<P CLASS="western" STYLE="margin-left: 0.25in; margin-bottom: 0in"><BR>
</P>
<P CLASS="western" STYLE="margin-left: 0.25in; text-indent: 0.25in; margin-bottom: 0in">
Finally, there is time required from the start of the project to
complete the work necessary for milestone 1. Although this milestone
seems to be essentially a porting of models already open-sourced in
the WTP/rdb project, we have to be careful to consider that these
model API are not settled (public) in WTP/rdb, so a substantial
effort from the Model Base team will be required. Since these models
are fundamental to the rest of the DTP releases and the DTP user
community, it will be very difficult to change decisions made at this
point. Hence, we have to provide enough time for the Model Base team
to work with the community. Let&rsquo;s assume 5 weeks for all
required activities, making the start of project coding work occur
during the week of September 12<SUP>th.</SUP></P>
<P CLASS="western" STYLE="margin-left: 0.25in; text-indent: 0.25in; margin-bottom: 0in">
<BR>
</P>
<P CLASS="western" STYLE="margin-left: 0.25in; text-indent: 0.25in; margin-bottom: 0in">
Thus, we have a six month project between the start of development
and the first numbered release. While the time between each milestone
might seem sufficient, six months of development for a project the
size of DTP seems fairly aggressive.</P>
<P CLASS="western" STYLE="margin-left: 0.25in; margin-bottom: 0in"><BR>
</P>
<P CLASS="western" STYLE="margin-left: 0.25in; text-indent: 0.25in; margin-bottom: 0in">
Also note that on this plan development would not start until
mid-September, although we currently are only at the beginning of
July. Does this 2.5 month gap mean that we could shift the start of
development back, and hence have a Q4/05 numbered release? I doubt we
could:</P>
<P CLASS="western" STYLE="margin-left: 0.25in; margin-bottom: 0in"><BR>
</P>
<UL>
	<LI><P CLASS="western" STYLE="margin-bottom: 0in">There are summer,
	Thanksgiving, and year-end holidays to consider.</P>
	<LI><P CLASS="western" STYLE="margin-bottom: 0in">There are product
	release consideration for participating companies during the summer
	time frame.</P>
	<LI><P CLASS="western" STYLE="margin-bottom: 0in">WTP will be
	released in late July, making transition of WTP/rdb code and staff
	to DTP impossible until after that date.</P>
</UL>
<P CLASS="western" STYLE="margin-left: 0.25in; margin-bottom: 0in"><BR>
</P>
<P CLASS="western" STYLE="margin-left: 0.25in; text-indent: 0.25in; margin-bottom: 0in">
Thus, it is unlikely that development in DTP could start during July.
It could start in August, however, giving up to a month and a half
earlier start from the above schedule. This would not be enough to
pull the numbered release back before Q1/06, but might provide a
buffer for slippage or (best case) and earlier numbered release,
giving time for more community usage of DTP.</P>
<DIV TYPE=FOOTER>
	<P ALIGN=CENTER STYLE="margin-top: 0.3in; margin-bottom: 0in"><BR>
	</P>
</DIV>
</BODY>
</HTML>