MÉTRICAS DE SOFTWARE

1.1.            Definición: La aplicación continua de técnicas basadas en las medidas de los procesos de desarrollo de Software y sus productos, para producir una información de gestión significativa y a tiempo. Esta información se utilizará para mejorar esos procesos y los productos que se obtienen de ellos.

1.2.            Características de las Métricas de Software.

·            La calidad de las medidas deberían facilitar el desarrollo de modelos que sean capaces de predecir el comportamiento de determinados parámetros que afectan al desarrollo de productos o procesos.

·            Implican medir: medir involucra números; el uso de números para hacer cosas mejor. Pretenden mejorar los procesos de desarrollo de Software y mejorar, por tanto, todos los aspectos de la gestión de aquellos procesos.

·            Estas medidas son aplicables a todo el ciclo de vida del desarrollo, desde la iniciación, cuando debemos estimar los costos, al seguimiento y control de la fiabilidad de los productos finales, y a la forma en que los productos cambian a través del tiempo debido a la aplicación de mejoras.

·            Las medidas del Software y los modelos de medida son entonces útiles para estimar y predecir costos y para medir la productividad y la calidad del producto.

1.3.            Áreas de Aplicación.

·            El control de proyectos de desarrollo de Software a través de medidas en un área que está generando un gran interés. Este es un tema que ha alcanzado un interés relevante con el incremento de contratos a precio fijo para desarrollar un producto Software y la utilización de cláusulas de penalización en los mismos en caso de retrasos, sobrecostos, etc.

·            La predicción de los niveles de calidad del Software, a menudo en términos de fiabilidad, es otra área en que las Métricas de Software tiene un importante papel que jugar.

·            El uso de las Métricas de Software es proporcionar una verificación cuantitativa del diseño de software es otra área bien definida. Estas Métricas no se van a estudiar en esta Unidad si no en la Unidad de Diseño.

·            La utilización de las Métricas para comprar unas organizaciones con otras es un área de aplicación muy importante. Un resultado de esta aplicación es que se puede identificar que se está haciendo mal y quién lo está haciendo bien y aprender de esas empresas.

·            Finalmente, el uso más común de las medidas de Software es la provisión de información de gestión, que incluye datos acerca de la productividad, calidad y eficacia de los procesos.

1.4.            Clasificación de las Métricas de Software.

1.4.1        Métricas de Producto son medidas de producto Software durante cualquier fase de su desarrollo desde los requisitos hasta la instalación. Estas métricas evalúan el proceso en sí de fabricación del producto correspondiente. Pueden medir la complejidad del diseño, el tamaño del producto final (fuente u objeto) o el número de páginas de documentación producida.

1.4.2        Métricas de Proceso son medidas del proceso de desarrollo del Software tales como tiempo de desarrollo total, esfuerzo en días/ hombre o mes / hombre de desarrollo del producto, tipo de metodología utilizada o nivel medio de experiencia de los programadores.

