Ingeniería de Software | Modelo COCOMO

Cocomo (Modelo de Costo Constructivo) es un modelo de regresión basado en LOC, es decir, número de Líneas de Código . Es un modelo de estimación de costos de procedimiento para proyectos de software y, a menudo, se usa como un proceso para predecir de manera confiable los diversos parámetros asociados con la realización de un proyecto, como el tamaño, el esfuerzo, el costo, el tiempo y la calidad. Fue propuesto por Barry Boehm en 1981 y se basa en el estudio de 63 proyectos, lo que lo convierte en uno de los modelos mejor documentados. Los parámetros clave que definen la calidad de cualquier producto de software, que también son un resultado de Cocomo, son principalmente el esfuerzo y el cronograma:

• Esfuerzo: Cantidad de trabajo que se requerirá para completar una tarea. Se mide en unidades de personas-meses.
• Horario: simplemente significa la cantidad de tiempo requerido para completar el trabajo, que es, por supuesto, proporcional al esfuerzo realizado. Se mide en unidades de tiempo como semanas, meses.

Se han propuesto diferentes modelos de Cocomo para predecir la estimación de costos en diferentes niveles, en función de la cantidad de precisión y corrección requerida. Todos estos modelos se pueden aplicar a una variedad de proyectos, cuyas características determinan el valor de la constante a utilizar en los cálculos posteriores. Estas características pertenecientes a diferentes tipos de sistemas se mencionan a continuación. Definición de Boehm de sistemas orgánicos, adosados ​​e integrados:

1. Orgánico: se dice que un proyecto de software es de tipo orgánico si el tamaño del equipo requerido es adecuadamente pequeño, el problema se entiende bien y se ha resuelto en el pasado y también los miembros del equipo tienen una experiencia nominal con respecto al problema.
2. Semi-separado: se dice que un proyecto de software es de tipo semi-separado si las características vitales, como el tamaño del equipo, la experiencia, el conocimiento de los diversos entornos de programación se encuentran entre orgánico e integrado. Los proyectos clasificados como Pareados son comparativamente menos familiares y difíciles de desarrollar en comparación con los orgánicos y requieren más experiencia y mejor orientación y creatividad. Ej.: Los Compiladores o diferentes Sistemas Embebidos pueden ser considerados de tipo Pareado.
3. Integrado: un proyecto de software que requiere el nivel más alto de complejidad, creatividad y requisitos de experiencia se incluye en esta categoría. Dicho software requiere un tamaño de equipo más grande que los otros dos modelos y también los desarrolladores deben tener suficiente experiencia y creatividad para desarrollar modelos tan complejos.
   1. Modelo COCOMO Básico
   2. Modelo COCOMO Intermedio
   3. Modelo COCOMO detallado
4. Modelo basica –

1. La fórmula anterior se usa para la estimación de costos del modelo COCOMO básico y también se usa en los modelos posteriores. Los valores constantes a,b,c y d del Modelo Básico para las diferentes categorías de sistema:

1. El esfuerzo se mide en personas-meses y, como se desprende de la fórmula, depende de Kilo-Lines de código. El tiempo de desarrollo se mide en meses. Estas fórmulas se utilizan como tales en los cálculos del modelo básico, ya que no se tienen en cuenta muchos factores como la fiabilidad y la experiencia, por lo que la estimación es aproximada. A continuación se muestra el programa C++ para COCOMO básico 

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

# Function for rounding off float to int
def fround(x):
    x = x + 0.5;
    return x;
 
# 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(effort))
    print("Development Time = {} Months".format(time))
    print("Average Staff Required = {} Persons".format(fround(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 111arpit1.

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

1. Modelo intermedio: el modelo básico de Cocomo asume que el esfuerzo es solo una función del número de líneas de código y algunas constantes evaluadas de acuerdo con los diferentes sistemas de software. Sin embargo, en realidad, el esfuerzo y el cronograma de ningún sistema pueden calcularse únicamente sobre la base de Líneas de código. Para eso, varios otros factores como la confiabilidad, la experiencia, la capacidad. Estos factores se conocen como impulsores de costos y el modelo intermedio utiliza 15 impulsores de este tipo para la estimación de costos. Clasificación de Cost Drivers y sus atributos: (i) Atributos del producto –
   • Grado de confiabilidad del software requerido
   • Tamaño de la base de datos de la aplicación
   • La complejidad del producto.
   • Restricciones de rendimiento en tiempo de ejecución
   • Restricciones de memoria
   • La volatilidad del entorno de la máquina virtual
   • Tiempo de respuesta requerido
   • Capacidad del analista
   • Capacidad de ingeniería de software
   • Experiencia en aplicaciones
   • Experiencia en máquinas virtuales
   • Experiencia en lenguaje de programación
   • Uso de herramientas de software.
   • Aplicación de métodos de ingeniería de software.
   • Cronograma de desarrollo requerido
2. Modelo detallado: COCOMO detallado incorpora todas las características de la versión intermedia con una evaluación del impacto del generador de costos en cada paso del proceso de ingeniería de software. El modelo detallado utiliza diferentes multiplicadores de esfuerzo para cada atributo del generador de costos. En cocomo detallado, todo el software se divide en diferentes módulos y luego aplicamos COCOMO en diferentes módulos para estimar el esfuerzo y luego sumar el esfuerzo. Las seis fases del COCOMO detallado son:
   1. Planificación y requisitos
   2. Diseño de sistemas
   3. Diseño detallado
   4. Código y prueba del módulo
   5. Integración y prueba
   6. Costo Modelo constructivo