Kanban: el método Toyota aplicado al software

Después de haber aplicado un alto porcentaje de Scrum en los proyectos de software en los que trabajo, siento curiosidad por todas las demás metodologías ágiles que existen, sobre todo, para saber si hay alguna práctica que pueda emplear que me permita optimizar algún aspecto de la actividad diaria a desarrollar.

En este aspecto, he descubierto en Kanban un interesante aliado para aspectos de la metodología que quedaban algo descolgados, y son los procesos rutinarios, o solo tener presente la continuidad de las tareas, ya que las tareas que se realizan en Kanban pueden aparecer en el backlog en cualquier momento e ir haciéndose, según su importancia y/o prioridad.

¿Qué es Kanban?

La palabra kanban (en kanji 看板, en katakana カンバン) parte de las palabras kan (看 o カン) que significa visual y ban (板 o バン), que significa tarjeta o tablero. La idea surge en el seno de la metodología de Lean, la cual fue desarrollada por Toyota, para mejorar la producción, basándose en técnicas como just-in-time (JIT).

Los principios que se promueven son:

 

  • Calidad perfecta a la primera. Todo lo que se hace, debe de intentar hacerse bien, no rápido, ya que cuesta más tiempo hacer algo rápido y tener que arreglarlo después, que hacerlo bien desde el principio.
  • Minimización del despilfarro. Hacer lo justo y necesario (y hacerlo bien, como se decía antes) y no entretenerse en otras tareas secundarias o no necesarias (principio YAGNI).
  • Mejora continua. Ir mejorando continuamente los desarrollos, según los objetivos a lograr y alcanzar.
  • Flexibilidad. Lo siguiente a realizar se decide del backlog pendiente, con lo que las tareas entrantes se pueden priorizar y condicionar según las necesidades puntuales.
  • Construcción y mantenimiento de una relación a largo plazo con los proveedores.

 

En el desarrollo del software, el sistema kanban se puede resumir como la visualización de las tareas mediante un tablero, en el que se van moviendo entre los sectores delimitados, con el objetivo de tener siempre presente el trabajo a realizar y lo que hace cada uno. Que nadie se quede sin trabajo y que todas las tareas importantes se realicen primero.

foto-kanban

El tablero visual

El tablero de kanban, el cual debe estar visible a todo el equipo de trabajo, tiene la peculiaridad de ser un tablero continuo. Esto quiere decir que, no se rellena con tarjetas y se van desplazando hasta que toda la actividad ha quedado realizada (como pasa en Scrum), sino que a medida que se avanza, las nuevas tareas (mejoras, fallos o tareas del proyecto) se van acumulando en la sección inicial, en las reuniones periódicas con el dueño de producto (o el cliente) se priorizan las más importantes, y se encolan en las siguientes zonas.

Además, las secciones que se pueden incluir en el tablero, además de diseño, desarrollo y pruebas, son las de paso a producción, con lo que, se tendrían todas las tareas en un seguimiento exhaustivo, desde que se piensan que deben de hacerse, hasta el punto en que se ha llevado a producción.

project-kanban

Como se puede ver en la figura, cada sección vertical, puede anidarse en conjuntos, de modo que la tarea de desarrollo, por ejemplo, pueda descomponerse en otras más significativas como: en cola y en desarrollo.

Los grandes grupos verticales, pueden pertenecer incluso a grupos de desarrollo diferentes, por ejemplo, un grupo de desarrollo puede encargarse del desarrollo, y otro de las pruebas y subida a producción, o incluso entre departamentos, tomando un último grupo para puesta en producción o incluso un primer grupo para la toma de propuestas y priorización de tareas.

Lo más corriente es que exista un grupo inicial, el dueño del producto, que se encargue de organizar las propuestas o entradas, y sea el propio cliente o incluso, si es para desarrollos internos, los departamentos de comercial y/o marketing. Depende de la empresa.

Las tarjetas

La importancia de la identificación rápida de tarjetas, en un tablero de amplias dimensiones es vital para ahorrar tiempo, con lo que, se pueden asignar colores, como pueden ser: verde para las mejoras, amarillo para las tareas del proyecto y rojo para los errores.

Además de esto, las tarjetas de kanban suelen tener bastante más información, ya que el método consiste en tener todo visual, para saber de forma rápida la carga total de trabajo, ya sea de los grupos, como del departamento, etc.

