Estimation tools for agile software development - Software-Eng

iyerra wrote:

> Stabilization of the software build will occur via multiple iterations.
> There is no apriori determination of the specific number of iterations
> that will occur during the project. However, the non-negotiable goal
> is to deliver a production release that meets customer requirements by
> a certain date.

The best strategy is to identify a customer or liaison who will accept
delivery. They should review every iteration, and rate how close it is to
acceptance. And they should select which features to implement in each
iteration. This means they are empowered to rank features by priority, and
they are empowered to accept the production release when it arrives.

Do not let one person (even you) rank the features while another person will
accept the final delivery. The goal is whoever accepts that delivery should
have no surprises whatsoever. They should have known for a while exactly
what will be in the delivery, in detail.

> I have created a working schedule of the software project in MS
> Project. Maintaining the sequencing among C_i, C_j (i, j ranging from 1
> to 20) has been represented manually since it requires domain knowledge
> of "what to build when" and in what order. Some developer and tester
> resources have been assigned to the project.

The problem here is MS Project is very agreeable, and is much more likely to
accept every iteration. You need a human in this role; someone who will push
back.

> However, in order to do effective and efficient "what-if" ****ysis, I
> have been somewhat stymied. For example, if I want to (1) change the
> relative ordering among the components or (2) change the resource
> assignment for a certain component (or a set of components), I have to
> perform these operations manually and is very labor intensive (or
> simply put, an exercise in raising my tenacity quotient).

Right - you are stretching MS Project outside its usability envelop.

However, even if you could do those ****yses, you are no closer to
satisfying a real customer.

> At the same time, my goal, as stated at the outset, is to create a
> realistic schedule for the project and then do a deep dive into the
> execution of the work that needs to get done in order to deliver the
> project. The schedule that I want to create should be closely aligned
> with some of the numbers that I would visualize while using
> http://construx.com/products/estimate.php. Are there any other tools
> that I should consider?

You seem to have "****ysis paralysis". Start your project, with Test-Driven
Development, and target the highest value features. Ask yourself (_and_ ask
your Onsite Customer) what's the minimum functionality that could _possibly_
be useful if you had to deliver _this Friday_.

(You can also add a little fudge-factor time for setting up your build
environment, configuring a version controller, launching your test rig,
etc.)

Work a real iteration, and you will have real data - how long each feature
took. Use this information to select the features for the next iteration.
And _again_ play the game "if we had to ship this Friday, what's the minimum
set of new features we must add?"

Also, each Friday, build a release version of the program (yes, installer
and everything) and give it to the Onsite Customer. They should already know
what's in it, and they should be able to demo it. They will use it to select
the next set of features.

--
Phlip
http://www.greencheese.org/ZeekLand <-- NOT a blog!!!

Responding to Iyerra...

> I am in the process of creating a realistic schedule for a software
> project. We have identified approximately 20 components that need to be
> designed and implemented. For the sake of discussion, assume that these
> components are numbered C_1, C_2, ..., C_20. There is a relative
> ordering among these components for the developer team (in terms of how
> they are going to be coded). A similar (or different) ordering will be
> used by the testing team during quality assurance. This ordering is
> captured in my project plan.
>
> Stabilization of the software build will occur via multiple iterations.
> There is no apriori determination of the specific number of iterations
> that will occur during the project. However, the non-negotiable goal
> is to deliver a production release that meets customer requirements by
> a certain date.

So neither the feature set nor the date are negotiable. Therefore
traditional agile "steering" is irrelevant and what you have is a pure
resource allocation problem. IOW, you want to know how many bodies you
will need. Is that correct?

> I have created a working schedule of the software project in MS
> Project. Maintaining the sequencing among C_i, C_j (i, j ranging from 1
> to 20) has been represented manually since it requires domain knowledge
> of "what to build when" and in what order. Some developer and tester
> resources have been assigned to the project.
>
> However, in order to do effective and efficient "what-if" ****ysis, I
> have been somewhat stymied. For example, if I want to (1) change the
> relative ordering among the components or (2) change the resource
> assignment for a certain component (or a set of components), I have to
> perform these operations manually and is very labor intensive (or
> simply put, an exercise in raising my tenacity quotient).

Right. Scheduling programs like Project can't do What-If ****ysis.
(They can't even do leveling right for a single project much of the
time!) AFAIK, there are no such tools but I would do some googling for
"resource allocation" anyway.

If you can't find one, I would suggest just writing one that is tailored
to this problem. Assume you do one component at a time to completion,
however many iterations that takes. Then you have exactly 20 components
with a <presumably> small set of fixed dependencies. Now your
allocation program has two loops: identifying valid ordering
combinations of the 20 components and, for each ordering combination,
applying 1-N resources to each component so that every combination of
resources and component is computed. For every combination, compute
total elapsed time and dump the data for the current best compared to
schedule.

This should be pretty easy to code up but make sure you have a fast
computer because you are dealing with iterations of order 20**N. B-)
You could put in the third level of iteration to deal with development
iterations for each component with 1-N resources, but that will be a
pretty big problem computationally. So I would do the simple
assumptions first and see how long it takes.

[Note that if computation is feasible, there are variations that
shouldn't be to tough to code with some simplifying assumptions. For
example, you could allow two components to overlay so long as the sum of
resources on the overlapping iterations was less than some total
constraint. As long as only two components overlap, that sort of
"walking" is pretty straight forward. However, you would have to think
of it as sets of iterations that slide in time, depending on resources.]


*************
There is nothing wrong with me that could
not be cured by a capful of Drano.

H. S. Lahman
hsl{}pathfindermda.com
Pathfinder Solutions -- Put MDA to Work
http://www.pathfindermda.com
blog: http://pathfinderpeople.blogs.com/hslahman
(888)OOA-PATH