COCOMO Model

COCOMO Model is a procedural cost estimate model for Software Projects and is often used as a process of reliably predicting the various parameters associated with making a project such as size, effort, cost, time, and quality.

• Helps in estimating effort and development time (schedule) required for a software project.
• It provides a way to calculate cost based on project size and resources needed.
• It ensures better planning and quality prediction by analyzing project parameters in advance

Types of Projects in COCOMO Model

1. Organic: Organic projects are simple and well-understood software systems that are developed by small teams with prior experience in similar projects.

• Small team size with good experience
• Problem is well-defined and previously solved
• Development is relatively easy and less complex

2. Semi-Detached: Semi-detached projects are moderately complex systems where team experience and project requirements fall between organic and embedded types.

• Medium team size with mixed experience levels
• Project is less familiar and moderately difficult
• Requires better planning, guidance, and creativity

3. Embedded: Embedded projects are highly complex and challenging systems that operate under strict constraints such as hardware, software, or regulations.

• Large team size with high expertise required
• High complexity with strict constraints
• Requires strong creativity and advanced development skills

Comparison of Types of Projects in COCOMO Model

Structure of COCOMO Model

Detailed COCOMO is an advanced software cost estimation model that extends Intermediate COCOMO. It divides the software into different modules, estimates the effort for each module separately, and then combines the results. It also evaluates the impact of cost drivers on each phase of the Software Engineering Process for more accurate effort estimation.

Phases of COCOMO Model:

1. Planning & Requirements: Define project goals, scope, and requirements.
2. System Design: Create the overall architecture of the system.
3. Detailed Design: Design individual modules, data structures, and interfaces.
4. Coding & Unit Testing: Develop and test each module.
5. Integration & Testing: Combine modules and test the complete system.
6. Maintenance: Modify and improve the software after deployment.

Importance

• Cost Estimation: To help with resource planning and project budgeting, COCOMO offers a methodical approach to software development cost estimation.
• Resource Management: By taking team experience, project size, and complexity into account, the model helps with efficient resource allocation.
• Project Planning: COCOMO assists in developing practical project plans that include attainable objectives, due dates, and benchmarks.
• Risk management: Early in the development process, COCOMO assists in identifying and mitigating potential hazards by including risk elements.
• Support for Decisions: During project planning, the model provides a quantitative foundation for choices about scope, priorities, and resource allocation.
• Benchmarking: To compare and assess various software development projects to industry standards, COCOMO offers a benchmark.
• Resource Optimization: The model helps to maximize the use of resources, which raises productivity and lowers costs.

Types of COCOMO Model

1. Basic COCOMO Model: The Basic COCOMO model is a straightforward way to estimate the effort needed for a software development project. It uses a simple mathematical formula to predict how many person-months of work are required based on the size of the project, measured in thousands of lines of code (KLOC).

It estimates effort and time required for development using the following expression:

E = a \times (\mathrm{KLOC})^{b}

T_{dev} = c \times E^{d}

\text{Persons Required} = \frac{\text{Effort}}{\text{Time}}

Where,

• E is effort applied in Person-Months
• KLOC is the estimated size of the software product indicate in Kilo Lines of Code
• Tdev is the development time in months
• a, b, c are constants determined by the category of software project given in below table.

The above formula is used for the cost estimation of the basic COCOMO model and also is used in the subsequent models. The constant values a, b, c, and d for the Basic Model for the different categories of the software projects are:

• The effort is measured in Person-Months and as evident from the formula is dependent on Kilo-Lines of code. The development time is measured in months.
• These formulas are used as such in the Basic Model calculations, as not much consideration of different factors such as reliability, and expertise is taken into account, henceforth the estimate is rough. 

Example: For a project of 400 KLOC, the effort and development time using the Basic COCOMO Model are:

• Organic Mode: Effort ≈ 1295 person-months, Development Time ≈ 38 months
• Semi-Detached Mode: Effort ≈ 2462 person-months, Development Time ≈ 38 months
• Embedded Mode: Effort ≈ 4772 person-months, Development Time ≈ 38 months

The calculations are performed using the respective COCOMO constants (a, b, c, and d) for each development mode.

Below are the programs for Basic COCOMO Model:

// C++ program to implement basic COCOMO
#include <bits/stdc++.h>

using namespace std;

// Function For rounding off float to int
int fround(float x)
{
    int a;
    x = x + 0.5;
    a = x;
    return (a);
}