Se suelen emplear tarjetitas con fotos o caricaturas que se ponen junto con la tarea que está desempeñando en cada momento cada persona, así como emplear post-it sobre las propias tarjetas para indicar observaciones sobre la tarea, o bloqueos que se puedan sueceder, es decir, que la tarea no se pueda realizar porque depende de algún factor no resuelto aún.

tarjetas

Es importante reseñar que las tarjetas debe de tener la estimación de tiempo que tiene asignada la tarea, así como se pueden anotar las fechas de entrada en cada cuadrante, para tener información, al término de la tarea, de si ha sido una buena estimación, así como obtener el rendimiento del equipo de trabajo.

Control del Flujo

El sistema kanban, a diferencia de scrum, no se dedica a llevar la pista de un solo proyecto, sino que se pueden entremezclar tareas y proyectos. El método se basa en tener a los trabajadores con un flujo de trabajo constante, las tareas más importantes en cola para ser realizadas y un seguimiento pasivo, a modo de no tener que interrumpir al trabajador para saber qué hace en cada momento.

Por otro lado, se puede seguir la pista del trabajo realizado por el grupo de trabajo almacenando los datos que las tarjetas nos proporcionan, una vez llegan a el sector final (cuando ya están en producción), con una gráfica de este estilo:

cfd

En el gráfico de áreas apiladas, se ve claramente el tiempo dedicado a cada sector. En el caso expuesto, por ejemplo, se ve que las tareas pasan más tiempo en backlog (el sector de propuestas o esperando a comenzar su desarrollo) que en la zona de desarrollo, propiamente dicha.

Conclusiones

El sistema de kanban tiene ciertas ventajas con relación a otras metodologías que ya había visto, ya que permite no solo llevar el seguimiento de un proyecto de forma individual, sino también de las incidencias que se van sucediendo, así cómo otros proyectos paralelos que tenga que hacer el mismo equipo de desarrollo, por lo que, nos damos cuenta de que, de lo que se lleva la pista en sí, no es de los proyectos, sino de los equipos de trabajo.

Lo veo indicado, sobre todo en sitios donde las operaciones (incidencias, tareas repetitivas y aisladas) son más comunes que el desarrollo puro y duro de proyectos, es decir, en entornos que necesiten de flexibilidad en la entrada de tareas, así como un seguimiento de las mismas, un sistema de priorización, control de un equipo de trabajo e informes de dedicación.

Planificación de Póker

Leyendo un artículo de una página de una empresa suiza (Crisp), he visto a lo que se refiere la planificación de póker. Voy a traducir gran parte del artículo para explicarlo.

Introducción

La estimación es una de las actividades del núcleo de Scrum y otros procesos ágiles. Este proceso se refiere a darle una duración a cada historia, p.ej. ¿cuánto tiempo tomaría?, ¿cuánto trabajo tiene su implementación?, ¿cómo de caro es?, o cualquier otra cosa que quieras poner.

En Scrum, la estimación es una actividad de equipo. Para cada historia, todo el equipo participa en el proceso de estimación.

La planificación de póker (a veces llamada Scrum Póker) es simple, pero una potente herramienta que hace la estimación de equipo más rápida, más precisa y más divertida. El término fue acuñado por James Grenning y popularizado por Mike Cohn.

Estimación sin Planficación de Póker

Aquí hay un problema típico con las estimaciones de equipo. Cuando estamos en la planificación de un sprint y el Dueño del Producto dice:

Vale, chicos, ¿cuánto tiempo necesitáis para esta historia?

El equipo comienza a pensar acerca de la duración de la historia (en el caso ideal de hombres-día)…

El participante A cree que el sabe exáctamente lo que necesita para hacerse, así que él piensa que puede tomar 3 días. Los participantes B y C son más pesimistas. Los participantes D y E están fuera de la conversación. El participante A dice “3 días”.

Esto hace que los participantes B y C queden confusos. Comienzan a dudar de sus propias estimaciones. El participante E despierta y no sabe realmente qué está siendo estimado. El participante D está aún dormido.

El dueño del producto pide al resto del equipo su estimación.

Como se puede ver, el resto del equipo ha sido fuertemente influenciado por el participante A, solo porque él habló primero. ¡Esto es muy arriesgado!, Tanto B como C pensaron que podría tomarse mucho más de 3 días, ¡sus dudas deberían ser aireadas!

Estimación con Planificación Póker

Ahora imagina que cada miembro de equipo tiene una baraja de cartas, conteniendo las siguientes cartas:

