Ejemplos de clase desarrollados y explicados.

Ejemplo 1: Un equipo de trabajo ha identificado siete módulos en su programa, los cuales se muestran en la tabla junto con los estimados de tamaño para cada uno. Se pide encontrar un estimado de líneas de código para el programa completo.

Módulo	Tamaño Mínimo	Tamaño Más Probable	Tamaño Máximo
1	20	30	50
2	10	15	25
3	25	30	45
4	30	35	40
5	15	20	25
6	10	12	14
7	20	22	25

Explicación y solución:

El problema nos da 7 módulos y para cada módulo se nos dan 3 datos: tamaño mínimo, tamaño más probable y tamaño máximo (en líneas de código o LDC). Así por ejemplo, el módulo 1 tiene 20 LDC de tamaño mínimo de 20 LDC, un tamaño más probable de 30 LDC y un tamaño máximo de 50 LDC.

Para calcular el tamaño estimado de cada pieza, aplicamos la fórmula:
(Tmin + 4(TMP) + Tmáx) / 6

Donde: Tmin es el tamaño mínim, TMP es el tamaño más probable y Tmax es el tamaño máximo.

Aplicando la fórmula a cada módulo nos queda:

M1(20 + 4(30) + 50) / 6 = 32 LDC
M2(10 + 4(15) + 25) / 6 = 16 LDC
M3(25 + 4(30) + 45) / 6 = 32 LDC
M4(30 + 4(35) + 40) / 6 = 37 LDC
M5(15 + 4(20) + 25) / 6 =20 LDC
M6(10 + 4(12) + 14) / 6 =12 LDC
M7(20 + 4(22) + 25) / 6 = 22 LDC

Luego, sumando todos los estimados, tenemos un total de 171 LDC, lo cual es el estimado en tamaño para el programa que se nos pide.

Ejemplo 2: Una compañía de desarrollo de software ha recolectado los siguientes datos de proyectos anteriores. Estime los parámetros de la fórmula de estimación de costo y luego utilícela para determinar el costo que debería requerirse en un nuevo proyecto de 30 KLDC.

No. del proyecto	Tamaño (KLDC)	Costo (PM)
1	50	120
2	80	192
3	40	96
4	10	24
5	20	48

Explicación y solución del ejemplo 2

Primeramente, se nos pide encontrar los parámetros de costo (α, β, γ) .

Si graficamos los puntos siendo T (tamaño en KLDC) la variable independiente y el C (costo en PM), tenemos:




Lo cual nos indica una tendencia lineal.

El costo marginal α viene dado por la pendiente de la recta. Para calcularlo, escogemos dos pares de puntos de la tabla y aplicamos la ecuación:

α = (C2 – C1) / (T2 – T1)

Por ejemplo, tomando los puntos (10,24) y (20,48), tenemos:

α = (48 – 24) / (20 – 10) = 2.4

Debido, a que la tendencia de la gráfica es lineal, podemos afirmar que β = 1.

Finalmente, para encontrar γ (o sea, el costo fijo), aplicamos la relación:

γ = -αTo + Co

Para To y Co podemos tomar cualquier pareja de la tabla de puntos, tomando por ejemplo, 10 y 24, esto nos da:

γ = -(2.4)(10) + (24) = 0

Los parámetros de costo encontrados son entonces:

Costo marginal α = 2.4
Economía de la escala β = 1
Costo fijo γ= 0

Luego, el problema nos pide estimar el costo para el caso de 30 KLDC (30 mil líneas de código).
Para ello, únicamente sustituimos los parámetros que encontramos en la relación Costo – Tamaño:

C = αTβ + γ
C = (2.4)(30)1 + 0
C = 72 PM

Ejemplo 3: Calcular el tiempo de desarrollo para proyectos de 5 mil líneas de código en los tres tipos de software que propone el modelo COCOMO.

Aplicando las ecuaciones COCOMO para 5 KLDC (5 mil líneas de código), en los tres tipos de software, nos queda:

Para software de aplicación: PM = 2.4(5)^1.05 = 13.0 PM

Para software utilitario: PM = 3.0(5)^1.12 = 18.2 PM

Para software de sistema: PM = 3.6(5)^1.20 = 24.8 PM

Relación Costo - Tamaño: Explicación del ejercicio de la clase

