web 2.0

viernes, 26 de marzo de 2010

Libros: Scrum y TDD


Pese a que las metodologías ágiles ya tienen más de una década, su uso en latinoamerica no ha sido tan profundo. Una de las principales razones, es la existencia de poco material en español!

Afortunadamente con el afán de promover principios ágiles, se han realizado traducciones de artículos y libros, por ejemplo, uno de ellos es "Scrum y XP desde las Trincheras", un libro obligatorio para todos aquellos que deseen aprender las bases de Scrum y XP de manera práctica! El libro es completamente gratuito!




TDD (Test Driven Development) es una práctica ágil cuya filosofía es desarrollar las pruebas unitarias antes de codificar cualquier funcionalidad del negocio! Este es un excelente libro gratuito escrito originalmente en español!



Ambos libros pueden ser comprados en su versión impresa por un módico precio!

¿Problemas?... Ese no es mi problema!!

La burocracia es uno de los problemas existentes en muchas organizaciones, principalmente en Gobierno! Desafortunadamente las empresas privadas no están exentas de esto!

El siguiente vídeo nos ilustra de una forma cómica lo que ocurre en muchas de las organizaciones! En el desarrollo de software por ejemplo, es muy común encontrarse con programadores egoístas que no comparten su conocimiento y cuando un integrante del equipo de trabajo tiene problemas, no faltara quien se niegue a ayudarle!... "Ese no es mi problema!!" pensamos rápidamente.

No solo programadores, sino todos los involucrados en el proyecto de desarrollo, nos corroe la envidia y buscamos únicamente que lo que nosotros hagamos este bien hecho, lo que hace el de al lado o el de frente no nos interesa. Se nos olvida que los objetivos requieren de una responsabilidad compartida y solo esta suma de esfuerzos harán que podamos obtener resultados cuantificables, es decir, metas!


lunes, 15 de marzo de 2010

El Fracaso en los Proyectos de Software

Última revisión: 17 de Marzo 2010
Antes de comenzar, debo aclarar que yo no tengo nada en contra de las metodologías tradicionales, al contrario, creo que su aplicación es muy eficiente en algunos tipos de proyectos, pero sin duda en la mayoría de proyectos empresariales, han demostrado ser ineficientes. Por esta razón, debemos dar una mirada a una nueva alternativa que lleva utilizándose con éxito en Europa desde hace más de 10 años!


Esta serie de articulos bajo el nombre “El fracaso en los proyectos de Software” es simplemente una recopilación de ideas que muchos expertos realmente involucrados en el desarrollo de software han vertido durante los últimos años:


Y a tantas otras personas que directa o indirectamente han influido en la filosofía ágile. (ver).

Esta primera parte, da solamente un acercamiento del entorno actual en el que se vive en muchas partes del mundo, principalmente, en México. En la segunda parte que comenzaré a escribir en breve, hablaré más especificamente sobre la filosofía de las metodologías ágiles y sus bondades.
Durante mi corta experiencia, he podido ver muchos Sistemas de Software de mediana escala con una calidad increíblemente pobre, con un mantenimiento que resulta un tormento y un tiempo de desarrollo cada vez más corto. Cuando lo anterior no sucede, el proyecto se termina, pero no cumple con las expectativas del cliente y termina siendo muy poco utilizado. Por ejemplo, una de las casas de préstamo de efectivo en México recientemente ha iniciado un nuevo proyecto para migrar su sistema de cobranza en .NET a una plataforma Java! Indudablemente la razón de esta migración no es por que .NET se haya quedado “corto”, más bien habla de una pésima aplicación que a estas alturas ya es inmantenible por su terrible calidad, derivado de una mala administración!

El fracaso de estos proyectos se atribuye a diferentes perspectivas, desde un nivel meramente técnico (personal mal capacitado), hasta una mala visión de negocio entre los niveles gerenciales. Mi intensión en este artículo no es hablar sobre los errores o aciertos que cometen los niveles gerenciales ya que en estos momentos no tengo injerencia en este campo por mi nula experiencia, así que me enfocaré más al problema derivado de una mala Ingeniería de Software y abrir la pregunta que Tom DeMarco lo plantea en uno de sus artículos…. La Ingeniería del Software es ¿Una idea obsoleta?

Esta serie de artículos, involucran a estudiantes y académicos y a profesionistas del mundo laboral.
A los estudiantes, para que conozcan lo que se viene trabajando en reino unido y países europeos con éxito desde hace más de 10 años. Además con esto espero que sepan que no todo en la vida de los sistemas es un conjunto de tablas, relaciones, frameworks y lenguajes de programación! Quienes me conocen, saben muy bien que mi formación ha sido eminentemente técnica, así que en definitiva no podrán decir que me intereso en este tipo de proyectos por que “no se programar”.