Vamos a rehacer la estimación. El dueño de producto dice:

Vale, chicos, ¿cuánto tiempo necesitáis para esta historia?

Una vez de nuevo, el equipo comienza a pensar sobre el tiempo que tomaría la historia.

Esta vez, nadie dice nada. En lugar de eso, todos tienen que presentar una carta, bocaabajo, conteniendo su estimación. Todo el mundo tiene que tener presente una carta, así que los participantes D y E despiertan. El participante D admite que estaba durmiendo y pide que se le repita la historia. Es difícil evadirse cuando se estima de esta forma :-)

Cuando están todos, todas las cartas se destapan simultáneamente, revelando las estimaciones de todos.

¡Oooops! Gran divergencia. El equipo, en particular los participantes A y C, necesitan hablar sobre esta historia y el porqué sus estimaciones son tan diferentes. Después de la charla, el participante A dice que había olvidado algunas tareas importantes que necesitan incluirse en la historia. El participante C dice que, con el diseño que el participante A presentó, la historia parece ser más pequeña de 20.

Después de la charla (3 minutos en total) hacen otra ronda de estimación para la misma historia.

¡Convergencia! Vale, no hay una convergencia completa, pero están de acuerdo en que una estimación de 5 puede ser lo suficientemente cercana. Siguiente historia.

¿Por qué la extraña serie de números?

El más alto de los números tiene menos granularidad. ¿Por qué?, ¿Por qué no hay 21, por ejemplo?

Por varias razones:

  • Acelera el proceso de estimación limitando el número de opciones (p.ej. número de cartas).
  • Elimina una falsa sensación de precisión para estimaciones altas.
  • Potencia al equipo a partir historias grandes en otras más pequeñas.

Una estimación alta (mayor de 20, por ejemplo) normalmente quiere decir que la historia no se entendió bien en detalle. Podría ser una pérdida de tiempo discutir si la historia tiene 19, 20 ó 22,5. Esta es, simplemente, una historia grande y un 20 debería reflejar eso. Si deseas entrar en detalle, rompe la historia en varias historias más pequeñas. Las pequeñas historias pueden ser estimadas en gran detalle.

Cartas Especiales

La carta cero significa esta historia está hecha o la historia es tan corta que se puede hacer en muy pocos minutos de trabajo.

La carta del signo de interrogación significa No tengo ni idea. Debería de ser rara. Si esta carta es usada demasiado frecuente, el equipo necesita hablar las historias más e intentar alcanzar un mejor conocimiento.

La carta del café significa Estoy demasiado cansado para pensar. Vamos a tomar un descanso.

Conclusión

Después de leer el artículo completo, saco en conclusión que, algo como es la capacidad de comunicación, es algo que hay que intentar potenciar en los equipos de desarrollo, a modo de que, no solo todos y cada uno se puedan expresar, sino emplear técnicas como esta para que su expresión no sea opcional, sino parte del juego.

Es importante que la opinión de un miembro del equipo no se vea afectada por la de otro, a menos, hasta poner toda la información sobre la mesa, que es cuando ambos, deben de afectarse por la información del resto del equipo, y llegar a un punto de comunicación e información que le dé consistencia a la estimación.

Lo justo y lo estándar

Desde hace unos meses, he estado envuelto en algunos proyectos, en los que he intentado dar un enfoque basado en patrones y estándares, para facilitar y simplificar los problemas. Solo que, hay patrones y sistemas, o frameworks, que son algo incompatibles entre sí.

Por ejemplo, el uso de un sistema BPM, puede ser compatible con un sistema REST como Ruby on Rails, mientras se mantenga la idea de REST… en cambio, si se modifica por intentar realizar un poco interoperatibilidad entre otros sistemas, a los cuales no se les quiere cambiar mucho la forma… se convierte en un infierno.

Al final, lo mejor, es mirar la piezas con las que queremos contar, por ser afines a los resultados que queremos obtener y, emplear única y exclusivamente, los patrones que se puedan ajustar bien a esas piezas.

En este caso, por ejemplo, Ruby on Rails, combina bien con sistemas BPM que sean REST, e incluso con bases de datos que sean REST, pero le quita características bastante deseables que sí tiene otro patrón como ActiveRecord, ante lo cual, se establece un sistema de preferencias y prioridades… ¿REST o ActiveRecord?… como es lógico, optando por ActiveRecord, desaparece BPM como tal, ya que ActiveRecord está hecho para su acceso directo a base de datos.

