Soft
Software Engineering (3161605)
Practical – 7
AIM: Solve the problem by applying the basic COCOMO model.
● Objectives:
1. Categorize projects using COCOMO, and estimate effort and development time
required for a project.
● Theory
A software project is not just about writing a few hundred lines of source code to
achieve a particular objective. The scope of a software project is comparatively quite
large, and such a project could take several years to complete. However, the phrase
"quite large" could only give some (possibly vague) qualitative information. As in any
other science and engineering discipline, one would be interested to measure how
complex a project is. One of the major activities of the project planning phase, therefore,
is to estimate various project parameters in order to take proper decisions. Some
important project parameters that are estimated include:
Project size: What would be the size of the code written say, in number of lines, files,
modules?
Cost: How much would it cost to develop a software? A software may be just pieces of
code, but one has to pay to the managers, developers, and other project personnel.
Duration: How long would it be before the software is delivered to the clients?
Effort: How much effort from the team members would be required to create the
software?
In this experiment we will focus on two methods for estimating project metrics:
COCOMO
COCOMO (Constructive Cost Model) was proposed by Boehm. According to him,
there could be three categories of software projects: organic, semidetached, and
embedded. The classification is done considering the characteristics of the software, the
development team and environment. These product classes typically correspond to
application, utility and system programs, respectively. Data processing programs could
be considered as application programs. Compilers, linkers, are examples of utility
programs. Operating systems, real-time system programs are examples of system
programs. One could easily apprehend that it would take much more time and effort to
develop an OS than an attendance management system.
The concept of organic, semidetached, and embedded systems are described below.
Organic: A development project is said to be of organic type, if The project deals with
developing a well understood application The development team is small The team
members have prior experience in working with similar types of projects
Semidetached: A development project can be categorized as semidetached type, if
Soft
Software Engineering (3161605)
The team consists of some experienced as well as inexperienced staff Team members
may have some experience on the type of system to be developed
Embedded: Embedded type of development project are those, which Aims to develop
a software strongly related to machine hardware Team size is usually large
Boehm suggested that estimation of project parameters should be done through three
stages: Basic COCOMO, Intermediate COCOMO, and Complete COCOMO.
Basic COCOMO Model
The basic COCOMO model helps to obtain a rough estimate of the project parameters.
It estimates effort and time required for development in the following way:
Effort = a * (KDSI)b PM
Tdev = 2.5 * (Effort)c Months
where
▪ KDSI is the estimated size of the software expressed in Kilo Delivered Source
Instructions
▪ a, b, c are constants determined by the category of software project
▪ Effort denotes the total effort required for the software development, expressed
in person months (PMs)
▪ Tdev denotes the estimated time required to develop the software (expressed in
months)
The value of the constants a, b, c are given below:
Software project a b c
Organic 2.4 1.05 0.38
Semi-detached 3.0 1.12 0.35
Embedded 3.6 1.20 0.32
COCOMO Model Calculation For Hospital Management System
1. Function Point Analysis (FPA)
Identify Functional Requirements for a Healthcare Patient Portal:
• User Inputs: Patient registration, appointment scheduling, medical records access.
• User Outputs: Reports, notifications, user dashboards.
• User Inquiries: Search for doctors and services.
• Internal Logical Files (ILFs): Patient records, appointment data.
• External Interface Files (EIFs): Interfaces with insurance providers, labs.
Assign Complexity Weights
(Using standard IFPUG weights):
Soft
Software Engineering (3161605)
Function Type Low Average High
User Inputs (EI) 3 4 6
User Outputs (EO) 4 5 7
User Inquiries (EQ) 3 4 6
Internal Logical Files (ILF) 7 10 15
External Interface Files (EIF) 5 7 10
Note: The weights in your version were slightly off; these are from the standard FPA.
Function Counts and Complexity:
• 5 User Inputs (Average): 5 × 4 = 20
• 3 User Outputs (Average): 3 × 5 = 15
• 2 User Inquiries (Low): 2 × 3 = 6
• 4 Internal Logical Files (High): 4 × 15 = 60
• 2 External Interface Files (Average): 2 × 7 = 14
Total Function Points (FP) = 20 + 15 + 6 + 60 + 14 = 115 FP
(Your earlier total was 122 FP using different weights. With IFPUG standard weights, it’s 115.)
2. COCOMO Estimation
Convert FP to KLOC
A typical rough estimate is:
• 1 FP ≈ 80 LOC (industry average for business apps)
So,
115 FP × 80 = 9200 LOC
KLOC = 9200 / 1000 = 9.2 KLOC
COCOMO Effort Estimation (Basic Model)
Formula:
E = a × (KLOC)^b
For Semi-detached type project:
• a = 3.0
• b = 1.12
Soft
Software Engineering (3161605)
So,
E = 3.0 × (9.2)^1.12 ≈ 3.0 × 11.2 ≈ 33.6 person-months
3. Summary
Metric Value
Total Function Points 115 FP
Estimated KLOC 9.2 KLOC
Estimated Effort ~33.6 person-months
Estimated Duration (Use COCOMO duration formula if needed)
4. Additional Considerations
• Risk Factors: Regulatory compliance (HIPAA), data security, third-party integrations.
• Team Experience: Adjust effort for experienced vs. novice teams.
• Tools & Technology Stack: Modern frameworks may reduce LOC/FP ratio.
• Productivity Factor: Customize estimation with local productivity data for better accuracy.
Conclusion
This estimation provides a solid initial project cost and effort baseline using FP and the COCOMO
model. It must be continuously refined as detailed requirements emerge. Tailor it to reflect your
team’s experience, tech stack, and project risks for a more accurate and reliable project plan.
Quiz:
1. Assume that the size of an organic type software product has been estimated to be 32,000 lines of
source code. Assume that the average salary of software engineers be Rs. 15,000/- per month.
Determine the effort required to develop the software product and the nominal development time.
Solution :
Ans:-
Given Information:
• Size of the software product = 32,000 lines of code (32 KLOC)
• Type of software = Organic (relatively small and simple)
• Average salary = Rs. 15,000 per month
• COCOMO constants for Organic software:
Soft
Software Engineering (3161605)
o a=2.4
o b=1.05
o c=2.5
o d=0.38
CALCULATE EFFORT (in person-months)
Effort(E):
E = a × (KLOC)^b
= 2.4 × (32) ^ 1.05
= 81.31
Calculate Development Time (in months)
Time (T):
T = c×(E) ^ d
= 2.5 × (81.31) ^ 0.38
= 15.83 months
Suggested Reference:
1) Roger S. Pressman, Software Engineering- A practitioner’s Approach, McGraw-Hill
International Editions
References used by the students:
Rubric wise marks obtained:
Rubrics 1 2 3 4 5 Total
Soft
Software Engineering (3161605)
Marks Complete Complete Complete Complete Complete
implementation as implementation as implementation as implementation as implementation as
asked asked asked asked asked
Problem analysis Problem analysis Problem analysis Problem analysis
Development of the Development of the Development of the
Solution Solution Solution
Concept Clarity & Concept Clarity &
understanding understanding
Correct answer to all
questions
Signature of Faculty:
