COCOMO Model

1
COCOMO Model: A Heuristic Estimation
Technique

• COCOMO (COnstructive COst MOdel)

proposed by Boehm.

2
COCOMO Model: A Heuristic Estimation Technique

3
COCOMO Product classes
• Roughly correspond to:
• application, utility and system programs
respectively.
• Data processing and scientific programs
are considered to be application programs.
• Compilers, linkers, editors, etc., are utility
programs.
• Operating systems and real-time system
programs, etc. are system programs.
4
Elaboration of Product classes

• Organic:
• Relatively small groups
• working to develop well-understood applications.
• Semidetached:
• Project team consists of a mixture of
experienced and inexperienced staff.
• Embedded:
• The software is strongly coupled to complex
hardware, or real-time systems.
5
COCOMO Model: A Heuristic Estimation Technique

6
COCOMO Model
• For each of the three product
categories:
• From size estimation (in KLOC), Boehm provides
equations to predict:
• project duration in months
• effort in programmer-months
• Boehm obtained these equations:
• examined historical data collected from a
large number of actual projects.

7
Basic COCOMO Model
• Gives only an approximate estimation:
• Effort = a1 * (KLOC) * a2
• Tdev = b1 * (Effort) * b2
• KLOC is the estimated kilo lines of source code,
• a1,a2,b1,b2 are constants for different categories
of software products,
• Tdev is the estimated time to develop the software
in months,
• Effort estimation is obtained in terms of person
months (PMs).

8
Basic COCOMO Model

a1 a2 b1 b2

9
Development Effort Estimation

• Organic :
• Effort = 2.4 (KLOC)1.05 PM
• Semi-detached:
• Effort = 3.0(KLOC)1.12 PM
• Embedded:
• Effort = 3.6 (KLOC)1.20PM
10
Development Time Estimation

• Organic:
• Tdev = 2.5 (Effort)0.38 Months
• Semi-detached:
• Tdev = 2.5 (Effort)0.35 Months
• Embedded:
• Tdev = 2.5 (Effort)0.32 Months
11
Basic COCOMO Model (CONT.)

h ed
c
ta
• Effort is Effort
Se
m
i d e

somewhat b ed
ded

super-linear in Em
Or
ga
n ic

problem size.
Size

12
Basic COCOMO Model
• Development time
• sublinear function of
Dev. Time
product size.
d
ed tache
• When product size be dd
ide
Em Sem
increases two times,
18 Months

• development time 14 Months

ic
gan
does not double. Or

• Time taken:
30K 60K
• almost same for all Size
the three product
categories.
13
Basic COCOMO Model

14
Example
• The size of an organic software product has
been estimated to be 32,000 lines of source
code.

• Effort = 2.4*(32)1.05 = 91 PM
• Nominal development time = 2.5*(91)0.38 = 14
months

15
Example

16
Example

17
Intermediate COCOMO
• Basic COCOMO model assumes
• effort and development time depend on product
size alone.
• However, several parameters affect effort
and development time:
• Reliability requirements
• Availability of CASE tools and modern facilities to
the developers
• Size of data to be handled

18
Intermediate COCOMO
• For accurate estimation,
• the effect of all relevant parameters must be considered:
• Intermediate COCOMO model recognizes this fact:
• refines the initial estimate obtained by the basic COCOMO by using
a set of 15 cost drivers (multipliers).
• If modern programming practices are used,
• initial estimates are scaled downwards.
• If there are stringent reliability requirements on the product :
• initial estimate is scaled upwards.
• Rate different parameters on a scale of one to three:
• Depending on these ratings,
• multiply cost driver values with the estimate obtained using the basic
COCOMO.
19
Intermediate COCOMO

20
Intermediate COCOMO

21
Intermediate COCOMO

22
Intermediate COCOMO

23
Complete COCOMO

24
25
26
27
28
Complete COCOMO Example

• A Management Information System (MIS) for

an organization having offices at several places
across the country:
• Database part (semi-detached)
• Graphical User Interface (GUI) part (organic)
• Communication part (embedded)
• Costs of the components are estimated
separately:
• summed up to give the overall cost of the system.

29
COCOMO 2
• The present day software projects are much larger in
size and reuse of existing software to develop new
products has become pervasive.
• To make COCOMO suitable in the changed scenario,
Boehm proposed COCOMO 2 in 1995.
• COCOMO 2 provides three models to arrive at
increasingly accurate cost estimations.
• These can be used to estimate project costs at
different phases of the software product.
• As the project progresses, these models can be
applied at the different stages of the same project.

30
COCOMO 2
Application composition model:
•This model as the name suggests, can be used to
estimate the cost for prototype development.

Early design model:

•This supports estimation of cost at the architectural
design stage.

Post-architecture model:
This provides cost estimation during detailed design and
coding stages.

31
Application composition model
• It is based on counting the number of screens,
reports, and modules (components).
• Each of these components is considered to be
an object.
• These are used to compute the object points
of the application.

32
Application composition model
• Effort is estimated in the application composition
model as follows:
• 1. Estimate the number of screens, reports, and
modules (components) from an analysis of the SRS
document.
• 2. Determine the complexity level of each screen and
report, and rate these as either simple, medium, or
difficult.
• The complexity of a screen or a report is determined
by the number of tables and views it contains.

33
Application composition model
• Use the weight values in Tables.
• The weights have been designed to correspond to the
amount of effort required to implement an instance of
an object at the assigned complexity class.

34
Application composition model

• Add all the assigned complexity values for the object

instances together to obtain the object points.

35
Application composition model

• Estimate percentage of reuse expected in the system.

Note that reuse refers to the amount of pre-
developed software that will be used within the
system.
• Then, evaluate New Object-Point count (NOP) as
follows

36
Application composition model
• Determine the productivity using Table. The
productivity depends on the experience of the
developers as well as the maturity of the CASE
environment used.
• Finally, the estimated effort in person-months is
computed as E = NOP/PROD.

37
Early design model
• The unadjusted function points (UFP) are counted and
converted to source lines of code (SLOP).
• In a typical programming environment, each UFP would
correspond to about 128 lines of C, 29 lines of C++, or
320 lines of assembly code.
• The conversion from UFP to LOC is environment
specific, and depends on factors such as extent of
reusable libraries supported.
• Seven cost drivers that characterize the post-
architecture model are used.

38
Early design model
• These are rated on a seven points scale.
• The cost drivers include product reliability and
complexity, the extent of reuse, platform
sophistication, personnel experience, CASE support,
and schedule.
• The effort is calculated using the following formula:
• Effort = (KSLOC)scaling factor * Effort Adjustment
Factors * 2.45
• Example

39
40
41
42
43
44
45
46
47