Pero al final, la base de datos, bien mirada, termina siendo nuestro sistema BPM y, con ayuda de procedimientos almacenados, triggers, usuarios y demás… es un sistema, no tan potente como otros, pero sí lo suficiente como para cumplir con las especificaciones básicas.

Bueno, al final, me doy cuenta de que, al igual que cuando se programa, se debe de decidir bien la estructura, los elementos a emplear, la forma y demás… cuando se desarrolla, se ha de tener especial cuidado con las metodologías, patrones de diseño y estándares, puesto que hay que comprobar que coordinen bien entre sí.

Escalado de Ruby on Rails

Después de liberar el primer proyecto escrito en Ruby on Rails, cuando lo pasamos a producción, nos dimos cuenta de que el sistema funcionaba realmente lento. En algunos casos, incluso, no respondía, con lo que buscamos información por internet y vimos:

Mongrel y Thin no son multi-hilo

Fue algo que nos sorprendió mucho, una aplicación servidora secuencial, que atiende las peticiones una a una y, en caso de que una petición se tarde un par de segundos (que las teníamos :-S ), el sistema se queda trabado durante todo ese tiempo.

Las soluciones posibles eran dos:

  • Phusion Passenger, también conocido como mod_rails, es un módulo para Apache que mantiene tantos hilos como peticiones se vayan gestionando, siempre con unos límites máximos y mínimos, tal y como apache suele hacerlo.
  • Ngnix + Thin, esta solución fue un poco más artesana, por decirlo de alguna forma, ya que consistía en configurar este servidor web como proxy inverso, para hacer el balanceo de peticiones entre todos los hilos de thin que se quieran cargar en el sistema. Descartamos en este punto a mongrel por comentarios que había leído en otros blogs.

Bien, por correr lo más posible, lanzamos tantos hilos como nos fue posible en la máquina que dedicamos al proyecto y, nos complació ver que podía aguantar hasta 40 hilos, sin que sus CPUs lo notasen apenas. Con lo que conseguimos un pool de 40 puertos dedicados a atender peticiones HTTP.

En otra máquina se configuró un proxy inverso. En el escenario de pruebas usamos nginx, aunque el tenerlo en la misma máquina y hacer pruebas masivas, nos dio como resultado que una cantidad importante de peticiones se perdían o transformaban en respuestas de tipo 500 por parte de nginx. Optamos entonces por un balanceador que tiene la compañía vía hardware, muy rápido y, a día de hoy el sistema web tira tan rápido y casi mejor que el que tenemos montado en PHP :-)

En el próximo artículo comentaré las configuraciones, arquitecturas y demás seguidas, sobre todo a nivel de nginx y thin, que es lo que realmente interesa.

Shoes: programación fácil de GUI en Ruby

Cuando se realizan scripts para ciertas tareas para automatizarlas, pero que tienen que tomar datos del usuario, así como los datos que se presentan son útiles, tanto para rápida consulta, como para dar dicha información por teléfono o usarla en el código, otra interfaz, etc. surge el problema de que la consola se hace un paso como a otro mundo y resulta incómodo.

Una forma de ahorrar la pulsación de teclas, diseñando una interfaz que nos sea útil y presente la información, así como la toma de datos, de forma organizada y práctica, son las aplicaciones basadas en GUI, que se han comenzado a introducir en lo lenguajes de scripting… solo que, el uso de los mismos, se hace tan tedioso, que resulta incómodo realizar una interfaz para usuario en esos sistemas.

Hace poco, en un curso de Ruby on Rails que estaba dando Dani, un colega muy versado en Ruby y su mundo, nos enseñó un juguetito bastante gracioso para hacer GUI desde Ruby: Shoes.

Lo instalé para GNU/Linux y lo comencé a probar… en cuestión de una hora tenía una pequeña aplicación que tomaba información de un ActiveRecord, hacía una consulta según los datos de entrada que le introducía y rellenaba el resto del formulario con los datos de salida… muy útil en esos momentos para la resolución de incidencias, ya que suelen venir con datos incompletos y la resolución debe de ser rápida (y ya estaba cansado de ir a golpe de consulta SQL… mucho que teclear para obtener solo un par de datos :-P )

En la misma página hay un tutorial y, bajando el código, se pueden ver ejemplos donde hay desde programitas simples de reloj, hasta videojuegos en 3D :-) … lo recomiendo, a mi me ha ayudado mucho.

