# Software Engineering | COCOMO Model

Cocomo (Constructive Cost Model) is a regression model based on LOC, i.e **number of Lines of Code**. It 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. It was proposed by Barry Boehm in 1981 and is based on the study of 63 projects, which makes it one of the best-documented models. The key parameters which define the quality of any software products, which are also an outcome of the Cocomo are primarily Effort & Schedule:

**Effort:**Amount of labor that will be required to complete a task. It is measured in person-months units.**Schedule:**Simply means the amount of time required for the completion of the job, which is, of course, proportional to the effort put in. It is measured in the units of time such as weeks, and months.

Different models of Cocomo have been proposed to predict the cost estimation at different levels, based on the amount of accuracy and correctness required. All of these models can be applied to a variety of projects, whose characteristics determine the value of the constant to be used in subsequent calculations. These characteristics pertaining to different system types are mentioned below. Boehmâ€™s definition of organic, semidetached, and embedded systems:

**Organic –**A software project is said to be an organic type if the team size required is adequately small, the problem is well understood and has been solved in the past and also the team members have a nominal experience regarding the problem.**Semi-detached –**A software project is said to be a Semi-detached type if the vital characteristics such as team size, experience, and knowledge of the various programming environment lie in between that of organic and Embedded. The projects classified as Semi-Detached are comparatively less familiar and difficult to develop compared to the organic ones and require more experience and better guidance and creativity. Eg: Compilers or different Embedded Systems can be considered Semi-Detached types.**Embedded –**A software project requiring the highest level of complexity, creativity, and experience requirement fall under this category. Such software requires a larger team size than the other two models and also the developers need to be sufficiently experienced and creative to develop such complex models.- Basic COCOMO Model
- Intermediate COCOMO Model
- Detailed COCOMO Model

**Basic Model –**

- The above formula is used for the cost estimation of for 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 system:

Software Projects | 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 |

- 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. Below is the C++ program for Basic COCOMO.

## CPP

`// 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` ` ` `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` ` ` `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"` `;` `}` `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;` `}` |

## Python3

`# 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.` |

## Javascript

`// 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.` |

## Java

`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);` ` ` `}` `}` |

**Output:**

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

**Intermediate 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 on the basis of Lines of Code. For that, various other factors such as reliability, experience, Capability. These factors are known as Cost Drivers and the Intermediate Model utilizes 15 such drivers for cost estimation. Classification of Cost Drivers and their attributes:**(i) Product attributes –**- Required software reliability extent
- Size of the application database
- The complexity of the product
- Run-time performance constraints
- Memory constraints
- The volatility of the virtual machine environment
- Required turnabout time
- Analyst capability
- Software engineering capability
- Applications experience
- Virtual machine experience
- Programming language experience
- Use of software tools
- Application of software engineering methods
- Required development schedule

**Detailed Model –**Detailed COCOMO incorporates all characteristics of the intermediate version with an assessment of the cost driver’s impact on each step of the software engineering process. The detailed model uses different effort multipliers for each cost driver attribute. In detailed cocomo, the whole software is divided into different modules and then we apply COCOMO in different modules to estimate effort and then sum the effort. The Six phases of detailed COCOMO are:- Planning and requirements
- System design
- Detailed design
- Module code and test
- Integration and test
- Cost Constructive model

**Advantages of the COCOMO model:**

- Provides a systematic way to estimate the cost and effort of a software project.
- Can be used to estimate the cost and effort of a software project at different stages of the development process.
- Helps in identifying the factors that have the greatest impact on the cost and effort of a software project.
- Can be used to evaluate the feasibility of a software project by estimating the cost and effort required to complete it.

**Disadvantages of the COCOMO model:**

- Assumes that the size of the software is the main factor that determines the cost and effort of a software project, which may not always be the case.
- Does not take into account the specific characteristics of the development team, which can have a significant impact on the cost and effort of a software project.
- Does not provide a precise estimate of the cost and effort of a software project, as it is based on assumptions and averages.

## Please

Loginto comment...