Proceso de Software Personal - Explicación del Ejercicio de la Clase

Enunciado del problema:

Se registra durante varios días los avances que un programador tiene al desarrollar un proyecto de prueba. Los resultados del registro de tiempos se muestran en la siguiente tabla:

Fecha	Inicio	Fin	Pausas	LDC
01/01/10	9:00 a.m.	3:30 p.m.	30 minutos	50
02/01/10	9:00 a.m.	2:00 p.m.	30 minutos	60
03/01/10	9:00 a.m.	11:30 a.m.		50
	12:00	2:00		Pruebas

Se pide:

- Calcular la productividad del programador.

- Tomando en cuenta que la empresa trabaja 5 horas cada día y su semana laboral es de 5 días, mencione cuántos meses y semanas le tomaría a un programador trabajar en
un programa de 1000 LDC.

Desarrollo y Explicación:

A la tabla podemos agregarle una columna más Δt que tomaría el diferencial de tiempo en minutos entre el inicio y el fin.

Fecha	Inicio	Fin	Pausas	Δt	LDC
01/01/10	9:00 a.m.	3:30 p.m.	30 minutos	360 minutos	50
02/01/10	9:00 a.m.	2:00 p.m.	30 minutos	270 minutos	60
03/01/10	9:00 a.m.	11:30 a.m.		150 minutos	50
	12:00	2:00		120 minutos	Pruebas

La columna la completamos de la siguiente forma:

Para la primera fecha, entre 9 de la mañana y 3 y 30 de la tarde tenemos 390 minutos, menos los 30 de pausa, son 360 minutos de diferencia.

Para la segunda fecha, entre 9 de la mañana y 2 de la tarde tenemos 300 minutos, menos los 30 de pausa, son 270 minutos de diferencia.

Para la tercera fecha, entre 9 de la mañana y 11 Y 30 de la tarde tenemos 150 minutos de diferencia, sin pausas.

En esa misma fecha, entre 12:00 del mediodía y 2:00 de la tarde, tenemos 120 minutos de diferencia, sin pausas.

Ahora, calculamos el total de tiempo en minutos, sumando las diferencias diarias:
360 + 270 + 150 + 120 = 900 minutos.

Luego, calculamos el total de LDC en ese tiempo: 50 + 60 + 50 = 160 LDC

La productividad del programador viene dada tomando en cuenta que el día de la empresa tiene 5 horas de trabajo (ya lo dice el enunciado). Haciendo la conversión de los 900 minutos:

Productividad del programador =
(160 LDC / 900 minutos) x (60 minutos / 1 hora) x (5 horas / 1 día) = 53 LDC / día

Con lo cual queda satisfecho el primer punto.

Para el segundo punto, si el proyecto es de 1000 LDC, el programador tardará (aplicando el dato encontrado de su productividad):

1000 LDC / 53 LDC * día = 19 días.

Y tomando en cuenta que, según el enunciado, la semana laboral tiene 5 días:

19 días x (1 semana / 5 días) = 4 semanas = 1 mes.

Ya está establecido y programado el horario de consultas para las asignaturas a mi cargo (Sistemas Operativos II e Ingeniería de Software I). Es el siguiente:

Lunes: 9:00 a.m. a 10:30 a.m.
Martes: 10:30 a.m. a 12:00
Jueves: 9:00 a.m. a 12:00

El lugar será en sala de docentes.

En caso de dudas, pueden efectuarlas también por este blog.

Enunciado: En un proyecto, se han determinado las siguientes tareas, duraciones y dependencias:

IdTarea	Descripción	Duración	Dependencias
a	Análisis de requerimientos	8
b	Conseguir recursos hardware	10
c		8	a,b
d	Diseñar la solución	9	a
e	Conseguir programadores	5	b
f	Diseñar las interfaces de usuario	3	c,d
g	Codificar el programa	2	d,e
h	Pruebas y depuración	4	f,g
i	Capacitación de programadores	3	e,f

Se pide:
(1) Dibujar el grafo de dependencias de tareas que incluya las duraciones de las mismas.
(2) Calcular los tiempos mínimos de inicio y finalización de cada tarea.
(3) Encontrar las tareas de ruta crítica y representar dicha ruta en el grafo anteriormente dibujado.
(4) Calcular las holguras de tiempo.

Desarrollo y explicación:

El primer punto nos pide dibujar un grafo de dependencias. Comenzamos con la tarea a. Según lo planificado, no lleva dependencias por lo que únicamente dibujamos el nodo:

El mismo razonamiento podemos seguir para la tarea b, con esto el grafo sigue:

La tarea c tiene como dependencias a la a y a la b, es decir, no puede comenzar hasta no haber terminado a y b. Esto se representa en el grafo así:

Seguimos la misma lógica para las demás tareas, con lo cual el grafo queda así:

Para completar el punto agregamos las respectivas duraciones a cada tarea según la tabla dada:


Con lo cual finalizamos el primer punto.

El segundo punto nos pide calcular los tiempos mínimos de inicio y finalización para cada tarea. Lo haremos directamente en la tabla agregando dos columnas respectivas:

IdTarea	Descripción	Duración	Dependencias	Tiempo inicio	Tiempo final
a	Análisis de requerimientos	8		0	8
b	Conseguir recursos hardware	10		0	10
c		8	a,b	10	18
d	Diseñar la solución	9	a	8	17
e	Conseguir programadores	5	b	10	15
f	Diseñar las interfaces de usuario	3	c,d	18	21
g	Codificar el programa	2	d,e	17	19
h	Pruebas y depuración	4	f,g	21	25
i	Capacitación de programadores	3	e,f	21	24

Explicación:
Iniciamos con la tarea a, la cual no tiene dependencias, por tanto su tiempo mínimo de inicio es 0 y su tiempo mínimo de finalización se obtiene sumando su duración, o sea 0 + 8 = 8.

La tarea b tampoco tiene dependencias, por lo que tiempo mínimo de inicio es 0 y tiempo mínimo de finalización es 0 + 10 = 10.

Para la tarea c se tienen a y b como dependencias. De éstas dos la que tiene mayor tiempo mínimo de finalización es b, con 10. Dicho 10 lo trasladamos al tiempo mínimo de finalización de c. Ahora le sumamos la duración de c para encontrar su tiempo mínimo de finalización: 10 + 8 = 18.

La tarea d sólo tiene una dependencia, la a. Por tanto, tiempo de inicio: 8, tiempo de finalización 8 + 9 = 17.

La tarea e sólo tiene una dependencia, la b. Por tanto, tiempo de inicio: 10 y tiempo de finalización 10 + 5 = 15.

La tarea f tiene c y d como dependencias. De éstas la que tiene mayor tiempo mínimo de finalización es c con 18. Por tanto, tiempo de inicio: 18 y tiempo de finalización: 18 + 3 = 21.

La tarea g tiene d y e como dependencias. De éstas la que tiene mayor tiempo mínimo de finalización es d con 17. Por tanto, tiempo de inicio: 17 y tiempo de finalización: 17 + 2 = 19.

La tarea h tiene f y g como dependencias. De éstas la que tiene mayor tiempo mínimo de finalización es f con 21. Por tanto, tiempo de inicio: 21 y tiempo de finalización: 21 + 4 = 25.

La tarea i tiene e y f como dependencias. De éstas la que tiene mayor tiempo mínimo de finalización es f con 21. Por tanto, tiempo de inicio: 21y tiempo de finalización: 21 + 3 = 24.

Con lo cual, finalizamos el punto 2.

El punto 3 nos pide encontrar las tareas de la ruta crítica y representarlas en el grafo dibujado en el punto 1.

Agregamos a la tabla una columna para la ruta crítica:

IdTarea	Descripción	Duración	Dependencias	Tiempo inicio	Tiempo final	Ruta crítica
a	Análisis de requerimientos	8		0	8
b	Conseguir recursos hardware	10		0	10	*
c		8	a,b	10	18	*
d	Diseñar la solución	9	a	8	17
e	Conseguir programadores	5	b	10	15
f	Diseñar las interfaces de usuario	3	c,d	18	21	*
g	Codificar el programa	2	d,e	17	19
h	Pruebas y depuración	4	f,g	21	25	*
i	Capacitación de programadores	3	e,f	21	24

Explicación:

Comenzamos con la tarea que tiene un mayor tiempo mínimo de finalización. Esa tarea es la h, con 25. La marcamos como tarea crítica.

Ahora vemos las dependencias de h, las cuales son f, g. De éstas dos seleccionamos la que tenga mayor tiempo mínimo de finalización, la cual es f con 21, por tanto, también marcamos f como crítica.

Ahora vemos las dependencias de f, las cuales son c, d. De éstas dos seleccionamos la que tenga mayor tiempo mínimo de finalización, la cual es c con 18, por tanto, también marcamos c como crítica.

Ahora vemos las dependencias de c, las cuales son a, b . De éstas dos seleccionamos la que tenga mayor tiempo mínimo de finalización, la cual es b con 10, por tanto, también marcamos b como crítica.

Como b no tiene dependencias, el algoritmo termina.

Ahora, resaltamos en el grafo, las tareas de la ruta crítica:



Con lo cual, terminamos el punto 3.

El punto 4 requiere los tiempos de holgura. Cabe destacar que dichos tiempos le pertenecen únicamente a las tareas no críticas.

IdTarea	Descripción	Duración	Dependencias	Tiempo inicio	Tiempo final	Ruta crítica
a	Análisis de requerimientos	8		0,1	8,9
b	Conseguir recursos hardware	10		0	10	*
c		8	a,b	10	18	*
d	Diseñar la solución	9	a	8,9	17,18
e	Conseguir programadores	5	b	10,14	15,19
f	Diseñar las interfaces de usuario	3	c,d	18	21	*
g	Codificar el programa	2	d,e	17,19	19,21
h	Pruebas y depuración	4	f,g	21	25	*
i	Capacitación de programadores	3	e,f	21,22	24,25

Explicación:

Comenzamos con la tarea no crítica con mayor tiempo de finalización. Esa es la i con 24. Como i no tiene tareas sucesoras, es decir, tareas de las cuales i sea dependencia, tomamos el mayor tiempo mínimo de finalización de todas las tareas, críticas o no. Ese tiempo es el de h con 25. Colocamos entonces el 25 como holgura en el tiempo de finalización de i y nos queda: 24, 25. Como entre 24 y 25 hay una diferencia de 1 unidad de tiempo, aplicamos la misma diferencia al tiempo de inicio y nos queda 21, 22.

Seguimos con la siguiente tarea no crítica con mayor tiempo de finalización. Esa es g con 19. Los sucesores de g son: h. De h tomamos el menor tiempo de inicio, es decir, 21. Ese 21 lo agregamos al tiempo de finalización de h quedándonos: 19,21. Como entre 19 y 21 hay una diferencia de 2 unidades de tiempo, aplicamos la misma diferencia al tiempo de inicio y nos queda 17,19.

Seguimos con la siguiente tarea no crítica con mayor tiempo de finalización. Esa es d con 17. Los sucesores de d son: f y g. Entre éstas dos tareas comparamos los mayores tiempos mínimos de inicio, es decir, 18 y 19. Tomamos el menor, es decir, 18. Ese 18 lo agregamos al tiempo de finalización de d quedándonos: 17,18. Como entre 17 y 18 hay una diferencia de 1 unidad de tiempo, aplicamos la misma diferencia al tiempo de inicio y nos queda 8,9.

Seguimos con la siguiente tarea no crítica con mayor tiempo de finalización. Esa es e con 15. Los sucesores de e son: g e i Entre éstas dos tareas comparamos los mayores tiempos mínimos de inicio, es decir, 19 y 22. Tomamos el menor, es decir, 19. Ese 19 lo agregamos al tiempo de finalización de e quedándonos: 15, 19. Como entre 15 y 19 hay una diferencia de 4 unidades de tiempo, aplicamos la misma diferencia al tiempo de inicio y nos queda 10,14.

Seguimos con la siguiente tarea no crítica con mayor tiempo de finalización. Esa es a con 8. Los sucesores de a son: c y d. Entre éstas dos tareas comparamos los mayores tiempos mínimos de inicio, es decir, 10 y 9. Tomamos el menor, es decir, 9. Ese 9 lo agregamos al tiempo de finalización de a quedándonos: 8, 9. Como entre 8 y 9 hay una diferencia de 1 unidad de tiempo, aplicamos la misma diferencia al tiempo de inicio y nos queda 0,1.

Al no quedar más tareas no críticas, el algoritmo ha terminado, así como también el punto 4 y el ejercicio.

En caso de otras dudas o correcciones, comunicarlas en clase o al correo: joaquin@ugb.edu.sv

Saludos.