// Function to calculate parameters 
// of Basic COCOMO
void calculate(float table[][4], int n, 
               char mode[][15], int size)
{
    float effort, time, staff;

    int model;

    // Check the mode according to size
    // organic
    if (size >= 2 && size <= 50)
        model = 0; 

    // semi-detached
    else if (size > 50 && size <= 300)
        model = 1; 

    // embedded
    else if (size > 300)
        model = 2; 

    cout << "The mode is " << mode[model];

    // Calculate Effort
    effort = table[model][0] * pow(size, 
                                   table[model][1]);

    // Calculate Time
    time = table[model][2] * pow(effort, 
                                 table[model][3]);

    // Calculate Persons Required
    staff = effort / time;

    // Output the values calculated
    cout << "\nEffort = " << effort << 
            " Person-Month";

    cout << "\nDevelopment Time = " << time << 
            " Months";

    cout << "\nAverage Staff Required = " << 
            fround(staff) << " Persons";
}

// Driver code
int main()
{
    float table[3][4] = {2.4, 1.05, 2.5, 0.38, 3.0, 1.12,
                         2.5, 0.35, 3.6, 1.20, 2.5, 0.32};

    char mode[][15]
        = {"Organic", "Semi-Detached", "Embedded"};

    int size = 4;

    calculate(table, 3, mode, size);

    return 0;
}

import java.util.Arrays;

public class BasicCOCOMO
{
    private static final double[][] TABLE = 
    {
        {2.4, 1.05, 2.5, 0.38},
        {3.0, 1.12, 2.5, 0.35},
        {3.6, 1.20, 2.5, 0.32}
    };
    private static final String[] MODE = 
    {
        "Organic", "Semi-Detached", "Embedded"
    };

    public static void calculate(int size) 
    {
        int model = 0;

        // Check the mode according to size
        if (size >= 2 && size <= 50) 
        {
            model = 0;
        } else if (size > 50 && size <= 300) 
        {
            model = 1;
        } else if (size > 300) 
        {
            model = 2;
        }

        System.out.println("The mode is " + MODE[model]);

        // Calculate Effort
        double effort = TABLE[model][0] * Math.pow(size, 
                                                   TABLE[model][1]);

        // Calculate Time
        double time = TABLE[model][2] * Math.pow(effort, 
                                                 TABLE[model][3]);

        // Calculate Persons Required
        double staff = effort / time;

        // Output the values calculated
        System.out.println("Effort = " + Math.round(effort) + 
                           " Person-Month");
        System.out.println("Development Time = " + Math.round(time) + 
                           " Months");
        System.out.println("Average Staff Required = " + Math.round(staff) + 
                           " Persons");
    }

    public static void main(String[] args) 
    {
        int size = 4;
        calculate(size);
    }
}

# Function to calculate parameters of Basic COCOMO
def calculate(table, n ,mode ,size):
    effort = 0
    time = 0
    staff = 0
    model = 0
    
    # Check the mode according to size
    if(size >= 2 and size <= 50):
        model = 0
    elif(size > 50 and size <= 300):
        model = 1
    elif(size > 300):
        model = 2
    
    print("The mode is ", mode[model])
    
    # Calculate Effort
    effort = table[model][0]*pow(size, table[model][1])
    
    # Calculate Time
    time = table[model][2]*pow(effort, table[model][3])
    
    #Calculate Persons Required
    staff = effort/time;
    
    # Output the values calculated
    print("Effort = {} Person-Month".format(round(effort)))
    print("Development Time = {} Months".format(round(time)))
    print("Average Staff Required = {} Persons".format(round(staff)))

table = [[2.4, 1.05, 2.5, 0.38],
         [3.0, 1.12, 2.5, 0.35],
         [3.6, 1.20, 2.5, 0.32]]
mode = ["Organic","Semi-Detached","Embedded"]
size = 4;
calculate(table, 3, mode, size)

# This code is contributed by yashpra1010.

using System;

class Program {
 
  // Function to calculate parameters of Basic COCOMO
    static void calculate(double[, ] table, int n,
                          string[] mode, int size)
    {
        double effort = 0, time = 0, staff = 0;
        int model = 0;

        // Check the mode according to size
        if (size >= 2 && size <= 50) {
            model = 0;
        }
        else if (size > 50 && size <= 300) {
            model = 1;
        }
        else if (size > 300) {
            model = 2;
        }

        Console.WriteLine("The mode is " + mode[model]);

        // # Calculate Effort
        effort = table[model, 0]
                 * Math.Pow(size, table[model, 1]);
        time = table[model, 2]
               * Math.Pow(effort, table[model, 3]);

        // Calculate Persons Required
        staff = effort / time;

        Console.WriteLine("Effort = " + Math.Round(effort)
                          + " Person-Month");
        Console.WriteLine("Development Time = "
                          + Math.Round(time) + " Months");
        Console.WriteLine("Average Staff Required = "
                          + Math.Round(staff) + " Persons");
    }

