Software Engineering | COCOMO Model - GeeksforGeeks

15 Feb, 2022
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, 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 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, 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 of Semi-Detached type.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.All the above system types utilize different values of the constants used in Effort Calculations.Types of Models: COCOMO consists of a hierarchy of three increasingly detailed and accurate forms. Any of the three forms can be adopted according to our requirements. These are types of COCOMO model:Basic COCOMO ModelIntermediate COCOMO ModelDetailed COCOMO ModelThe first level, Basic COCOMO can be used for quick and slightly rough calculations of Software Costs. Its accuracy is somewhat restricted due to the absence of sufficient factor considerations.Intermediate COCOMO takes these Cost Drivers into account and Detailed COCOMO additionally accounts for the influence of individual project phases, i.e in case of Detailed it accounts for both these cost drivers and also calculations are performed phase-wise henceforth producing a more accurate result. These two models are further discussed below.Estimation of Effort: Calculations –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 system:Software ProjectsabcdOrganic2.41.052.50.38Semi Detached3.01.122.50.35Embedded3.61.202.50.32The 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, expertise is taken into account, henceforth the estimate is rough.Below is the C++ program for Basic COCOMO// C++ program to implement basic COCOMO#include<bits/stdc++.h>using namespace std;  // Function for rounding off float to intint fround(float x){    int a;    x=x+0.5;    a=x;    return(a);}  // Function to calculate parameters of Basic COCOMOvoid 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;}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 extentSize of the application databaseThe complexity of the product(ii) Hardware attributes –Run-time performance constraintsMemory constraintsThe volatility of the virtual machine environmentRequired turnabout time(iii) Personnel attributes –Analyst capabilitySoftware engineering capabilityApplications experienceVirtual machine experienceProgramming language experience(iv) Project attributes –Use of software toolsApplication of software engineering methodsRequired development scheduleCost DriversVery LowLowNominal;HighVery HighProduct AttributesRequired Software Reliability0.750.881.001.151.40Size of Application Database0.941.001.081.16Complexity of The Product0.700.851.001.151.30Hardware AttributesRuntime Performance Constraints1.001.111.30Memory Constraints1.001.061.21Volatility of the virtual machine environment0.871.001.151.30Required turnabout time0.941.001.071.15Personnel attributesAnalyst capability1.461.191.000.860.71Applications experience1.291.131.000.910.82Software engineer capability1.421.171.000.860.70Virtual machine experience1.211.101.000.90Programming language experience1.141.071.000.95Project AttributesApplication of software engineering methods1.241.101.000.910.82Use of software tools1.241.101.000.910.83Required development schedule1.231.081.001.041.10The project manager is to rate these 15 different parameters for a particular project on a scale of one to three. Then, depending on these ratings, appropriate cost driver values are taken from the above table. These 15 values are then multiplied to calculate the EAF (Effort Adjustment Factor). The Intermediate COCOMO formula now takes the form:
The values of a and b in case of the intermediate model are as follows:Software ProjectsabOrganic3.21.05Semi Detached3.01.12Embeddedc2.81.20Detailed 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 requirementsSystem designDetailed designModule code and testIntegration and testCost Constructive modelThe effort is calculated as a function of program size and a set of cost drivers are given according to each phase of the software lifecycle.Also read: Classical Waterfall Model, Iterative Waterfall Model, Prototyping Model, Spiral ModelMy Personal Notes
arrow_drop_upSave
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, 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 of Semi-Detached type.
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.All the above system types utilize different values of the constants used in Effort Calculations.Types of Models: COCOMO consists of a hierarchy of three increasingly detailed and accurate forms. Any of the three forms can be adopted according to our requirements. These are types of COCOMO model:Basic COCOMO ModelIntermediate COCOMO ModelDetailed COCOMO ModelThe first level, Basic COCOMO can be used for quick and slightly rough calculations of Software Costs. Its accuracy is somewhat restricted due to the absence of sufficient factor considerations.Intermediate COCOMO takes these Cost Drivers into account and Detailed COCOMO additionally accounts for the influence of individual project phases, i.e in case of Detailed it accounts for both these cost drivers and also calculations are performed phase-wise henceforth producing a more accurate result. These two models are further discussed below.Estimation of Effort: Calculations –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 system:Software ProjectsabcdOrganic2.41.052.50.38Semi Detached3.01.122.50.35Embedded3.61.202.50.32The 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, expertise is taken into account, henceforth the estimate is rough.Below is the C++ program for Basic COCOMO// C++ program to implement basic COCOMO#include<bits/stdc++.h>using namespace std;  // Function for rounding off float to intint fround(float x){    int a;    x=x+0.5;    a=x;    return(a);}  // Function to calculate parameters of Basic COCOMOvoid 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;}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 extentSize of the application databaseThe complexity of the product(ii) Hardware attributes –Run-time performance constraintsMemory constraintsThe volatility of the virtual machine environmentRequired turnabout time(iii) Personnel attributes –Analyst capabilitySoftware engineering capabilityApplications experienceVirtual machine experienceProgramming language experience(iv) Project attributes –Use of software toolsApplication of software engineering methodsRequired development scheduleCost DriversVery LowLowNominal;HighVery HighProduct AttributesRequired Software Reliability0.750.881.001.151.40Size of Application Database0.941.001.081.16Complexity of The Product0.700.851.001.151.30Hardware AttributesRuntime Performance Constraints1.001.111.30Memory Constraints1.001.061.21Volatility of the virtual machine environment0.871.001.151.30Required turnabout time0.941.001.071.15Personnel attributesAnalyst capability1.461.191.000.860.71Applications experience1.291.131.000.910.82Software engineer capability1.421.171.000.860.70Virtual machine experience1.211.101.000.90Programming language experience1.141.071.000.95Project AttributesApplication of software engineering methods1.241.101.000.910.82Use of software tools1.241.101.000.910.83Required development schedule1.231.081.001.041.10The project manager is to rate these 15 different parameters for a particular project on a scale of one to three. Then, depending on these ratings, appropriate cost driver values are taken from the above table. These 15 values are then multiplied to calculate the EAF (Effort Adjustment Factor). The Intermediate COCOMO formula now takes the form:
The values of a and b in case of the intermediate model are as follows:Software ProjectsabOrganic3.21.05Semi Detached3.01.12Embeddedc2.81.20Detailed 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 requirementsSystem designDetailed designModule code and testIntegration and testCost Constructive modelThe effort is calculated as a function of program size and a set of cost drivers are given according to each phase of the software lifecycle.Also read: Classical Waterfall Model, Iterative Waterfall Model, Prototyping Model, Spiral ModelMy Personal Notes
arrow_drop_upSave
All the above system types utilize different values of the constants used in Effort Calculations.
Types of Models: COCOMO consists of a hierarchy of three increasingly detailed and accurate forms. Any of the three forms can be adopted according to our requirements. These are types of COCOMO model:
Basic COCOMO ModelIntermediate COCOMO ModelDetailed COCOMO Model
Basic COCOMO Model
Intermediate COCOMO Model
Detailed COCOMO Model
The first level, Basic COCOMO can be used for quick and slightly rough calculations of Software Costs. Its accuracy is somewhat restricted due to the absence of sufficient factor considerations.
Intermediate COCOMO takes these Cost Drivers into account and Detailed COCOMO additionally accounts for the influence of individual project phases, i.e in case of Detailed it accounts for both these cost drivers and also calculations are performed phase-wise henceforth producing a more accurate result. These two models are further discussed below.
Estimation of Effort: Calculations –
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 system:Software ProjectsabcdOrganic2.41.052.50.38Semi Detached3.01.122.50.35Embedded3.61.202.50.32The 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, expertise is taken into account, henceforth the estimate is rough.Below is the C++ program for Basic COCOMO// C++ program to implement basic COCOMO#include<bits/stdc++.h>using namespace std;  // Function for rounding off float to intint fround(float x){    int a;    x=x+0.5;    a=x;    return(a);}  // Function to calculate parameters of Basic COCOMOvoid 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;}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 extentSize of the application databaseThe complexity of the product(ii) Hardware attributes –Run-time performance constraintsMemory constraintsThe volatility of the virtual machine environmentRequired turnabout time(iii) Personnel attributes –Analyst capabilitySoftware engineering capabilityApplications experienceVirtual machine experienceProgramming language experience(iv) Project attributes –Use of software toolsApplication of software engineering methodsRequired development scheduleCost DriversVery LowLowNominal;HighVery HighProduct AttributesRequired Software Reliability0.750.881.001.151.40Size of Application Database0.941.001.081.16Complexity of The Product0.700.851.001.151.30Hardware AttributesRuntime Performance Constraints1.001.111.30Memory Constraints1.001.061.21Volatility of the virtual machine environment0.871.001.151.30Required turnabout time0.941.001.071.15Personnel attributesAnalyst capability1.461.191.000.860.71Applications experience1.291.131.000.910.82Software engineer capability1.421.171.000.860.70Virtual machine experience1.211.101.000.90Programming language experience1.141.071.000.95Project AttributesApplication of software engineering methods1.241.101.000.910.82Use of software tools1.241.101.000.910.83Required development schedule1.231.081.001.041.10The project manager is to rate these 15 different parameters for a particular project on a scale of one to three. Then, depending on these ratings, appropriate cost driver values are taken from the above table. These 15 values are then multiplied to calculate the EAF (Effort Adjustment Factor). The Intermediate COCOMO formula now takes the form:
The values of a and b in case of the intermediate model are as follows:Software ProjectsabOrganic3.21.05Semi Detached3.01.12Embeddedc2.81.20Detailed 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 requirementsSystem designDetailed designModule code and testIntegration and testCost Constructive modelThe effort is calculated as a function of program size and a set of cost drivers are given according to each phase of the software lifecycle.
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 system:Software ProjectsabcdOrganic2.41.052.50.38Semi Detached3.01.122.50.35Embedded3.61.202.50.32The 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, expertise is taken into account, henceforth the estimate is rough.Below is the C++ program for Basic COCOMO// C++ program to implement basic COCOMO#include<bits/stdc++.h>using namespace std;  // Function for rounding off float to intint fround(float x){    int a;    x=x+0.5;    a=x;    return(a);}  // Function to calculate parameters of Basic COCOMOvoid 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;}Output:The mode is Organic
Effort = 10.289 Person-Month
Development Time = 6.06237 Months
Average Staff Required = 2 Persons







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 system:
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, expertise is taken into account, henceforth the estimate is rough.
Below is the C++ program for Basic COCOMO
// C++ program to implement basic COCOMO#include<bits/stdc++.h>using namespace std;  // Function for rounding off float to intint fround(float x){    int a;    x=x+0.5;    a=x;    return(a);}  // Function to calculate parameters of Basic COCOMOvoid 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;}
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 extentSize of the application databaseThe complexity of the product(ii) Hardware attributes –Run-time performance constraintsMemory constraintsThe volatility of the virtual machine environmentRequired turnabout time(iii) Personnel attributes –Analyst capabilitySoftware engineering capabilityApplications experienceVirtual machine experienceProgramming language experience(iv) Project attributes –Use of software toolsApplication of software engineering methodsRequired development scheduleCost DriversVery LowLowNominal;HighVery HighProduct AttributesRequired Software Reliability0.750.881.001.151.40Size of Application Database0.941.001.081.16Complexity of The Product0.700.851.001.151.30Hardware AttributesRuntime Performance Constraints1.001.111.30Memory Constraints1.001.061.21Volatility of the virtual machine environment0.871.001.151.30Required turnabout time0.941.001.071.15Personnel attributesAnalyst capability1.461.191.000.860.71Applications experience1.291.131.000.910.82Software engineer capability1.421.171.000.860.70Virtual machine experience1.211.101.000.90Programming language experience1.141.071.000.95Project AttributesApplication of software engineering methods1.241.101.000.910.82Use of software tools1.241.101.000.910.83Required development schedule1.231.081.001.041.10The project manager is to rate these 15 different parameters for a particular project on a scale of one to three. Then, depending on these ratings, appropriate cost driver values are taken from the above table. These 15 values are then multiplied to calculate the EAF (Effort Adjustment Factor). The Intermediate COCOMO formula now takes the form:
The values of a and b in case of the intermediate model are as follows:Software ProjectsabOrganic3.21.05Semi Detached3.01.12Embeddedc2.81.20
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
(ii) Hardware attributes –
Run-time performance constraints
Memory constraints
The volatility of the virtual machine environment
Required turnabout time
(iii) Personnel attributes –
Analyst capability
Software engineering capability
Applications experience
Virtual machine experience
Programming language experience
(iv) Project attributes –
Use of software tools
Application of software engineering methods
Required development schedule
;
The project manager is to rate these 15 different parameters for a particular project on a scale of one to three. Then, depending on these ratings, appropriate cost driver values are taken from the above table. These 15 values are then multiplied to calculate the EAF (Effort Adjustment Factor). The Intermediate COCOMO formula now takes the form:


The values of a and b in case of the intermediate model are as follows:
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 requirementsSystem designDetailed designModule code and testIntegration and testCost Constructive modelThe effort is calculated as a function of program size and a set of cost drivers are given according to each phase of the software lifecycle.
The Six phases of detailed COCOMO are:
Planning and requirementsSystem designDetailed designModule code and testIntegration and testCost Constructive model
Planning and requirements
System design
Detailed design
Module code and test
Integration and test
Cost Constructive model
The effort is calculated as a function of program size and a set of cost drivers are given according to each phase of the software lifecycle.
Also read: Classical Waterfall Model, Iterative Waterfall Model, Prototyping Model, Spiral Model
chitrasingla2001
yogirao
Software Engineering
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Types of Software Testing
Differences between Black Box Testing vs White Box Testing
Functional vs Non Functional Requirements
Differences between Verification and Validation
Software Testing | Basics
Software Requirement Specification (SRS) Format
Levels in Data Flow Diagrams (DFD)
Difference between Alpha and Beta Testing
Software Engineering | Architectural Design
Difference between Spring and Spring Boot