Al sector académico es una llamada de atención para que dejen a un lado sus ideas obsoletas sobre la Administración de Proyectos de Software, se haga una revisión a las retículas académicas y se actualice a la planta docente. Es hora de que los catedráticos sepan que hay otras cosas que el modelo en cascada (muchos ni siquiera enseñan algo de RUP) y peor aún ¿Por qué seguimos perdiendo el tiempo en hacer que el alumno domine un Microsoft Project para hacer bonitos pero inútiles diagramas de Gantt? Es hora que el sector académico se pregunte ¿Realmente todas estas prácticas están agregando un valor real al producto?… En México la educación es obsoleta, mientras en otras partes del mundo se enseña PSP/TSP, RUP, Ágile, Testing, etc., en México seguimos encerrados con nuestros diagramas de flujo, diagramas de contexto, y tantas otras prácticas obsoletas. Mi antipatía por el sector académico siempre ha sido notoria para todos aquellos que me conocen en persona y he sido un crítico muy duro con ellos. Yo mismo he vivido la ineptitud de muchos catedráticos, mi asesor de titulación quería diagramas de flujo y de contexto argumentando que los Casos de Uso eran para personas técnicas y no para los usuarios!!! Lo más triste era ver que se encontraba en el departamento de Posgrado pues era un Maestro en Ciencias!

Finalmente, a los profesionistas de hoy, a los desarrolladores que aún no conocen a los métodos ágiles, es seguro que ustedes estarán con muchas cosas de acuerdo.

Sin más que esperar una mentalidad abierta por parte de ustedes lectores, es hora de ver algunas de las razones por la que los proyectos de Software fracasan y ver bajo una filosofía agile una alternativa, aunque no  necesariamente una solución completa a los problemas existentes en el desarrollo de SW, pero Ágile puede influenciar aún más los conceptos de la Ing de Software tradicional!


SITUACIÓN ACTUAL
En el año 2006, John Avellanet utilizó un estudio realizado por Accenture para establecer los puntos necesarios que se requieren para alcanzar el éxito de un proyecto. Los datos sobre el entorno en el desarrollo de proyectos de TI era desalentador, desafortunadamente del 2006 a la fecha, las cosas no han cambiado en mucho.

  • Solo el 27% de los proyectos de TI puede ser considerado un éxito. 
  • Los proyectos de TI sobrepasan su costo en un 56%. 
  • Se estima que los proyectos sobrepasan su calendario en un 84%. 
  • El 31.1% de los proyectos son cancelados antes de que sean terminados. 
Lo anterior son números rojos alarmantes, que sin embargo, no son nada nuevos , estos números han existido desde un inicio.

Este proyecto es extremadamente importante.
No hay calendario, ni guias, ni el personal necesario…
Y su fecha de entrega es mañana!! Así que esta es su oportunidad
de impresionar realmente a todos!



CAUSAS DE TAN DESALENTADOR PANORAMA
Las causas son diversas. El Dr. Daniel Tapia, Profesor Investigador del Centro de Investigación en Tecnologías de la Información (CITIS) de la Universidad Autónoma del Estado de Hidalgo, atribuye el fracaso de un proyecto de TI a las siguientes razones;

  • Se daba mayor atención a las cuestiones operativas que a la planificación. 
  • Planeación deficiente. 
  • Los objetivos del proyecto no estaban alineados con los objetivos de la organización. 
  • El entorno global hace que la planeación tradicional ya no sea suficiente. 
  • Una mera planificación de actividades y recursos no sirve de nada. 
  • Se requiere una gestión estratégica. 

Existen puntos interesantes en las presentaciones del Dr. Tapia que recomiendo leer (ver al final de este artículo), aunque en algunas cuestiones, no concuerdo del todo, como por ejemplo donde hace mención que se requieren procesos bien definidos y una documentación extensa. Fuera de esto, el Dr. Tapia concluye que un simple enfoque de Ing. de Software ya no es suficiente, lo cuál es extremadamente cierto, sin embargo, en este artículo nos enfocaremos en dicho aspecto.
A los puntos anteriores, voy a agregar uno que seguramente puede ser causa de polémica por ser tan directo y acusador.


Durante muchos años, el sector académico ha tenido erróneamente mucha injerencia en el desarrollo de software cuando su papel no es precisamente ser el protagonista en este ámbito. Las universidades estan más interesadas en crear pequeñas fábricas de software, que en preparar de forma adecuada a los alumnos. Las empresas por su parte, se están enfocando en capacitar en cuestiones básicas a los alumnos que egresan en lugar de desarrollar software, es decir, los papeles se estan invirtiendo!! Las universidades están desarrollando software y las empresas están capacitando!!.

Hace poco más de un año, escuche al Director General de QuarkSoft, Cesar Montes de Oca, decir todo lo anterior! Ellos como empresa tenían que capacitar a los recién egresados sobre temas tan sencillos como realizar una simple conexión a base de datos con Java! Sin duda que algo muy pero muy grave esta fallando con las Universidades, pero bueno, afortunada o desafortunadamente no es tema de análisis en este estudio.

