Metodología


En los últimos días he dedicado algún tiempo a buscar información sobre mecanismos de Estimación Objetiva de proyectos de construcción de software.

 Es algo recurrente en mí. Cada año, más o menos, me entra esta ansiedad por encontrar la bola de cristal que me permita saber cuanto tiempo y esfuerzo va a costar construir el sistema A, B o C. Y cada año, tras el peregrinaje de rigor por las páginas, artículos y libros que versan sobre el tema, regreso a casa con la misma frustración.

El “Secreto de la Estimación Objetiva” dice:

Utiliza algún sistema homogéneo para medir el tamaño de un sistema.

¡Já! Empezamos por algo fácil. Es sencillo utilizar un sistema de medida homogéneo cuando las aplicaciones a medir son también homogéneas. Se pueden contar páginas, si se trata de aplicaciones web o, refinándolo más, contar los elementos que las generan (JSPs, ASPs, ficheros HTML, clases, EJBs, o lo que sea), asignándoles incluso un orden de complejidad. Esto nos permite comparar el tamaño de dos aplicaciones (“la aplicación A es el doble de grande que la aplicación “B”).

Pero ¿qué hacer si se trata de medir cosas algo diferentes? Hala! Compárenme una aplicación COBOL/CICS, con sus pantallas, transacciones, y todas sus cositas, con la aplicación web de antes. En este caso cuesta algo más comparar los tamaños de ambas.

Para salvarnos de este aprieto, aparece allá por 1979 (gracias, Allan Albrecht), los Puntos Función. En todos los casos, con algo de práctica, seremos capaces de contar los EO, EI, EQ, ILF, EIF y demás elementos. Aunque al no tratarse de pantallas, programas, rutinas, páginas, clases, etc. sino un nivel de abstracción superior, cuesta algo más de esfuerzo tomar las medidas.

Esto es otra muestra más de que cuando intentamos simplificar algo, como es el homogeneizar la medida de tamaño de sistemas heterogéneos, nos llevamos la complejidad a otra parte. Vamos, que hay que hacer un curso para medir bien con Puntos Función.

Traduce la medida resultante a algo tangible.

Es posible, por tanto, obtener una medida de tamaño de un sistema de software. Eso sí, no se consigue el tamaño en líneas de código, megabytes de los ficheros de código fuente o, lo que es mucho más util, horas de esfuerzo a realizar por un equipo de trabajo con una productividad media (otra variable más).

Para convertir los Adjusted Function Point -que tendremos que calcular a partir de los Unadjusted Function Point considerando los parámetros del entorno del proyecto- en algo útil, habrá que multiplicarlos por un “Número Mágico” que nos dará una aproximación al esfuerzo necesario de desarrollo, es decir, su coste (es decir, su precio).

Para obtener este factor -que, además no es inmutable- es preciso contar con una cierta historia en desarrollo de software. Si se conoce el esfuerzo que resultó necesario y los puntos función de cada uno de los sistemas desarrollados en el pasado, es posible obtener un factor de conversión suficientemente fiable como para ser capaces de predecir lo que costará un sistema nuevo.

Claro que es preciso que los proyectos analizados sean más o menos homogéneos, que no hayan tenido circunstancias excepcionales que desvirtúen la estimación, desarrollados preferiblemente en la misma compañía y entorno, y preferiblemente por el mismo equipo o equipos de cualificaciones semejantes.

Fácil ¿eh?

En resumen, que yo sigo contando pantallas y multiplicando por cincuenta.
Tags: Métricas, Metodología

Parece que esta bitácora va de leyes, así que ahí va otra:

No hables con desconocidos

Esta regla fue formulada en la Northeastern University en 1987 por Ian Holland. Y la explica magistralmente el blog Refactoring.

Es una regla comúnmente aceptada de buen Diseño, que se basa en el mínimo conocimiento del modelo de objetos, de modo que se reduzca el número y complejidad de las interrelaciones.

Aplicado la ley de Demeter a objetos, tendríamos que una operación de un objeto sólo tendría que utilizar:

  • Las operaciones propias del objeto.

  • Los objetos que tenga asociados o sean atributos del objeto.

  • Los objetos que recibe como parámetro la operación.

  • Los objetos que cree la operación.

