COCOMO-II
COCOMO II
• Includes
– COTS and reusable software
– Degree of understanding of requirements and architectures
– Schedule constraints
– Project size
– Required reliability
• Three Types of Estimation Models
– Application Composition - Prototyping or RAD
– Early Design - Alternative evaluation
– Post-architecture - Detailed estimates
COCOMO-II
• The following categories of application
projects are identified by COCOMO-II.
Stages of COCOMO II
Application Composition
Estimation Model
Object point estimation
• Object points are easier to estimate from a
specification than function points as they are simply
concerned with screens, reports and programming
language modules.
• They can therefore be estimated at a fairly early
point in the development process.
• At this stage, it is very difficult to estimate the
number of lines of code in a system.
• Assess object counts
• Estimate the number of screens, reports and 3 GL
components that will comprise this application.
• Classification of complexity levels
• We have to classify each object instance into
simple, medium and difficult complexity levels
depending on values of its characteristics.
For Screens
For Reports
Assign complexity weight to each object
The weights are used for three object types i.e.,
screen, report and 3GL components using the table.
Complexity weights for each level
• Determine object points
• Add all the weighted object instances to get one number
and this known as object-point count.
• Compute new object points
• We have to estimate the percentage of reuse to be
achieved in a project.
• Depending on the percentage reuse, the new object points
(NOP) are computed.
• NOP are the object points that will need to be developed
and differ from the object point count because there may
be reuse.
(object points) * (100 - %reuse)
NOP = -------------------------------------------
100
• Calculation of productivity rate
Productivity rate (PROD) = NOP/Person month
Productivity values
Compute the effort in Persons-Months
NOP
Effort in PM = ------------
PROD
Example
Consider a database application project with the
following characteristics:
I. The application has 4 screens with 4 views each
and 7 data tables for 3 servers and 4 clients.
II. The application may generate two report of 6
sections each from 07 data tables for two server and
3 clients. There is 10% reuse of object points.
– The developer’s experience and capability in the
similar environment is low.
– The maturity of organization in terms of capability
is also low.
– No. of PM is 7.
– Calculate the object point count, New object
points and effort to develop such a project.
Solution
• This project comes under the category of application
composition estimation model.
• Number of screens = 4 with 4 views each
• Number of reports = 2 with 6 sections each
• From Table, we know that each screen will be of
medium complexity and each report will be difficult
complexity.
Using Table of complexity weights, it may
calculate object point count.
=4x2+2x8
= 24
NOP= 24*(100-10)/100=21.6
Effort in PM = NOP/PRODUCT
= 21.6/7 = 3.086 PM
The Early Design Model
The Early Design Model
• The COCOMO-II models use the base equation
of the form:-
PMnominal= Effort of the project in person
months.
A = Constant representing the nominal
productivity, provisionally set to 2.5
B = Scale factor
Size = Software size
Scaling factors
Data for the Computation of B
B=0.91 + 0.01 * (Sum of rating on scaling factors
for the project)
Early design cost drivers
• Seven early design cost drivers:
i. Product Reliability and Complexity (RCPX)
ii. Required Reuse (RUSE)
iii. Platform Difficulty (PDIF)
iv. Personnel Capability (PERS)
v. Personnel Experience (PREX)
vi. Facilities (FCIL)
vii. Schedule (SCED)
Post Architecture Cost Drivers
• The list of seventeen cost drivers is given
below:-
i. Reliability Required (RELY)
ii. Database Size (DATA)
iii. Product Complexity (CPLX)
iv. Required Reusability (RUSE)
v. Documentation (DOCU)
vi. Execution Time Constraint (TIME)
vii. Main Storage Contraint (STOR)
Viii Platform Volatility (PVOL)
ix. Analyst Capability (ACAP)
x. Programmers Capability (PCAP)
xi. Personnel Continuity (PCON)
xii. Analyst Experience (AEXP)
xiii. Programmer Experience (PEXP)
xiv. Language & Tool Experience (LTEX)
xv. Use of Software Tools (TOOL)
xvi. Site Locations & Communication Technology
between Sites (SITE)
xvii. Schedule (SCED)
Mapping of early design cost drivers and post
architecture cost drivers
• The 17 Post Architecture Cost Drivers are mapped to
7 Early Design Cost Drivers and are given in Table.
Product Reliability and Complexity (RCPX)
The cost driver combines four Post Architecture cost drivers
which are RELY, DATA, CPLX and DOCU.
• Required Reuse (RUSE)
• This early design model cost driver is same as its Post
architecture Counterpart. The RUSE rating levels are (as
per Table 16):
• Platform Difficulty (PDIF)
• This cost driver combines TIME, STOR and PVOL of
Post Architecture Cost Drivers.
Personnel Capability (PERS) :
This cost driver combines three Post Architecture
Cost Drivers.
These drivers are ACAP, PCAP and PCON.
• Personnel Experience (PREX) :
– This early design driver combines three Post
Architecture Cost Drivers, which are AEXP, PEXP
and LTEX.
• Facilities (FCIL):
– This depends on two Post Architecture Cost
Drivers,which are TOOL and SITE.
Schedule (SCED)
This early design cost driver is the same as Post
Architecture Counterpart and rating level are given
below.
• The seven early design cost drivers are converted
into numeric values with a Nominal value 1.0.
• These values are used for the calculation of a factor
called “Effort Multiplier” which is the product of all
seven early design cost drivers.
Early Design parameter
Note
• The early design model adjusts the nominal effort
using 7 effort multipliers(EMs).
• Each effort multiplier (also called drivers) has 7
possible weights. These factors are used for the
calculation of adjusted effort as given below:
• PMadjusted effort may very even up to 400% from
Pmnominal Hence PMadjusted is the fine tuned value of
effort in the early design phase.
Example
• A software project of application generator category
with estimated 50KLOC has to be developed.
• The scale factor (B) has low precedentness, high
development flexibility and low team cohesion.
Other factors are nominal.
• The early design cost drivers like platform difficult
(PDIF) and Personnel Capability (PERS) are high and
others are nominal.
• Calculate the effort in person months for the
development of the project.
Solution
B = 0.91 + 0.01 * (Sum of rating on scaling factors for the project)
= 0.91 + 0.01 * (4.96 + 2.03 + 4.24 + 4.38 + 4.68)
= 0.91 + 0.01(20.29)
=1.1129
= 2.5 * (50)1.1129 = 194.41 Person months
Contd…
• The 7 cost drivers are:-
• PDIF = high (1.29)
• PERS = high (0.83)
• RCPX = nominal (1.0)
• RUSE = nominal (1.0)
• PREX = nominal (1.0)
• FCIL = nominal (1.0)
• SCEO = nominal (1.0)
= 194.41 * [1.29 x 0.83)
= 194.41 x 1.07
= 208.155 Person months Software
Post Architecture Model
Post Architecture Model
• The post architecture model is the most detailed
estimation model and is intended to be used when a
software life cycle architecture has been completed.
• This model is used in the development and
maintenance of software products in the application
generators, system integration or infrastructure
sectors.
Post Architecture Model
Post Architecture Cost Driver rating level summary
Post Architecture Cost Driver rating level summary
Post Architecture Cost Driver rating level summary
• Product complexity is based on control operations,
computational operations, device dependent
operations, data management operations and user
interface management operations.
• The numeric values of these 17 cost drivers are used
in the calculation of the product of efforts i.e., effort
multiplier (EM).
• Hence PM adjusted is calculated which will be a
better and fine tuned value of effort in person
months.
Module complexity ratings
Module complexity ratings
Module complexity ratings
Cost Drivers
Cost Drivers
17 Cost Drivers
Example: Consider Previous Project
• Size and scale factor(B) are the same.
• The identified 17 Cost drivers are high reliability
(RELY),very high database size (DATA), high execution
time constraint (TIME), very high analyst capability
(ACAP), high programmers capability (PCAP).
• The other cost drivers are nominal.
Calculate the effort in Person-Months for the
development of the project.
Solution
