The constructive cost model (COCOMO) is one of the most widely used software cost estimation models. This model is developed by B.W.Boehm in 1981. COCOMO model is based on LOC, i.e., the number of lines of code. This model can be classified into three categories basic, intermediate, and detailed sub-models.

These are the essential parameter of COCOMO which is responsible for the quality of any software product:

Effort: The number of labor required to complete the work. It is measured in person-months units.

Schedule: The amount of time required to complete the work is directly proportional to the effort. It is measured in the unit of time, for example, months, and weeks. 

Various models of COCOMO have been introduced to predict cost estimates at different levels. All the models are applied to different projects according to the requirements. 

Software projects are classified into three categories:

  • Organic
  • Semi-detached
  • Embedded

Organic: In the organic type, the project deals with developing a well-understood application program; the team size is generally small. This category is for the small to medium size software product. In this type, team members have good experience and knowledge. 

Semi-detached: In the semi-detached type, the essential elements are team-size, experience, knowledge of the multiple programming languages. The projects that come under the semi-detached are less familiar and hard to develop. It also requires better guidance, more experienced developers.

Embedded: In the embedded type, a software project requires the highest level of complexity, creativity, and experience. In this category, the larger team size is needed as compared to the previous models. 

Basic COCOMO Model

This model is based on Lines of code. The basic COCOMO model helps to calculate a quick estimation of software development costs. The accuracy of this model is considerably restricted because of the insufficient factor considerations. The Basic COCOMO model’s expression is given as:

 Effort (E) = a*(KLOC)b 
Development Time (Tdev) = c*(E)d 


KLOC is Kilo’s lines of code.

E is the Effort applied in person-month.

Tdev is the development time in months.

The coefficient a,b,c & d are constant and can be calculated using the given table:

Project A b c d
Organic 2.4 1.05 2.5 0.38
Semi-detached 3.0 1.12 2.5 0.35
Embedded 3.6 1.20 2.5 0.32

When we calculate effort and development time, then the average staff size to complete the project should be calculated as:

Average staff size (SS)  = E/Tdev persons

When the project size is calculated, then we will have to calculate productivity level

Productivity (P) = KLOC/E

Intermediate Model

The basic COCOMO model assumes that effort is the only factor, which calculates the number of lines of code and constants with respect to the multiple software systems. The intermediate COCOMO model refines the initial estimate. This estimate is obtained through the basic COCOMO expressions with the help of a set of fifteen cost drivers, based on various attributes of software development. Boehm requires the project manager to rate these fifteen different parameters for a particular project on a scale of one to three. Then based on these three ratings, he suggests an appropriate cost driver value to be multiplied with the initial estimate that was obtained from the basic COCOMO model.

In general, cost drivers can be grouped into four categories:

Product attributes

  • Required software reliability extent (RELY)
  • Size of the application database (DATA)
  • The complexity of the product (CPLX)

Hardware attributes

  • Run-time performance constraints (TIME)
  • Memory constraints (STOR)
  • The volatility of the virtual machine environment (VIRT)
  • Required turnaround time (TIME)

 Personnel attributes

  • Analyst capability (ACAP)
  • Programmer capability (PCAP)
  • Applications experience (AEXP)
  • Virtual machine experience (VEXP)
  • Programming language experience (LEXP)

Project attributes

  • Use of software tools (TOOL)
  • Modern programming practices (MODP)
  • Required development schedule (SCED)
Cost Drivers Ratings
Very low Low Nominal High Very High Extra-High
Product Attributes            
0.75 – 0.70 0.88 0.94 0.85 1.00 1.00 1.00 1,15 1.08 1.15 1.40 1.16 1.30 – – 1.65
Computer Attributes            
– – – – – – 0.87 0.87 1.00 1.00 1.00 1.00 1.11 1.06 1.15 1.07 1.30 1.21 1.30 1.15 1.66 1.56 – –
Personnel Attributes            
ACAP AEXP PCAP VEXP LEXP 1.46 1.29 1.42 1.21 1.14 1.19 1.13 1.17 1.10 1.07 1.00 1.00 1.00 1.00 1.00 0.86 0.91 0.86 0.90 0.95 0.71 0.82 0.70 – –   – – – – –
Project Attribute            
MODP TOOL SCED 1.24 1.24 1.23 1.10 1.10 1.08 1.00 1.00 1.00 0.91 0.91 1.04 0.82 0.83 1.10 – – –

Detailed Model

In detailed COCOMO, a large amount of work has been done by Boehm to cover all essential aspects of software development. It offers a medium to process all the project characteristics for calculating the software estimation. The detailed model introduces two more capabilities that are as follows:

Phase-sensitive effort multiplier:

Some phases (like design, programming, integration/test) are more affected than others by factors defined by the cost drivers. The detailed model provides a set of phase-sensitive effort multipliers for each cost driver. This helps in determining the workforce allocation for each phase of the project.

Three-level product hierarchy: 

In the three-level product hierarchy, there are a module, subsystem, and system levels. The ratings of the cost driver are done at an appropriate level, i.e., the level at which it is most affected by the variation.

Development phase

Software development is done in four phases:


This is the first phase of the software development life cycle. In this phase, the requirements are analyzed, the product plan is set up, and a full product specification is generated for software development. The developers have to give 6% to 8% of the effort and 10% to 40% of the development time.

Product design:

In this phase, a software developer starts thinking about “how.” How a software UI look like?  How do they function? The software requirements required by the customers are kept in the mind of the designer while designing software. There are two types of designs that are designed by the designer; conceptual design and technical design. Conceptual design tells the customer what the system will exactly do. When the customer approves the design, this process is called validation. Then the conceptual design is converted into a more detailed form of technical design, which helps the developer to understand the hardware and software needs to fulfill the customer’s requirement.    


This is the phase where development starts. This phase is divided into two sub-phases: detailed design and code/unit test. This phase requires an effort from 48% to 68% and necessitate 24% to 64% of the development time to finish the coding.


In the integration testing, individual units are combined and tested as a whole. The purpose of this level of testing is to expose faults in the interaction between integrated units.

Pin It on Pinterest

Share This