Tags: Metodología, Programación

Ya lo dice Martin Fowler en su artículo sobre La Nueva Metodología: Ágil no es para todo el mundo. No hay reglas predeterminadas que nos ayuden a determinar claramente cuando utilizar una metodología Ágil o, por el contrario, una metodología clásica.

En cualquier caso, ahí van unas ideas:

Dedicación del cliente.

Difícilmente podemos aplicar una metodología ágil si no contamos con la adecuada involucración del cliente. En ese caso es mejor tomar requisitos muy concienzudamente al principio.

Tamaño del proyecto.

El tamaño no es una limitación en si misma, pero a mayor tamaño más complicado es implantar una metodología Ágil.

Estabilidad de los requerimientos.

Cuando los requerimientos cambian, una metodología Ágil puede ayudar a adaptarse a ellos. Para requisitos estables, quiza una metodología clásica ayude a evitar el re-trabajo.

Criticidad.

Yo personalmente no utilizaría una metodología Ágil para diseñar y construir un sistema del que dependan vidas humanas: los sistemas de navegación de un avión, por ejemplo.

Experiencia.

Esto es obvio. No uses metodologías Ágiles con equipos sin experiencia. Estas metodologías se basan en la capacidad y madurez de los miembros del equipo.

Apetencia.

Otra obviedad. Si no te apetece usarlas, pues no las uses.

Tags: Metodología, Programación

Una de las palabras-de-moda que encuentro cada vez más a menudo es la de Desarrollo de Software Ágil (Agile Software Development), en todas sus variantes: metodologías ágiles, modelado ágil, programación ágil…

Aunque esta idea surge a principios de 2001, es quizá ahora cuando está teniendo más auge, en gran parte por el uso publicitario que se está dando al término para calificar métodos, herramientas o productos que no lo son en absoluto.

Si tanto se habla de ello, ¿en que momento perdimos la agilidad? ¿o nunca la tuvimos?

Probablemente la agilidad la hemos ido perdiendo a medida que la Artesanía de Software (perdón, se me ha escapado otra vez) ha ido madurando a lo largo de un camino, largo y tortuoso, para intentar convertirse en una auténtica Ingeniería.

En ese afán, empezamos por aplicar las ideas de Dijkstra, y utilizar la programación estructurada – y el Análisis, y el Diseño, y las Metodologías, Warnier, Yourdon, etc. Eran los tiempos en los que el GOTO era un instrumento del diablo cuyo único objetivo era complicarle la vida a nuestros colegas programadores.

Luego, simplificandolo mucho, aparecieron la Modularidad, la Orientación a Objeto, los Patrones de Diseño, SOA. Con sus correspondientes técnicas y herramientas de Análisis, Diseño, Programación, etc. Todo ello bien aderezado con diversas Metodologías, Control de calidad, ISOs, CMMs y demás…

En definitiva, un loable intento de mejorar la forma de hacer software, como quien construye una casa, un coche o un avión.

Y claro, con tanta toma de requisitos, documentación de especificación y diseño, pruebas, controles de calidad, reuniones de seguimiento y demás tareas absurdas, es imposible ser ágil. Pero lo peor es que ni con esas conseguimos que nuestro software funcione bien del todo.

Bob y Dough son programadores en un equipo de Extreme Programming. Programan en pareja y desarrollan las pruebas antes que el código, utilizan técnicas de desarrollo incremental, y patrones de diseño. Refactorizan su código para mejorarlo cuando parece necesario, y sus programas siempre pasan la creciente batería de pruebas que han desarrollado para verificar la calidad de su software.

Pero el cliente no está contento. Han descubierto muchos errores en el software que, finalmente, se ha visto que se deben a una especificación incompleta del sistema.

Interesante fábula de Johnatan Kohl, que nos demuestra que parapetarnos tras unos métodos y técnicas considerados “buenos” por la industria no nos vale de nada si no nos centramos en satisfacer las necesidades de quien usa nuestro software.