SOFTWARE PROJECT ESTIMATION Software project planning encompasses five major activities

Estimation, scheduling, risk analysis, quality management planning, and change management planning

Estimation determines how much money, effort, resources, and time it will take to build a specific system or product. Define scope and feasibility

Software scope describes

The functions and features that are to be delivered to end users

The data that are input to and output from the system

The "content" that is presented to users as a consequence of using the software

The performance, constraints, interfaces, and reliability that bound the system

Software feasibility has four dimensions

Technology Is the project technically feasible? Is it within the state of the art? Can defects be reduced to a level matching the application's needs?

Finance Is is financially feasible? Can development be completed at a cost that the software organization, its client, or the market can afford?

Time Will the project's time-to-market beat the competition? Resources Does the software organization have the resources needed to succeed

in doing the project? The accuracy of a software project estimate is predicated on

The degree to which the planner has properly estimated the size (e.g., KLOC) of the product to be built

The ability to translate the size estimate into human effort, calendar time, and money

The degree to which the project plan reflects the abilities of the software team The stability of both the product requirements and the environment that supports

the software engineering effort

Options for achieving reliable cost and effort estimates

Delay estimation until late in the project (we should be able to achieve 100% accurate estimates after the project is complete)

Base estimates on similar projects that have already been completed Use relatively simple decomposition techniques to generate project cost and effort

estimates

Use one or more empirical estimation models for software cost and effort estimation

Decomposition techniques

These take a "divide and conquer" approach.

2 approaches are used Problem-based estimation

Based on either source lines of code or function point estimates

Process-based estimation

Based on the effort required to accomplish each task

Empirical estimation models

Offer a potentially valuable estimation approach if the historical data used to seed the estimate is good

PROBLEM BASED ESTIMATION TECHNIQUE 1) Start with a bounded statement of scope

2) Decompose the software into problem functions that can each be estimated individually

3) Compute an LOC or FP value for each function

4) Derive cost or effort estimates by applying the LOC or FP values to your baseline productivity metrics (e.g., LOC/person-month or FP/person-month)

5) Combine function estimates to produce an overall estimate for the entire project

For both approaches, the planner uses lessons learned to estimate an optimistic, most likely, and pessimistic size value for each function or count (for each information domain value)

Then the expected size value S is computed as follows:

S = (Sopt + 4Sm + Spess)/6 EXAMPLE OF LOC BASED ESTIMATION FOR CAD SOFTWARE

Function Estimated LOC

User interface and control facilities (UICF) Two-dimensional geometric analysis (2DGA) Three-dimensional geometric analysis (3DGA) Database management (DBM) Computer graphics display facilities (CGDF) Peripheral control function (PCF) Design analysis modules (DAM)

2,300

5,300

6,800

3,350

4,950

2,100

8,400

Estimated lines of code 33,200

Estimation table

Estimated lines of code = W = 33,200

Let,Average productivity = 620 LOC/pm = X

Labor rate = $8,000 per month = Y

So,Cost per line of code = Z = Y/X = $13 (approx.) Total estimated project cost = W*Z = $431,000 (approx.)

Estimated effort = W/X = 54 person-months (approx)

EXAMPLE OF FP BASED ESTIMATION FOR CAD SOFTWARE

value adjustment factors

Now, FPestimated = count-total [0.65 + 0.01 (Fi)] Fi (i = 1 to 14 are value adjustment factors)

So, FPestimated = W = 320 [0.65 + 0.01 52] = 375 (approx.)

Let, Average Productivity = X = 6.5 FP/pm

Labor rate = Y = $8,000 per month So, Cost per FP = Z = Y/X = $1,230 (approx.) Total estimated project cost = W*Z = $461,000 (approx.) - Estimated effort = W/X = 58 person-months (approx)

EMPIRICAL ESTIMATION MODEL

- Uses empirically derived formulas to predict effort as a function of LOC or FP.

- The empirical data are derived from a limited sample of projects - So, no estimation model is appropriate for all classes of s/w and in all

development environments.

STRUCTURE OF EMPIRICAL MODEL E = A + B (ev)c

Here, A, B, and C are empirically derived constants E is effort in person-months ev is the estimation variable (either LOC or FP)

Example of a LOC-oriented estimation model (Bailey-Basili model) E = 5.5 + 0.73 (KLOC)1.16

Example of a FP-oriented estimation model (Kemerer model) E = -37 + 0.96 FP

The COCOMO II Model (by Barry Boehm) Its a hierarchy of estimation models.

It uses object points.

Object point is computed using counts of the number of Screens (at the user interface) Reports

Components likely to be required to build the application

Object type Complexity weight

Simple Medium Difficult

Screen 1 2 3

Report 2 5 8

3GL component

10

once complexity is determined for each object, the object point count is determined by multiplying the original number of object instances by weighting factor and summing to obtain a total object point. percentage of reuse is estimated and object point count is estimated by,

NOP = (object points) [(100-%reuse)/100] NOP = New Object Points Object Points = Weighted Total %reuse = Percent of reuse

productivity rate is calculated as,

PROD=NOP/Person-month

Estimated Effort is calculated by,

Estimated effort = NOP/PROD

PROD = Productivity Rate, PROD = NOP/person-month

SOFTWARE EQUATION (multivariate model)BY PUTNAM

E = [LOC B0.333/P]3 (1/t4) Here, E = effort in person-months or person-years

t = project duration in months or years B = special skills factor

P = productivity parameter

For small programs (KLOC = 5 to 15), B = 0.16 For programs greater than 70 KLOC, B = 0.39

P = 2000 for development of real-time embedded s/w

P = 10,000 for telecommunication and systems s/w

P = 28,000 for business systems applications

Simplified formulas

tmin = 8.14 (LOC/P)0.43 in months for tmin > 6 months tmin = minimum development time

E = 180 Bt3 in person-months for E 20 person-months

Here t is represented in years