    static void Main(string[] args)
    {
        double[, ] table = { { 2.4, 1.05, 2.5, 0.38 },
                             { 3.0, 1.12, 2.5, 0.35 },
                             { 3.6, 1.20, 2.5, 0.32 } };
        string[] mode
            = { "Organic", "Semi-Detached", "Embedded" };
        int size = 4;

        calculate(table, 3, mode, size);
    }
}

// This code is contributed by Shiv1o43g

// Javascript program to implement basic COCOMO

// Function to calculate parameters of Basic COCOMO
function calculate(table,n,mode,size)
{
    var effort,time,staff,model;

    // Check the mode according to size

    if (size >= 2 && size <= 50)
        model = 0; // organic

    else if (size > 50 && size <= 300)
        model = 1; // semi-detached

    else if (size > 300)
        model = 2; // embedded
    

    console.log("The mode is ",mode[model]);
    
    // Calculate Effort
    effort = table[model][0] * (size ** table[model][1]);

    // Calculate Time
    time = table[model][2] * (effort ** table[model][3]);

    // Calculate Persons Required
    staff = effort / time;

    console.log("Effort = ",effort," Person-Month");
    console.log("Development Time = ",time," Months");
    console.log("Average Staff Required = ",Math.round(staff)," Persons");
}


var table = [[2.4,1.05,2.5,0.38],[3.0,1.12,2.5,0.35],[3.6,1.20,2.5,0.32]]
var mode = ["Organic","Semi-Detached","Embedded"]
var size = 4;
calculate(table, 3, mode, size);

// This code is contributed by satwiksuman.

The mode is Organic
Effort = 10.289 Person-Month
Development Time = 6.06237 Months
Average Staff Required = 2 Persons

2. Intermediate COCOMO Model: The basic COCOMO model assumes that the effort is only a function of the number of lines of code and some constants evaluated according to the different software systems. However, in reality, no system's effort and schedule can be solely calculated based on Lines of Code. For that, various other factors such as reliability, experience, and Capability. These factors are known as Cost Drivers (multipliers) and the Intermediate Model utilizes 15 such drivers for cost estimation.

Cost drivers in the Intermediate COCOMO model are divided into four categories:

Product attributes:

• Required Software Reliability extent
• Size of the application database
• The complexity of the product

Hardware attributes:

• Run-time performance constraints
• Memory constraints
• The volatility of the virtual machine environment
• Required turnabout time

Personal attributes:

• Analyst capability
• Software engineering capability
• Application experience
• Virtual machine experience
• Programming language experience

Project attributes:

• Use of Software Tools.
• Application of Software Engineering Methods.
• Required development schedule.

Each of the 15 cost drivers is assigned a rating from Very Low to Extra High. Based on these ratings, an Effort Adjustment Factor (EAF) is calculated, which helps make the effort estimation in the Basic COCOMO model more accurate.

Intermediate COCOMO Model equation:

PM = a \times (\mathrm{KLOC})^{b} \times EAF

T_{dev} = c \times (PM)^{d}

Where,

• E is effort applied in Person-Months
• KLOC is the estimated size of the software product indicate in Kilo Lines of Code
• EAF is the Effort Adjustment Factor (EAF) is a multiplier used to refine the effort estimate obtained from the basic COCOMO model.
• Tdev is the development time in months
• a, b, c are constants determined by the category of software project given in below table.

The constant values a, b, c, and d for the Basic Model for the different categories of the software projects are:

3. Detailed COCOMO Model: Detailed COCOMO goes beyond Basic and Intermediate COCOMO by diving deeper into project-specific factors. It considers a wider range of parameters, like team experience, development practices, and software complexity. By analyzing these factors in more detail, Detailed COCOMO provides a highly accurate estimation of effort, time, and cost for software projects. It's like zooming in on a project's unique characteristics to get a clearer picture of what it will take to complete it successfully.

Advantages

• Provides a systematic approach for software cost estimation.
• Helps estimate project cost and effort at different development stages.
• Identifies factors that significantly affect project cost and effort.
• Assists in evaluating project feasibility before development.

Disadvantages

• Assumes software size is the primary factor affecting cost and effort.
• Does not consider team-specific characteristics and productivity.
• Estimates are based on assumptions and may not be fully accurate.