1.4.3        Métricas del tamaño: provienen de la normalización de las medidas de `calidad y/o productividad considerando -el tamaño - del Software que se haya producido.  Existen un cierto número de Métricas que intentan cuantificar el tamaño del Software.  A continuación, vamos a analizar las medidas más utilizadas en la determinación del tamaño del Software.

·            Líneas de Código: La medida más utilizada de la longitud del código fuente de un programa es el Numero de Líneas de Código (Lines of Code en Inglés, abreviado LOC). Sin embargo esta métrica puede calcularse de muchas maneras. Estas diferencias afectan al tratamiento de las líneas en blanco y las líneas de comentarios, las sentencias no ejecutables, las instrucciones múltiples por línea y las múltiples líneas por instrucción. Además, deberían contarse las líneas reusables del código.

·           Especificación del Diseño Unas especificaciones o un diseño, están compuestos por textos o diagramas, los cuales parecen inmedibles con relación a la longitud. Al comienzo del ciclo de vida, tales documentos consisten en una infinidad de texto, grafos, diagramas matemáticos, y símbolos. La naturaleza de aquellos dependerá en particular del estilo el método o la notación utilizada.

·           Predicción de la longitud: Un modo intuitivo de predecir la longitud es obteniendo una relación entre la longitud de diferentes productos obtenidos durante el ciclo de vida. En particular, una predicción de longitud, se puede obtener considerando la relación ratio de expansión entre la longitud de las especificaciones o del diseño y la longitud del Código en proyectos similares en los que se mantienen datos.

El objetivo más importante es identificar una medida del tamaño de Software que pueda ser la variable predominante en los sistemas de predicción de costos y esfuerzo, así como en la evaluación de la productividad.

1.4.4        Métricas de Calidad

La calidad del software es una característica que, teóricamente al menos, puede ser medida en cada fase del ciclo de desarrollo del Software.

El objeto primordial de la ingeniería del Software es producir un sistema, aplicación o producto de alta calidad. Para lograr este objetivo, los ingenieros del software deben aplicar métodos efectivos con herramientas modernas dentro del contexto de un proceso maduro de desarrollo del Software. Se puede generar una larga lista de características de la calidad de Software: corrección, eficacia, portabilidad, mantenibilidad, fiabilidad, etc. Desafortunadamente, las características a veces se solapan y entran en conflicto unas con otras. Por ejemplo, incrementar la portabilidad, que es muy deseable, puede dar lugar a una eficacia menor.

Se considera importante atención a las siguientes tres áreas:

·            Corrección de los programas: Un programa debe operar correctamente o proporcionará poco valor a sus usuarios. La corrección es el grado en el que el Software lleva a cabo su función requerida.

·            Fiabilidad del Software: En esta época de intrusos informáticos y de virus, la integridad del software ha llegado a tener mucha importancia. Este atributo mide la habilidad de un sistema para resistir ataques (tanto accidentales como intencionales) contra su seguridad. El ataque se puede realizar en cualquiera de los tres componentes del Software, programas, datos, y documentos.

·            Mantenibilidad del Software, que se mide a partir de otro conjunto de métricas, incluidas las de complejidad: La facilidad de mantenimiento es la facilidad con la que se puede corregir un programa si se encuentra un error, se puede adaptar si su entorno cambia, o mejorar si su cliente desea un cambio de requisitos. 

1.5.            Integración de las Métricas dentro del Proceso de Software

¿Por qué es tan importante medir el proceso de ingeniería de Software y el producto (Software) que produce? Si no se mide, no hay una forma real de determinar sí se está mejorando. Y si no se está mejorando, se está perdido.

Mediante el uso de la medición para establecer una línea base del proyecto, cada uno de estos asuntos se hace más fácil de manejar. Entonces, la línea base sirve como base de la estimación y la recopilación de métricas de calidad permite a una organización -sintonizar- su proceso de ingeniería del Software para eliminar las causas - poco vitales- de los defectos que tienen el mayor impacto en el desarrollo del Software.

Método Compuesto de Simpson de Euler y Runge-Kutta de orden cuatro (Algoritmo y Código en Matlab)

1)      Método Compuesto de Simpson

1.1)            Algoritmo:

Entrada: puntos extremos a; b; entero positivo m
Salida: Aproximación XI de la integral I
Paso 1: Tomar h = (b - a)/2m
Paso 2: Tomar XI0 = f(a) + f (b)

XI1 = 0; (suma de f (x2i-1)
XI2 = 0; (suma de f (x2i))

Paso 3: Para i = 1;…; 2m – 1
Paso 4: tomar x = a + ih
Paso5: Si i es par entonces tomar XI2 = XI2 + f(x)

Si no tomar XI1 = XI1 + f(x)

Paso 6: Tomar XI = h (XI0 + 2XI2 + 4XI1)/3
Paso 7: Salida (XI)
Parar

1.2)            Programa:

%****************************************************************

%** Romina Betancourt **

%****************************************************************

clear;

clc;

fprintf('Alumna:\n');

fprintf('Romina Betancourt\n\n');

%Ingreso de datos

disp('Regla de simpson')

disp('Integrales definidas')

fx=input('digite la funcion f(x) = ','s');

%load limiteinferior.txt

%a = load('limiteinferior.txt');

%load limitesuperior.txt

%b = load('limitesuperior.txt');

%load tol.txt

%tol = load('tol.txt');

a=input('limite inferior = ');

b=input('limite superior = ');

tol=input('tolerancia = ');

%Condiciones iniciales

err(1)=100;ns=2;exito=0;

%Calculo de la integral

while exito==0

    h=(b-a)/ns;

    x=a:h:b;

    y=eval(fx);

    if (rem(ns,3)==0) %simpson 3/8

        Iaprox(ns-1)=3*h/8*(y(1)+y(ns+1)+3*sum(y(2:3:ns-1))+3*sum(y(3:3:ns))+2*sum(y(4:3:ns-2)));

    elseif (rem(ns,2)==0) %simpson 1/3

        Iaprox(ns-1)=h/3*(y(1)+y(ns+1)+4*sum(y(2:2:ns))+2*sum(y(3:2:ns-1)));

    else % combinacion 3/8 + 1/3

        Iaprox(ns-1)=h/3*(y(1)+y(ns-2)+4*sum(y(2:2:ns-3))+2*sum(y(3:2:ns-4)))+3*h/8*(y(ns-2)+3*y(ns-1)+3*y(ns)+y(ns+1));

    end

    if ns>2 % calculo del error

        err(ns-1)=abs((Iaprox(ns-1)-Iaprox(ns-2))/Iaprox(ns-1))*100;

        if err(ns-1)<tol

            exito=1;

            break;

        end

    end

    ns=ns+1;

end

%Presentacion de resultados

n=2:ns;

fprintf('n');

disp(['     segm'   '      integ'  '      error'])

disp([n' Iaprox' err' ]);

fprintf('n se alcanzo la solucion con % g segmentos n',ns);

fprintf('n la integral aproximada es %g n',Iaprox(ns-1));

plot(x,y)

  

              2)      Método de Euler

2.1)           Algoritmo: Este algoritmo calcula la soluci´on del problema de valor inicial (1.1) en puntos equidistantes x1 = x0 + h ,x2 = x0 + 2h, x3 = x0 + 3h, ・ ・ ・ ,           xN = x0 + Nh, aquí f es tal que (1.1) tiene una solución ´única en [x0, xN].

Entrada: Valores iníciales x0, y0, tama˜no de paso h y n´umero de pasos N

Para n=0,...,N-1, hacer

xn+1 = xn + h

yn+1 = yn + hf(xn, yn)

            Salida xn+1, yn+1

Parar

2.2)            Programa:

function y=euler(n,a,b,h)

format long

%****************************************************************

%** Romina Betancourt **

%****************************************************************

fprintf('Romina Betancourt\n\n');

fprintf('\n ///// EULER/////\n')

x=a:h:n*h;

y=zeros(n,1);

y(1)=b;

for k=1:n

  f=feuler(x(k),y(k));

  y(k+1)=y(k)+h*f;

end

3) Método de Runge-Kutta de orden cuatro

3.1) Algoritmo: Este algoritmo calcula la soluci´on del problema de valor inicial (1.1) en puntos

equidistantes x1 = x0 + h ,x2 = x0 + 2h, x3 = x0 + 3h, ・ ・ ・ , xN = x0 + Nh, aqu´ı f es tal que (1.1) tiene una solución ´única en [x0, xN].

Entrada: Valores iníciales x0, y0, tamaño de paso h y numero de pasos N

Para n=0,...,N-1, hacer

k1 = hf(xn, yn)

k2 = hf(xn + 1

2h, yn + 1

2k1)

k3 = hf(xn + 1

2h, yn + 1

2k2)

k4 = hf(xn + h, yn + k3)

yn+1 = yn + 1

6 (k1 + 2k2 + 2k3 + k4)

Salida xn+1, yn+1

Parar

            3.2) Programa:

function runge_kutta

%****************************************************************

%** Romina Betancourt **

%****************************************************************

clear;

clc;

fprintf('Romina Betancourt\n\n');

format short % exportando formato

% ingreso de Datos

fprintf('\n ///// RUNGE-KUTTA DE ORDEN 4/////\n')

dfx=input('\EC. DIFERENCIAL dfx =','s');

a =input('\n ingrese a=:\n');

b =input('\n ingrese b=:\n');

%load limiteinferior.txt

%a = load('limiteinferior.txt');

%load limitesuperior.txt

%b = load('limitesuperior.txt');

y0=input('\n&#160;&#160;EL valos inicial y0 = :\n');

n=input('\n cual es el No de Pasos? :\n');

h=(b-a)/n;

%vector final agustado al numero de pasos

xs=a:h:b;

fprintf('\n''Funcion descrita');

for i=1:n

it=i-1;

a=xs(i);

x=a;

y = y0;

k1=h*eval(dfx);

x=a+h/2;

y=y0+k1/2;

k2=h*eval(dfx);

x=a+h/2;

y=y0+k2/2;

k3=h*eval(dfx);

x=a+h;

y=y0+k3;

k4=h*eval(dfx);

y0=y0+(k1+2*k2+2*k3+k4)/6;

%formato de impresion de resultados

fprintf('\n%2.0f%5.6f%10.6f\n',it,a,y0);

plot(xs,y0,':ok');

end

fprintf('\n El punto aproximado y(x1) es = %8.6f\n',y0);

Archivo limiteinferior.txt (caso de leer desde archivo debe modificar el código, los valores adentro pueden ser los que usted guste)

-10
-9
-8
-7
-6
-5
-4
-3
-2
-1
0
1
2
3
4
5
6
7
8
9
10

Archivo limitesuperior.txt (caso de leer desde archivo debe modificar el código, los valores adentro pueden ser los que usted guste)

10
9
8
7
6
5
4
3
2
1
0
-1
-2
-3
-4
-5
-6
-7
-8
-9
-10