De Programador a Desarrollador

Cuando tenía doce años, comencé a programar en Basic, en un ZX Spectrum de 128K… en esos momentos, y los años siguientes, hacer un programa, para mi, era sentarme delante de mi ordenador, durante unas cuantas horas, incluso echando noches en vela, para al final ver el resultado… un pequeño programa de gestión de contactos, un juego de puzzle, tetris, plataformas 2D… y eso, a lo largo de los años… y de los lenguajes, pasando por Basic, C, C++, Modula-2, Pascal, Java, Perl, PHP, Python, Ruby, Erlang…

La programación se convierte, en mi vida, en mi tiempo libre y, después, en mi trabajo, en una forma de realizar programas de ideas que me surgen, de forma heróica, y sin una fuerte organización que me permita ver el resultado de mi esfuerzo, ni las horas que voy a invertir, ni si merece la pena hacerlo de una cierta forma u otra.

Como programador, disfruto de la programación sin orden, anárquica, programo lo que quiero, como quiero y todo el tiempo que quiero. Me encuentro con los problemas típicos de haber abordado un problema del modo equivocado, y tener que reescribir una y otra vez el mismo código para alcanzar una forma óptima de lograrlo… pero no es óptimo y muchas veces aburre, ¿cuál es el siguiente paso?

Desarrollar es tener una idea en mente, darle forma hasta conseguir una idea completa y organizada, o al menos creíble, de un producto software conseguible mediante algún camino que se pueda tomar. Es decir, que si programo el código de una cierta forma, conseguiré lo que me propongo, ya que, mediante un diseño previo, he podido analizar las posibilidades de que no me ocurra el encontrarme ante un callejón sin salida.

Pero no es solo saber de antemano donde nos metemos al comenzar a programar, sino también, poder distribuir el trabajo en un equipo de desarrollo, un equipo de programadores. El análisis del problema nos permite ver qué hay que desarrollar exactamente, detecta las necesidades para que, después, el diseño nos diga el cómo podemos abarcar el problema para su resolución. Y ese cómo incluye la división del trabajo.

Como desarrollador, y viendo la programación como una parte del conjunto de hacer un proyecto de software, he podido aprender que, para poder realizar de forma más óptima un proyecto, hay dos caminos:

  • predictivo / por procesos: cuando se ha desarrollado ya bastante software del mismo tipo, es fácil poder estimar y cerrar requisitos, es fácil tener una especificación del problema a resolver, realizar el análisis, el diseño y la programación del mismo. Es fácil predecir cuánto tiempo se puede tardar en cada fase y realizarlo sin problemas. En este sentido, es bastante fácil tomar un modelo de procesos como el CMMI, SPICE o Metrica-3, y seguirlo para conseguir nuestro objetivo, consiguiendo además, la máxima documentación útil sobre el proyecto.
  • ágil / por iteraciones: si el proyecto que se quiere conseguir es sobre una tecnología que no se domina, plataforma nueva, o requisitos cambiantes, lo mejor es emplear una metodología ágil, que nos permita agregar flexibilidad para el cambio de requisitos, mediante entregas cortas, periódicas y agregando valor cada vez al proyecto a desarrollar, mediante la continua liberación de versiones. Las metodologías más usadas son Scrum, XP, Lean, FDD, DSDM, Crystal, Kanban, …

En conclusión, el siguiente paso ha sido convertirme en desarrollador. Conocedor de las metodologías predictivas y ágiles y poder dar a cada proyecto la orientación necesaria para poder llevarlo a cabo de la mejor forma posible.

El Principio de Peter

Hace tiempo ya escribí algo relacionado con esto, en el artículo despide a tu jefe. Hoy, después de haber leído la definición del principio de Peter en la wikipedia, se le puede dar más forma, precisión y color :-P

El caso es que en la mayoría de empresas, lo normal, es promocionar, es decir que, siendo bueno en lo que se hace, se sube de puesto por méritos y se toma mayor responsabilidad, mayor sueldo… pero también, algo poco evaluado, es que se cambia de trabajo.

El principio de Peter viene a decir que cada persona es ascendida hasta su nivel de incompetencia.

Esto quiere decir que, si somos buenos haciendo lo que hacemos, al ascender, haciendo otra cosa distinta, podemos no ser tan buenos, e incluso podríamos ser un desastre haciendo ese trabajo. Ahí es donde se centra el principio de Peter, ya que, siendo ya no tan buenos en el nuevo trabajo, es más difícil ascender.