Grandes universidades que sin duda han hecho grandes aportes a la Ing. del Software, como por ejemplo la University Carnegie Mellon (en conjunto con el SEI), han desarrollado varios de los modelos y procesos para el desarrollo de Software como por ejemplo (CMM/CMMI, PSP/TSP., etc., “Avances” mismos que al día de hoy han demostrado ser ineficientes para la mayoría de los casos reales. Aquí en México por ejemplo, se ha creado MoProSoft como un modelo de desarrollo de software para las empresas mexicanas, modelo que ha sido lidereado por la Dra. Hanna Oktaba, académico del IMAS en la UNAM.


Es importante hacer un pequeño paréntesis y aclarar todo lo anterior para no crear malos entendidos. El sector académico ha hecho no solamente grandes aportes, más bien ha hecho todos los aportes de la actualidad en cuanto a las Ciencias Computacionales [Ver Ing de Software de Ian Somerville para una diferencia entre las Ciencias Computacionales y la Ing de Software]. Debemos agradecer a nuestros maestros de la universidad por enseñarnos aquellas estructuras de datos, por hacernos entender el algoritmo de Dijkstra, por explicarnos la notación O, por aquellos difíciles proyectos en lenguaje ensamblador y por aquellas Series de Fourier, etc., sin embargo, han olvidado que mucho de su trabajo es eminentemente teórico que puede demostrarse y realizarse en laboratorios, pero un proyeto de desarrollo de software no puede ser simulado y demostrado fácilmente.


¿Cuál es el problema de las Metodologías actuales?
La filosofía que siguen los métodos formales están basados en procesos aplicados en otras ingenierías como la ingeniería civil y mecánica en donde se requiere una planeación detallada antes de construir! Este es el punto medular de este artículo… “La planeación detallada“… Martín Fowler un verdadero gurú a nivel mundial, escribió un muy interesante y famoso artículo donde habla sobre “La nueva metodología” y da unas pautas generales que describen el error de las metodologías tradicionales y los aciertos que han tenido las metodologías ágiles.

Ha sido un error tomar casi al pie de la letra la filosofía de otras ingenierías y aplicarlas al desarrollo de software. En la ingeniería civil por ejemplo, los problemas importantes son suceptibles de un análisis matemático que determina por ejemplo, la fuerza a aplicar a ciertos elementos, la resistencia de los materiales, etc. En pocas palabras, los métodos que se utilizan en otras ingenierías son “predictivos” [entiéndase por predictivo que es posible "predecir" el comportamiento de un Sistema bajo ciertas condiciones]y funcionan muy bien en ese ámbito. Sin embargo, en el mundo del desarrollo de software comercial, ¿Como es posible predecir un cambio de requerimientos? ¿Es posible predecir la duración de un proyecto?… Muchas personas podrían argumentar que si es posible predecir lo anterior, quizá sí, pero no bajo modelos matemáticos como en otras ingenierías y por ende esta filosofía debería desecharse.

Lamentablemente, esta predicibilidad es muy usada en procesos tales como el PSP [Ver Personal Software Process del Dr. Watts Humprhey] , en donde debes ir haciendo todo un registro de tus tiempos, de tus distracciones, e ir sacando promedios de cada actividad a la que te dedicas para que de esta forma, en actividades similares posteriores, puedas predecir el tiempo que llevaras en construir cierto componente de software, aunado a esto, toda una serie de procesos formales intentan mejorar tu productividad y calidad en tus desarrollos. Los principios del PSP pueden ser aun muy discutidos, yo mismo me encuentro aún valorando sus bondades en ciertos tipos de proyectos.

Las metodologías tradicionales, al ser meramente predictivas, dicen que debemos hacer una toma completa y detallada de requerimientos al iniciar un proyecto, posteriormente asentar en documentos y diagramas UML la arquitectura del sistema a utilizar, después comenzar la construcción del sistema y finalmente una etapa de pruebas. Nótese la gran similitud con la ingeniería civil, en donde primero se diseña y después se construye!

Cuando se trabaja con metodologías tradicionales, existe una resistencia nativa al cambio. Las personas que trabajan en el proyecto se resisten a cualquier cambio de requerimientos, cosa contraria a lo que pasa con los métodos ágiles, en donde se piensa que los cambios son bienvenidos, se trata sencillamente de convivir con ellos y transformar una debilidad en una fortaleza.
La toma de requerimientos tradicional, indica hacer una detallada documentación y casos de uso donde se plasmen los requerimientos. Hoy en día ya sabemos que un desarrollo iterativo es mejor, en donde al inicio del proyecto se de solo un panorama general de todo lo que el usuario quiere y en cada iteración se desglosen un poco más los requerimientos.

El diseño de una arquitectura antes de la codificación es otro problema fundamental! Teóricamente lo anterior suena bien e incluso lógico, pues a final de cuentas, esto mismo se hace en otras ingenierías! Pero la práctica nos ha demostrado que el definir una arquitectura anterior a la codificación resulta muy problemática a la hora de codificar. La filosofía agile, nos indica que la mejor arquitectura que podemos definir en un inicio son cuestiones generales como la plataforma de programación, la BD y los frameworks que utilizaremos, pero la arquitectura detallada, ira fluyendo durante la codificación!


La etapa de pruebas es un asunto discutido. Por un lado, los tradicionalistas opinan que debe haber un equipo aparte del equipo de desarrollo que se encargue de probar el sistema, además de esto, nos indica que la etapa de pruebas se realiza al final de la etapa de codificación! En el lado ágil, tenemos que no existe un equipo aparte del equipo de desarrollo, los desarrolladores son y deben ser los mejores testers, además de esto, la práctica de TDD, nos dice que primero debemos crear la prueba unitaria antes de crear el módulo! Es decir, debemos crear primero una prueba unitaria para algo que aun no existe!! Esto es raro al inicio, pero aporta muchas ventajas!


El error de las personas que practican metodologías tradicionales
Son muchos los errores que siguen los project manager tradicionales. Desde el hecho de que las empresas gastan o se desviven en piratear licencias de sofisticados programas para elaborar diagramas de Gantt y hacer un detallado calendario de todo el proyecto con fechas de entrega, personas que realizarán cada una de las tareas y/o módulos existentes, plan de trabajo que desarrollo una noche antes el departamento de ventas para poder vender un proyecto de miles de pesos etc., hasta el hecho de designar un equipo especializado en “pruebas de software” que sea diferente al del equipo de desarrollo que realizará las pruebas al software en base a un detallado análisis en casos de uso de 100 páginas.


Otro error que cometen frecuentemente los administradores de proyectos es,

Yo Administrador de Proyectos, soy el único que puede dialogar con el cliente! Tu programador, tienes prohibido hablar con el cliente de cosas relacionadas con el proyecto, cualquier duda que tengas en los requerimientos debes dirigirte a mi, cualquier duda que tenga el cliente en la estimación de tiempo debes indicarle que se dirija conmigo.
Acaso al construir una casa, el maestro de obra habla con nuestros papás en lugar de hablar directamente con nosotros que somos los clientes??

Algo más irónico es por ejemplo, cuando una vez que el departamento de ventas diseñó nuestro plan de trabajo y decidió que nos llevaríamos 2 días en construir la interfaz que comunicaría nuestro módulo de consultas de proveedores externos con la tabla que existe en DBASE y que la transmición de datos se haría mediante un certificado digital de seguridad web SSL, además claro esta, de tener la opción de enviar un correo electrónico a los directivos cuando el monto de las facturas exceda el monto planeado que se tiene en SAP. Una vez que en la primer reunión que tuvo el depto de ventas con el cliente y entrego dicho plan de trabajo, el cliente quedo asombrado ante la rapidez de desarrollo y le dijo al departamento de ventas que entonces comenzaran ese mismo día con el proyecto! Entonces el departamento de ventas, corre inmediatamente a darle la excelente noticia al equipo de desarrollo que tiene 2 días para mostrar un primer entregable, que de el plan de trabajo y las estimaciones de tiempo, que ya ni se preocupen, que ellos muy amablemente ya lo hicieron por nosotros!

Entonces el equipo de desarrollo, manda rápidamente a su analista estrella a la toma de requerimientos. Este llega al siguiente día con unas 30 hojas de las cuales unas 25 contiene información redundante! Entonces el equipo de desarrollo tiene ya solamente 1 día para terminar el primer entregable!!!!

Lo anterior, obviamente es una descripción subjetiva que no esta muy alejado de la realidad. Por un lado, tenemos a muchosStakeholder como el cliente, el depto de ventas, gerencia, etc., que piensa que hacer software es como manufacturar algo o hacer enchiladas, que en cuestión de horas estará listo para funcionar!!

Por otro lado, tenemos a métodos formales que nos exigen hacer una detallada toma de requerimientos en extensos casos de uso y más importante aún, estar persiguiendo al cliente para que firme dichos requerimientos y así “asegurar” que estos no cambien en un futuro y si cambian entonces tenemos a un “cliente que no sabe lo que quiere” y nos negaremos a realizar el cambio y si lo realizamos, será con un costo adicional sobre lo planeado. Por si esto fuera poco, se nos ha enseñado que antes de iniciar la etapa de codificación, debemos elaborar una detallada arquitectura del sistema y plasmarla en muchos diagramas UML y documentos que puedan servir como referencia “más adelante”.

Esta idea de una Arquitectura detallada y modelado UML, funciona bien en la Ingeniería Civil, pero no en el desarrollo de software… Incluso, el hecho de que muchos catedráticos piensen que el UML es la octava maravilla del mundo, es debido a que los diseños en papel o en una herramienta UML son consistentes y se ven bien! De la misma forma en el mundo real y productivo, los diseños UML en un principio parecen ser correctos y el modelo parece ser lo suficientemente bueno para generar una buena arquitectura, pero los problemas surgen a la hora de la codificación, y es cuando vemos que los diagramas UML solo nos han servido para perder el tiempo!! Cuando lo anterior pasa, es entonces que vociferamos a todo mundo que el cliente tiene la culpa por no saber lo que quiere, que nuestro analista no “predijo” como si lo hubiera hecho Walter Mercado lo que el cliente iba a querer más adelante y que nuestro arquitecto de software no supo diseñar una arquitectura escalable y preparada para el cambio!! Y es que aún si suponemos un modelo exitoso con UML, el constante cambio de requerimientos hará que sucedan dos cosas posibles:

  • Se actualiza toda la documentación existente y además se procede con dicho cambio a nivel de codificación. Al actualizar los cientos de documentos existentes y dejarlos actualizados y acorde a los nuevos requerimientos, hemos perdido tiempo valioso en aquello que realmente aporta un valor o ventaja competitiva a nuestro cliente! Por lo tanto, ya tenemos un retraso de más de un 50% y no entregaremos a tiempo la funcionalidad o si la entregamos, estará llena de errores por la premura del tiempo. 
  • Dejamos de lado la documentación y nos enfocamos a lo que realmente aporta un valor al cliente! Desafortunadamente, a mitad del proyecto, este enfoque resulta triste, ya que hemos perdido la mitad de tiempo en elaborar documentación que, conforme el proyecto fue avanzando y evolucionando ha quedado obsoleta y ya no sirve de “base” para el mantenimiento del sistema, pues lo que comenzó como un simple sistema de facturación, terminó acercándose más a lo que es un ERP. Finalmente, la documentación pasa a ser un bonito recuerdo! 


No faltara quien a estas alturas pueda argumentar algo a favor del modelado detallado en UML y pueda decir:

“Uhmm, pero un diagrama de clases o de componentes, nos da una visión general de la estructura del sistema y esto es muy útil para saber como interactuan los componentes del sistema, así que es necesario realizar estos diagramas. Además los diagramas de despliegue por ejemplo son muy útiles cuando tratas con un cliente técnico.”

Lo anterior, es una idea desesperada por encontrarle un sentido a la existencia del modelado excesivo en UML. Bastaría hacer un refactoring a nuestro código fuente para obtener un diagrama siempre actualizado de clases o de componentes del sistema! Y todo en cuestión de minutos!!… ¿Para que perder el tiempo diseñando y planeando algo de naturaleza intangible que con el tiempo irá cambiando y evolucionando? Ahora bien, no todo en el UML es malo, los diagramas de despliegue por ejemplo son útiles, los diagramas de actividades son una versión más bonita de los diagramas de flujo, en un momento dado podrían ser útiles 2 o 3 diagramas de secuencia, etc. El punto aquí es el “exceso” que se comete con UML.
Aunado a lo anterior, todavía podemos decir mucho más….


  1. Los líderes y clientes, piensan que el hacer software es tan sencillo y rápido como introducir una fórmula en excel, por esto mismo, obligan a los desarrolladores a trabajar jornadas mayores a las 8 horas! 
  2. Los líderes de proyecto no están dispuestos a perder su autoridad! Es común que en los equipos, siempre exista una autoridad que tome todas las decisiones [programadores extrella, líderes absolutos]. Cuando un desarrollador sugiere o habla algo con el cliente, el líder siente perder autoridad, reacciona y entonces prohíbe una comunicación con el cliente! 
  3. Los equipos de trabajo siempre están a la espera de recibir órdenes, a que se les asigne una tarea, muchas veces a que se les diga como hacerla, etc. Mientras en la forma tradicional perdemos el tiempo esperando recibir ordenes, en las metodologías ágiles se fomenta a equipos auto-dirigidos! 

¿Es importante estar certificado en una norma ISO, CMM/CMMI/, MoProSoft, etc?
Muchas empresas no ven lo anterior como una posibilidad para realizar un cambio y mejora en sus procesos, en vez de eso, lo ven como algo superficial del cual pueden alzar el cuello y presumir ante sus clientes que tienen una certificación ISO xxxx-xxxx y que entonces son la mejor opción ya que sus competidores hacen software basura y ellos al tener una ISO, hacen desarrollos de calidad!

Yo mismo he vivido lo anterior. En mi primer trabajo profesional que tuve en el desarrollo de software, yo aún era estudiante y me toco vivir como la empresa para la que trabajaba, se preocupaba más por dar a conocer a los clientes que se contaba con la certificación MoProSoft nivel 1, cuando internamente no se conocía muy bien la forma de aplicar efectivamente dicho modelo.

El presidente de la empresa, siempre aseguraba que no podíamos presumir nuestras miserias al cliente! Ciertamente algo muy cierto, el problema era que nunca se preocupo por hacer un verdadero cambio de fondo. Pero bueno, el asunto original es si realmente es importante estar certificado en alguna de las anteriores normas y procesos formales para tener éxito en el desarrollo de software! Me permito citar nuevamente al Dr. Tapia:

No existe interés por métodos formales de aseguramiento de la calidad del software. Las empresas mexicanas están más preocupadas por conseguir la certificación de sus procesos con un distintivo de calidad, aunque dicha certificación no garantice la satisfacción de sus clientes.
Finalmente
Para terminar esta primera parte del artículo “El fracaso en los proyectos de Software”, debemos sacar las concluciones más relevantes.

  • Los métodos tradicionales, siguen un enfoque utilizado en otras ingenierías como la Ingeniería Civil y Mecánica, en donde, sus problemas son susceptibles a un análisis matemático que determinará el comportamiento de un sistema bajo ciertas condiciones. En el desarrollo de software, no es posible determinar con exactitud el comportamiento de los sistemas de software. 
  • Los métodos tradicionales y las personas que trabajan con ellos, siguen un riguroso esquema, en donde se aleja mucho al equipo de desarrollo y al cliente. El desarrollo ágil fomenta la comunicación desarrollador/cliente e invita al cliente a ser parte del equipo, mientras que los tradicionalistas sostienen que el líder de proyecto debe ser el responsable de hablar con el cliente. 
  • Cuando los proyectos fracasan, se cree que todavía debe agregarse una capa más detallada de procesos aún más formales y definidos, de planes aún más detallados, de más documentación, de más juntas de 3 horas, de una mayor vigilancia al equipo de desarrollo y de más horas de trabajo, cuando en realidad los principios deben ser muy sencillos. [ver el artículo de Emilio Osorio] 
  • Las empresas se preocupan más por tapar hoyos superficiales, por presentar un mundo de caramelo en sus desarrollos con el cliente y de obtener certificaciones aunque no entiendan como aplicarlas. 
  • En muchas empresas, la gerencia toma decisiones que no le corresponden y debe dejarlas a los verdaderos expertos. Muchas veces son estos niveles los que fijan el costo de un proyecto de software y la duración del mismo. Cuando menos lo esperamos, ya nos entregan un plan de desarrollo con fechas ya establecidas!. 
  • Durante más de 10 años, los métodos formales no han dado tantos resultados positivos. Lo preocupante de esto, es que al no dar los resultados esperados, día a día se piensa en agregar más formalidad y rigidez a su proceso. Los métodos ágiles tampoco son la solución a todos los problemas, pero si dan unas buenas pautas para reformular las actuales ideas de la Ingeniería de Software. 
En la segunda parte de este artículo, comenzaremos a ver a la filosofía de los métodos ágiles y veremos en ellos una mejor herramienta para tratar de resolver los problemas actuales en la administración y desarrollo de software.

Visita el blog próximamente para leer la segunda parte que será mucho más interesante! No olvides vertir tus comentarios que serán muy útiles para enriquecer este artículo! Tanto si eres un estudiante con o sin experiencia, un académico dando o no dando clases de Ing de Software, o un profesionista desarrollador o líder de proyecto! Todos los comentarios, buenos o malos, pero constructivos, son bienvenidos!


REFERENCIAS BIBLIOGRÁFICAS

    miércoles, 10 de marzo de 2010

    Métodos de Ordenación de forma concurrente


    En mi blog anterior, publique en el 2008 un artículo sobre la ordenación de un arreglo de números aleatorios mediante 3 métodos: QuickSort, Burbuja e Inserción. Pero estos métodos se ejecutaban de forma concurrente mediante Threads. En ese tiempo, no se la razón por la cual no subi el código fuente y mucha gente lo solicito en los comentarios de dicho artículo!
    Pongo aquí el código fuente para su descarga!

    martes, 9 de marzo de 2010

    Números palindrómicos


    En projecteuler.net se ofrece el siguiente problema:
    Un número palindrómico se lee de la misma forma en ambos sentidos. El palíndromo más grande a partir del producto de dos números de 2 dígitos es 9009 = 91 x 99.
    Encontrar el palíndromo más grande a partir del producto de dos números de 3 dígitos.
    A continuación les planteo la solución original que yo hice antes de acertar a la respuesta y poder ver la solución que se plantea en la misma página una vez resuelto el problema!


    public Set calcularPalindromosNumerico(Integer min, Integer max){
            Set <Integer>listaPalindromos = new HashSet<Integer>();
            for(int i = min; i <= max; i++ ){
                for(int j = min; j <= max; j++){
                    Integer res = j*i;
                    if(isPalindromo(res))
                        listaPalindromos.add(res);
                }
            }
            return listaPalindromos;
        }
    


    Lo primero que cabe resaltar en el método anterior es que utilizamos una clase “Set” con el único propósito de no almacenar resultados repetidos (100*110 y 110*100 por ejemplo) [Recordamos que la clase Set no almacena datos duplicados]. Lo segundo que hay que notar es que el método recibe objetos envoltorio Integer. Esto es así ya que la lista que contendrá los números palindrómicos no estará ordenada y usaremos al método estático “sort” de la clase Arrays para ordenar dicho arreglo, pero para que lo anterior funcione, los elementos a ordenar deben implementar a la InterfazComparable según nos lo indica la documentación de la clase Arrays, así pues, los envoltorios de los tipos primitivos implementan a esta interfaz y es por ello que el método recibe objetos Integer en lugar de int.
    Por último, creamos otro método que permita validar si un número es palindrómico.

    public boolean isPalindromo(int numero){
            String palindromo = ReverseString.reverseIt(
                    String.valueOf(numero));
     
            if(numero == Integer.parseInt(palindromo))
                return true;
            else
                return false;
        }
    

    ReverseString es una clase que podemos encontrar aquí
    Lo único que nos resta hacer es crear el método main que nos permita comprobar el resultado:

    public static void main(String []args){
            Palindromo palindromo = new Palindromo();
            Object[] listaPalindromos = palindromo.calcularPalindromosNumerico
                                    (100,999).toArray();
     
            Arrays.sort(listaPalindromos);
            for(Object i : listaPalindromos){
                System.out.println(i);
            }
        }
    

    El 100 y 999 que se pasan como argumentos al método, esta claro que es el primero y último número de 3 cifras que existen!
    De esta forma, obtenemos que el palíndromo más grande resultado de la multiplicación de dos números de tres cifras es: 906609
    En la misma página de project euler , se proporciona un PDF con el algoritmo que da solución al problema! Pero este PDF solo lo podremos ver una vez que hayamos acertado a la respuesta!
    Como complemento, para hallar números palindrómicos, existe el 196-Algorithm que pueden revisar como lectura adicional!
    Saludos!!

    domingo, 7 de marzo de 2010

    Project Euler: Matemáticas y Programación


    Project Euler es una página que consta de más de 200 problemas matemáticos, que por su dificultad en el número de operaciones y cálculos, no son posibles de resolver sin la ayuda de la programación!
    Hace 2 días recién me inscribí, así que al día de escribir esta entrada, solo llevo 5 ejercicios resueltos! Desde luego que he iniciado con los más fáciles!
    Lo interesante de esto es que para entrar a un nivel “novice” debes tener entre 100 a 149 problemas resueltos! De lo contrario, estarías en el nivel 1 o 2 los cuales no son tan válidos, ya que si en un lapso de 60 días no resuelves ningún problema, desapareces del record! El nivel 3 es el nivel “novice” y en este nivel es cuando ya puedes quedar inmortalizado en el score sin importar el tiempo que ha pasado desde la última vez que resolviste un problema!
    Para muestra del tipo de ejercicios, he aquí el primero que resolví el cual es un verdadero regalo!
    If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23. Find the sum of all the multiples of 3 or 5 below 1000.
    public class Multiplo {
        public int sumarMultiplos(int rango, int numeroUno, int numeroDos){
            int suma = 0;
            for(int i = 1; i
    Como ven, se trata de un problema bastante sencillo! Estaré poniendo en este blog todos los problemas que vaya resolviendo! Aunque solo lo hago cuando tengo por ahí un tiempo libre!
    Saludos!!

    DB4O: El poder de las Bases de Datos Orientadas a Objetos



    DB40
    Hace alrededor de 1 año, conocí a DB40, una Base de Datos Orientada a Objetos Open Source!… ¿Pero qué es DB4O? y sobre todo ¿para que me sirve si ya se utilizar MySQL, SQL Server, Oracle y otro manejador de Base de Datos Relacional?… Estas preguntas son las que trataré de responder a continuación.

    ¿Qué es DB4O?

    Bien, como ya lo dije arriba, DB40 es una Base de Datos Orientada a Objetos de alto rendimiento. En algunos Benchmark realizados, DB4O muestra un rendimiento superior o similar a las Bases de Datos Relacionales, en el caso de Java, utilizando JDBC o algún Framework como Hibernate! Podemos ver estas pruebas en la página de polepos.org

    ¿Hibernate?… ¿Qué es eso?

    Bien, si no sabes que es Hibernate te lo explicare a continuación!
    Hibernate es una “herramienta” para Java (NHibernate es la versión para .NET) que nos permite poder conjuntar sin ningún problema al modelo Orientado a Objetos con el Relacional! Debes de saber que ambos modelos no son compatibles!

    Pero yo he utilizado Java y MySQL… ¿Como no van a ser compatibles?

    Es verdad, el paradigma Orientado a Objetos con el Modelo Relacional son incompatibles. No importa que tu hayas trabajado y desarrollado una aplicación que guarde datos en MySQL mediante Java, C# o algún otro lenguaje OO, en realidad lo único que has hecho, es escribir una simple sentencia SQL y enviarla al manejador de BD pero desde Java.
    El hecho de enviar sentencias SQL a algún manejador de BD Relacional, no significa que sean compatibles!… Pero bueno, finalmente ¿A que me refiero cuando digo que son incompatibles?,.. pues bien, veámoslo con un ejemplo.
    Persona ximena = new Persona("Ximena", "Rodriguez", 'F');
    JDBC.save(ximena);
    Si Java fuera compatible con MySQL/PostgreSQL/etc., el código anterior, indudablemente funcionaria! Es decir, sería posible guardar objetos! En lugar de eso, necesitamos utilizar variables escalares que contienen los valores que deseamos guardar, concatenarlas a otra cadena que tiene la sentencia SQL y finalmente enviarlas al manejador de Base de Datos mediante una alguna interfaz que comunique Java con  MySQL/PostgreSQL/etc., como lo es JDBC.
    public void guardar(String nombre, String aPaterno, char sexo){
        stmt.executeUpdate(
                    "INSERT INTO persona("nombre, paterno, sexo )" +
                        "VALUES(' "+nombre+', ' "+aPaterno+" ', ' "+sexo+" ')");
    }
    Y para recuperar datos, es lo mismo, debemos enviar una consulta SELECT * FROM y con el resultado que nos devuelve la BD, ir iterando sobre cada registro para guardar el valor en variables o en Listas.
    Finalmente podemos ver el esfuerzo requerido para conectar los dos mundos;
    import java.sql.*;
    
    public class Jdbc10 {
      public static void main(String args[]){
        System.out.println(
                      "Copyright 2004, R.G.Baldwin");
        try {
          Statement stmt;
          ResultSet rs;
    
          //Register the JDBC driver for MySQL.
          Class.forName("com.mysql.jdbc.Driver");
    
          //Define URL of database server for
          // database named JunkDB on the localhost
          // with the default port number 3306.
          String url =
                "jdbc:mysql://localhost:3306/JunkDB";
    
          //Get a connection to the database for a
          // user named auser with the password
          // drowssap, which is password spelled
          // backwards.
          Connection con =
                         DriverManager.getConnection(
                            url,"auser", "drowssap");
    
          //Display URL and connection information
          System.out.println("URL: " + url);
          System.out.println("Connection: " + con);
    
          //Get a Statement object
          stmt = con.createStatement();
    
          //As a precaution, delete myTable if it
          // already exists as residue from a
          // previous run.  Otherwise, if the table
          // already exists and an attempt is made
          // to create it, an exception will be
          // thrown.
          try{
            stmt.executeUpdate("DROP TABLE myTable");
          }catch(Exception e){
            System.out.print(e);
            System.out.println(
                      "No existing table to delete");
          }//end catch
    
          //Create a table in the database named
          // myTable.
          stmt.executeUpdate(
                "CREATE TABLE myTable(test_id int," +
                      "test_val char(15) not null)");
    
          //Insert some values into the table
          stmt.executeUpdate(
                    "INSERT INTO myTable(test_id, " +
                        "test_val) VALUES(1,'One')");
          stmt.executeUpdate(
                    "INSERT INTO myTable(test_id, " +
                        "test_val) VALUES(2,'Two')");
          stmt.executeUpdate(
                    "INSERT INTO myTable(test_id, " +
                      "test_val) VALUES(3,'Three')");
          stmt.executeUpdate(
                    "INSERT INTO myTable(test_id, " +
                       "test_val) VALUES(4,'Four')");
          stmt.executeUpdate(
                    "INSERT INTO myTable(test_id, " +
                       "test_val) VALUES(5,'Five')");
    
          //Get another statement object initialized
          // as shown.
          stmt = con.createStatement(
                   ResultSet.TYPE_SCROLL_INSENSITIVE,
                         ResultSet.CONCUR_READ_ONLY);
    
          //Query the database, storing the result
          // in an object of type ResultSet
          rs = stmt.executeQuery("SELECT * " +
                    "from myTable ORDER BY test_id");
    
          //Use the methods of class ResultSet in a
          // loop to display all of the data in the
          // database.
          System.out.println("Display all results:");
          while(rs.next()){
            int theInt= rs.getInt("test_id");
            String str = rs.getString("test_val");
            System.out.println("\ttest_id= " + theInt
                                 + "\tstr = " + str);
          }//end while loop
    
          //Display the data in a specific row using
          // the rs.absolute method.
          System.out.println(
                            "Display row number 2:");
          if( rs.absolute(2) ){
            int theInt= rs.getInt("test_id");
            String str = rs.getString("test_val");
            System.out.println("\ttest_id= " + theInt
                                 + "\tstr = " + str);
          }//end if
    
          //Delete the table and close the connection
          // to the database
          stmt.executeUpdate("DROP TABLE myTable");
          con.close();
        }catch( Exception e ) {
          e.printStackTrace();
        }//end catch
      }//end main
    }//end class Jdbc10
    Código fuente: Using JDBC with MySQL, Getting Started
    Con DB4O es tan sencillo conectar a la BD como hacer lo siguiente:
    // Crear una base si no existe, abrirla si ya existe.
         File file = new File("testDb4o.yap");
         String fullPath = file.getAbsolutePath();
         ObjectContainer db = Db4oFactory.openFile(file);
         try{
               // realizar alguna acción con db4o
               // Ejemplos :
               db.set(obj);  // Almacena un objeto en la base
               db.commit();       // Realizar la transacción (y arrancar otra)
               db.delete(obj);   // Eliminar un objeto en la base
         }
         finally{
               db.close();         // Cerrar la base y liberar los recursos
    }
    Existe abundante documentación en ingles y en español sobre el uso de DB4O con Java y C#, al bajar DB4O de la página oficial, encontraremos en dicha carpeta, un completo tutorial en español sobre su uso, además de una guía de referencia! De igual forma, existe un libro “The definitive guide to db4o” que aunque no es la versión actual, sin duda es un excelente comienzo para iniciarse en esta fantástica BD.

    Finalmente… Dijiste que Hibernate conjunta los dos mundos, ¿Como lo hace? y si ya lo hace, ¿Para que usar DB4O?

    Bueno, Hibernate utiliza archivos XML para “mapear” clases Java con columnas de una Tabla Relacional y mediante este mapeo, es posible hacer algo similar al código que vimos para guardar objetos en DB4O, pero la diferencia es que Hibernate internamente se encargará de hacer dicho “mapeo” por nosotros e insertar en las columnas de la Tabla Relacional! A cambio de esta comodidad de utilizar Java y MYSQL/SQL Server/etc., Hibernate disminuye el rendimiento de la aplicación!
    Es causa de mucha polémica decir si DB4O es o no es la opción idónea para aplicaciones empresariales de gran escala, por lo mismo que las Bases de Datos Orientadas a Objetos no tienen un fuerte sustento matemático como si lo tienen las Relacionales, su penetración no ha sido tan fuerte! Por lo anterior, la industria del Software no ha querido experimentar en ambientes reales de gran escala la potencia de DB4O.
    Independientemente de lo anterior, DB4O es la mejor opción para aquellos desarrolladores Freelance que desarrollan aplicaciones de escritorio o incluso web que no requieren de almacenar millones de datos!
    Algunos recursos sobre el uso de DB4O son: