Path: utzoo!utgpu!news-server.csri.toronto.edu!cs.utexas.edu!swrinde!sdd.hp.com!hp-col!col!denisl
From: denisl@col.hp.com (Denis Lambert)
Newsgroups: comp.object
Subject: Re: Object-Oriented Project Management
Message-ID: <18860001@col.hp.com>
Date: 19 Jun 91 15:38:59 GMT
References: <1991Jun18.124041.11482@grebyn.com>
Organization: HP Colorado Springs Division
Lines: 65

Ron,

Although I have done only a small amount of OOP, we do use quite a bit
of iterative prototyping here, which may or may not be similar.  I can
comment on how the current offering of project management tools really
does fit into this environment.  I have not found it necessary to warp 
the project to fit the tool, or warp the tool to fit the project.  The 
problem with iteration lies in its perceived definition of: keep doing
something until you get it right.  If this is your definition, then
no project management tool or methodology will work.  I prefer to look
at "Objective or Goal Driven" iteration sets.  By this I mean that each
set of iterations should have a clear and well defined goal, such as to
understand the menuing interface system or in the OO sense to design an
implement class strings.  The trick is to decompose the project into a
series of well defined, goal driven iteration sets and to use the project
management tool for what it was designed for, as an overview tool to see
and control an entire project.

Without having objective driven prototyping I have seen many projects
prototype forever.  Each prototype cycle adds to the programmers knowledge
base and forms the catalyst for the creation of new ideas which require
another cycle, which leads to increased knowledge, and so on.  With
objective driven prototyping, no cycle is started until a clear end result
or goal has been established, and the cycle ends when the goal is reached.
Decomposing the project into a series of these objectives fits well within
the current project management models.

What doesn't fit into the current PM models is what goes on within the  
objective, in other words the set of iterations required to achieve the
end result.  Current PM software is not well designed to handle micro-
management.  Its' main purpose is to aid the project manager in seeing
and managing the total project.  What I suggest is to find a project
management tool that supports out-of-sequence progress and task 
summarization.  Primavera, Prestige, OpenPlan, and a few others fill
these requirements (but they may have shortcomings in other areas).  With
these features the objective can be described with summary tasks, and the
details of the set of iterations can be the children of the summary task.
The project would be planned for summary tasks to be performed in the 
order that they have been scheduled, while the details of the summary
task will be performed in an iterative fashion.  The following is an
example of this hierarchy.

	Design and Implement Class String
		Design			4 weeks
		Code			2 weeks
		Test & Evaluate		2 weeks

The summary task, Design and Implement Class String, would have clearly
defined objectives (i.e. efficient string search, concatination, etc.).
The actual process through the details would be to design a little, code
a little, test a little and then repeat the process.  The total amount of 
design would be 4 weeks even though it may be done in one four week chuck
or several 2 or 3 day iterations.  The same holds true for Code and Test
tasks.  Packages that do not allow the detail tasks to be performed in
an out-of-sequence fashion while retaining the overall logic will be a
nightmare in this situation.  Packages such as TimeLine and MS Project
fit this category.  When we report project status, we report the summary
task in a graphical format (Gantt Chart), and report the detail in a
tabular format listing the effort remaining.

Let me know what you think of this.  I would look forward to additional
comments.

Denis Lambert
denisl@col.hp.com