Esto no es así en el 100% de los casos. Hay gente que cuando sube de puesto se recicla y comienza a hacerse valer en el nuevo puesto… pero son los menos.

La pregunta que debemos de hacernos cada uno, entonces, es… ¿has llegado a tu nivel de incompetencia o te sigues reciclando?

¿Cómo funciona el sistema de correo?

Esta es una pregunta que no todo el mundo se formula y, realmente, no es tan simple contestar. Quizás de todos los servicios de Internet, el sistema de correo es uno de los más complicados que existe (si no tenemos en consideración la VoIP, claro :-P ).

Conceptos

En principio, vamos a definir algunos términos que usaremos de forma natural en el resto del artículo, para adentrar lo que son los términos de funcionamiento del email:

  • MUA: (Mail User Agent, Agente de Usuario de Correo), es el sistema que se encarga de recibir y enviar emails usando los protocolos STMP (para el envío) y POP3 o IMAP (para la recepción). Ejemplos de MUA son evolution, kmail, sylpheed o incluso squirrelmail (los webmails).
  • MTA: (Mail Transfer Agent, Agente de Transferencia de Correo), es el sistema que se encarga de tomar el email de un MUA o de otro MTA y entregarlo a otro MTA o a un MDA, en caso de que el email pertenezca al dominio propio del MTA. Ejemplos de MTA son postfix, qmail, exim, cyrus y courier.
  • MDA: (Mail Delivery Agent, Agente de Entrega de Correo), es el sistema que se encarga de la recpeción del email por parte de un MTA, y lo almacena de la forma que tenga configurada. Los MDA pueden almacenar en disco, base de datos o llamar a otro programa para hacer el procesado de emails (p.ej: listas de correo, sistemas de control de incidencias, etc.). Ejemplos de MDA son procmail, maildrop… cyrus y courier implementan también sus propios MDA.
  • MAA: (Mail Access Agent, Agente de Acceso de Correo), es el sistema que se encarga del acceso al correo almacenado. Sería como la oficina de correos, y por ello su protocolo más usado es POP3 (Post-Office Protocol version 3). Se encarga de hacer accesible lo buzones a equipos remotos. Ejemplos de MAA son dovecot, uw, qpopper… cyrus y courier implementan también sus propios MAA.

Funcionamiento

Un ejemplo básico, desde el punto de vista de un usuario sería:

  • Un usuario abre su MUA (evolution, por ejemplo), escribe un email desde su buzón yo@miemail.com a un amigo, que tiene la dirección de correo el@suemail.com.
  • Su programa MUA se conecta con el MTA que está en el dominio miemail.com, este MTA comprueba que el remitente es suyo, pero que el destinatario es de otro dominio, por lo que realiza un relay del email al MTA del dominio suemail.com.
  • El MTA del dominio suemail.com ve que el destinatario es propio, por lo que, libera el email a su MDA.
  • El MDA comprueba el usuario a través de los alias y las reglas configuradas en el equipo y libera el email en el soporte, buzón y carpeta que tiene configurados.
  • El usuario el se conecta a un webmail, que hace de MUA para leer sus emails.
  • Los MUA, para leer emails, ya sean aplicaciones en el equipo o webmails, se conectan a MAA para leer los emails vía POP3 o IMAP, y estos MAA acceden a los datos que han liberado los MDA, por lo que el puede leer el email de yo.

Como dato a tener en cuenta, podemos ver las cabeceras del mensaje completas y aparecerán unas cabeceras redundantes que tienen por nombre Received. Estas cabeceras se agregan a cada paso por un MUA, MTA y MDA.

Spam

Por la forma de funcionamiento del protocolo SMTP (MTA), los antiguos programas que solo comprobaban el remitente y el destinatario, se veían en el problema de que esos datos se pueden falsear sin problemas, con lo que la veracidad de los mismos queda entredicho.

Para solventar estos problemas, se han desarrollado varios sistemas, antispam y de seguridad de conexión, que aseguran, en la medida de lo posible, que estos problemas no sucedan, pero aún así, hay una guerra entre desarrolladores de sistemas de correo para realizar sistemas cada vez más seguros, y spammers para el desarrollo de sistemas que salten esta seguridad.

Por ello, el uso de filtros es cada vez más común en los MTA, MDA e incluso los MUA.

CASE: escribiendo código más fácilmente

Las herramientas CASE (Computer Aided Software Engineering, Ingeniería del Software Asistida por Ordenador), son herramientas diseñadas para dar soporte al programador a través de una interfaz intuitiva y gráfica que le permita, mediante el posicionamiento de objetos gráficos concretos, relacionados entre sí siguiendo una nomenclatura específica, desarrollar la base de un programa automáticamente.

La programación siempre ha estado respaldada por el diseño de gráficos que, de un solo vistazo, den una imagen gráfica de lo que hace un programa, como se estructuran los datos que maneja, o cómo se organiza el código que se está escribiendo. Esto se hace mediante diagramas como los de flujo de datos, organigramas, entidad/relación, jackson, OMT y UML, entre otros.

Actualmente, no hay proyecto de grandes dimensiones que no se desarrolle usando metodologías que no estén respaldadas por diagramas como los de UML. La mayoría de proyectos que se subcontratan actualmente, por consultoras, se desarrollan, principalmente, en Java.

Esto es debido a varios factores, el principal, es que los sistemas heterogéneos a los que se enfrentan los consultores, les hacen decantarse por entornos multiplataforma, como Java, para facilitar su tarea, otro motivo es que Java ha crecido de forma considerable y tiene multitud de herramientas para el desarrollo de aplicaciones de negocio.

A día de hoy, por tanto, la mayoría de herramientas CASE se basan en el uso de diagramas UML que permitan especificar una organización del código, un comportamiento, con definición de casos de uso y secuencias, para después autogenerar la estructura o esqueleto base y escribir el resto del código, dentro de los métodos que quedasen vacíos después de la autogeneración.

Las herramientas CASE más usadas en el entorno laboral y las que hay disponibles de forma libre (algunas no gratuitas) son las siguientes:

  • Visual Paradigm: esta empresa cubre con su oferta de herramientas la generación de casi todo el código y asistentes para el mantenimiento del mismo código una vez acabado, para seguir completándolo, corrigiéndolo y adaptándolo a las nuevas necesidades del cliente. Es una solución no libre y de pago, pero muy completa y aconsejable.
  • ArgoUML: de las herramientas libres que he probado, esta es una de las más completas. El desarrollo a nivel individual es muy potente y permite desarrollar de forma muy rápida una gran cantidad de diagramas UML que después se pueden autoconvertir a Java, C#, C++, Base de Datos…
  • Innovator: este software incluye características para diseño y desarrollo de software de lógica de negocio, basado en SOA y BPM. Es de pago, pero cuenta con una gran cantidad de características.
  • Umbrello: este proyecto, lo usé durante un tiempo, antes de decantarme por ArgoUML y, solo decir que, aunque es libre y tiene bastante buena pinta, el hecho de que haya quedado descontinuado (no se ha liberado ninguna nueva versión desde finales de 2007), tenía bastantes fallos.

Oracle y Sybase también tienen sus entornos para desarrollo rápido de aplicaciones, solo que son de pago y no es fácil acceder a una copia para probarlos, por lo que no los comento en la lista anterior.

Para más información puede ver la página de la wikipedia sobre CASE, la cual completa con algunos conceptos más, y mucho más software.

La liebre y la tortuga

En este cuento voy a intentar explicar lo que significa programar rápido y lo que significa programar de forma ágil. La primera forma sería la que se considera comenzar lo antes posible, para terminar lo antes posible… pero ciertamente, sin planificación, dar palos de ciego a ciertos niveles de implementación, es más lento que planificar la estrategia de desarrollo a priori. Vamos a verlo con el cuento de…

La liebre y la tortuga

En Silicon Valley, había un programador tan rápido que podía escribir cientos y miles de líneas de código en cuestión de pocas horas, trabajaba rápidamente y, por ello, era conocido como la liebre. Aunque era un poco alocado, se lanzaba directamente a programar y no planificaba bien los proyectos.

No obstante, todos lo admiraban por lo rápido que hacía aparecer código en tan poco tiempo.

Por otro lado, estaba otro programador, algo más lento, que planificaba en papel y lentamente todos sus desarrollos, con lo que en un día obtenía muy pocas líneas de código. Este programador era conocido, por esto mismo, como la tortuga.

La liebre y la tortuga trabajaban en la misma empresa y, ante la fuerza que la admiración del resto ejercía sobre el primero, por su característica totalmente opuesta a la del segundo, la liebre instigaba e intentaba siempre perjudicar a la tortuga.

En la sala de trabajo, un día, cuando la tortuga ya se cansó de tanta hostilidad, aprovechó la oferta de un trabajo de programación importante, con un nivel de desarrollo importante y grande, para retar a la liebre: tú que eres tan rápido, te desafío a desarrollar este programa más rápido que yo.

Toda la sala quedó estupefacta, salvo el director de proyectos, que disimuladamente sonrió, agregando: sería interesante verlo. A lo que el resto de la sala agregó más risas.

El director de proyecto se dirigió a la liebre y le preguntó: ¿serías capaz de desarrollar este proyecto en menos tiempo que la tortuga? A lo que la liebre respondió sin dudar: ¡claro que sí! Pues os doy a ambos una semana para el desarrollo del proyecto, quien antes lo termine cumpliendo con los requisitos especificados, será el ganador.

La liebre comenzó a reir, aceptó el trato, al igual que la tortuga y fue a seguir riendo con sus compañeros durante largo rato mientras la tortuga marchó a su puesto de trabajo. La tortuga analizó el proyecto e inmediatamente localizó una serie de patrones claros que seguir, tomó los requisitos y trazó los diagramas que le harían cumplir con los mismos de la mejor forma, para seguir con una planificación ajustada al tiempo que tenía para cumplir con el proyecto. Se puso manos a la obra y comenzó el diseño.

Mientras tanto la liebre, se tomaba su tiempo y, mientras hablaba con sus compañeros decía: si ya sé cómo lo voy a hacer, es una chorrada de proyecto, ¡muy fácil!

En el segundo día, la tortuga terminaba su diseño con diagramas de UML, marcaba la división y los patrones que integrarían cada una de las clases, así cómo los detalles del diseño de interfaz y otras características a tener en cuenta en diagramas de secuencia.

Al tercer día, la liebre comenzó a codificar, en poco tiempo, tenía un trozo de código que cumplía los primeros requisitos y reía a gusto creyendo saber que conseguiría su propósito. Mientras, la tortuga, acababa de sentar el esquema de clases y la estructura básica, la arquitectura de soporte y preparaba todo para comenzar la codificación al día siguiente.

En el cuarto día, la liebre comenzó a encontrarse los primeros problemas, algunos requisitos chocaban directamente con muchas de las partes ya desarrolladas y en funcionamiento, así como datos ya implementados en la base de datos, con lo que se veía obligada a rehacer la estructura de datos, eliminar todo el código que no le servía y volver a escribir código nuevo. La tortuga comenzaba la codificación con la estructura de clases autogenerada por las herramientas CASE que usaba y trazaba las líneas de código de acceso a datos y lógica de negocio, escribía las pruebas unitarias para asegurar que todo salía bien y seguía adelante.

El quinto día, para la liebre, comenzaba el stress, la desesperación, se acerca el final del proyecto, aún no están todos los requisitos y se han vuelto a encontrar problemas. Como no hay una visión global, no sabe cuantos problemas más puede llegar a encontrar y, para los ya encontrados, la recodificación es algo pesada. Con lo que parece que solo lleva, de forma constante la mitad del proyecto. Por otro lado, la tortuga ha terminado la parte de lógica de negocio y manejo de datos, así como la parte de seguridad y acceso, el controlador, con lo que solo le restan las vistas, con las pruebas funcionales para acabar el proyecto.

El sexto día, cuando se había previsto la entrega del proyecto, la liebre había pasado toda la noche en su puesto de trabajo, intentando, con chapuzas, terminar a tiempo el proyecto, haciéndolo de forma muy deficiente y sin probarlo. Sin embargo, la tortuga, ya acababa la vista, haciendo siempre la ejecución de las pruebas de regresión para probar la integración de cada una de las partes, junto con las funcionalidades pedidas y el entorno en sí.

A la entrega del proyecto, la liebre presentó un proyecto con fallos, que no terminaba de funcionar y que tenía implementados los requisitos solicitados de forma dudosa, mientras que la tortuga entregaba un proyecto bien pensado, con un resultado limpio y funcional.

Ante los resultados, el director de proyectos se dirigió a la liebre y le dijo: no es cierto que es más rápido quien más rápido programa, sino quien, con menos código y menos trabajo, consigue hacer lo mismo en menos tiempo; y con ello, la tortuga ha demostrado, que es más rápido que la liebre.

Conclusión: usar metodologías ágiles acelera realmente el desarrollo, porque optimiza el proceso de creación.