¿Donde documentar mi proyecto de software?

Formas de documentarA lo largo de los años hemos intentado tener una documentación en cada proyecto que pueda servir a cualquier miembro del equipo en el momento que lo necesite.

Respecto a la cantidad de documentación, cada proyecto es un mundo pero en general siempre tenemos bastante información que tiene una relación directa con el proyecto.

Hemos probado técnicas, ubicaciones, wikis, documentos y otros sistemas, cada uno con distinto éxito.

A lo largo de los diferentes proyectos hemos comprobado  que cuanto más cerca estaba la documentación del código más ventajas teníamos y la información era más valiosa.

Entendemos por cerca, que la documentación este dentro de los mismos ficheros de código, en los mismos directorios o en el mismo repositorio de código.

Estas son algunas de las ventajas que existe cuando la documentación del proyecto esta cerca de los recursos :

-Más fácil tenerla actualizada

Al estar cerca del código es más sencillo actualizarla cuando realizamos un cambio.

-Más fácil tenerla localizada

No hay que preguntar a nadie donde esta el esquema de conexión el gŕafico de recursos o como acceder al wiki para ver tal objeto. Todo el equipo sabe donde está y donde debe estar.

-Organizada en base al proyecto

Los proyectos suelen tener una organización en base a módulos, componentes, áreas, etc. La documentación puede estar organizada de la misma manera, con lo que si te sabes mover por el código sabes moverte por la documentación

-La documentación y el código se apoyan, es bueno verlo con relación

Cuando tienes dudas en el código del proyecto necesitas ver la documentación que pueda estar relacionada. Cuando quieres ver como se aplica algo de la documentación, es bueno tener el código cerca.

-Si viaja el código que viaje la documentación

En ocasiones necesitas llevarte el código a una máquina sin conexión o cambiar de máquina. Si el código va junto a la documentación no tendrás que hacer dos pasos.

-Si tengo acceso al código tengo acceso a la documentación.

Si tienes unos privilegios de acceso al código, normalmente van parejos para el acceso a la documentación

Uno de los ejemplos prácticos de llevar la documentación cerca del código es la documentación de Qt, donde los ex-nokia y ex-trolltech documentaban en el código, su inmensa librería esta perfectamente documentada y actualizada.

Si tu documentación esta dentro del código existen herramientas que te ayudan a extraer esa documentación y compactarla de una forma muy accesible. Doxygen o JavaDoc son claros ejemplos.

En otros casos los IDEs de las plataformas te permiten crear directamente la documentación, en el caso de Velneo puedes crear esquemas directamente desde el vDevelop.

Revisión por pares

Como bien comenta jgarzas, en su post Beneficios del pair programming, que dos desarrolladores compartan el editor y hagan el desarrollo de forma conjunta puede aportar un plus de calidad a nuestro proyecto.

Del mismo modo, la puesta en marcha es complicada, por la sensación de pérdida de productividad.

Hace tiempo pusimos en práctica la revisión por pares, consiste en definir unos pares de desarrolladores donde cada uno verá el trabajo realizado por su compañero el día anterior.

Un script nocturno en la herramienta de integración continua captura del control de cambios el resumen de las modificaciones realizadas el día anterior por su compañero. Con la información se compone un email y se envía a cada par correspondiente.

El desarrollador lo primero que hace en el día es ver y entender lo que ha realizado su compañero, ante cualquier duda respecto al código, al formato o los comentarios, el desarrollador le consulta a su par e inician un diálogo para aclarar dudas.

Con la revisión por pares conseguimos una serie de beneficios:

  • Aprendizaje de trucos y el buen hacer de los compañeros
  • Amplio conocimiento de todo el proyecto
  • Solución a problemas de estilo de código
  • Solución a problemas de código detectado por un compañero
  • Unificación de criterios en la forma de desarrollar

No es tan eficaz como la programación por pares, pero ayuda al trabajo en equipo.

Es llevar a la práctica la ley de Linus en un equipo de desarrollo de una forma que no invertimos mucho tiempo en la revisión.

Cambios de una versión como detalle de calidad de un producto software

El momento de liberación de una versión es un momento clave, el resultado de largas semanas o meses de trabajo se muestran a los interesados. Junto nuestro producto (Exe, web, etc) hay muchos otros entregables que forman parte del producto completo que percibe el usuario final en cada ciclo de desarrollo.

Un elemento importante y donde se puede detectar si el equipo ha tenido un mínimo de calidad es que exista un log de cambios.

El log de cambios se puede presentar en muchos formatos:

  • Fichero txt, html
  • Post en un blog
  • Página web
  • Vídeo

La información que incluye el log de cambios ayuda al usuario a conocer de primera mano los cambios que va a sufrir cuando use la nueva versión. Generalmente las personas somos reacias a los cambios, con lo que informar adecuadamente puede ser importante para que nadie se lleve sorpresas.

Cuando se ve un log de cambios se puede entrever

  • Si el equipo de desarrollo ha usado una herramienta de seguimiento de incidencias
  • Si se informa de todos los cambios o solo de algunos
  • El tipo de perfil de usuario al que va destinado (muy friki o más comercial)
  • Enlaces a la historia sobre el desarrollo de la funcionalidad o la resolución de la incidencia
  • Si la versión se ha centrado en bugs o tiene muchas nuevas funcionalidades

Cada equipo de desarrollo tiene su log de cambios, los hay de todos los tipos y colores, os pongo unos enlaces a unos cuantos para poder ver la variedad :

Ejemplos de tipos de Changelist (totales) conocidos:
http://qt.nokia.com/products/changes/changes-4.7.2
http://www.mozilla.org/en-US/firefox/7.0/releasenotes/buglist.html
https://www.virtualbox.org/wiki/Changelog
http://support.microsoft.com/kb/2460049 (Service Pack de Office 2010)

Ejemplos de listado de novedades, más comerciales :
http://doc.qt.nokia.com/4.7-snapshot/qt4-7-intro.html
http://velneo.es/listado-de-novedades-velneo-v7-7-10/
http://www.mozilla.org/en-US/firefox/7.0/releasenotes/
http://www.vmware.com/support/ws71/doc/releasenotes_ws712.html

¿Cuantas hijas/versiones debo mantener?

En software es fácil tener muchas versiones de un mismo producto, las peticiones del cliente y el reducido coste de actualizar nos hace que podamos tener fácilmente varias versiones en producción de un mismo producto.

Crear, mantener y gestionar estas versiones puede ser tan laborioso como tener descendencia.

Una versión funcionando en un cliente es como una hija:

  • Has tenido que parirla y eso cuesta
  • Has tenido que darle un buen trabajo (Instalándola en los clientes)
  • Si tiene algún problema te llamará y tu eres el responsable de ayudarla
  • A una hija/versión no puedes abandonarla
  • Cuantas más hijas/versiones distintas tengas en producción más difícil será «mantenerlas todas»
  • Cuantas más versiones, más te costara «identificarlas». Ponles nombres
  • En reyes (cambio legal en la aplicación), tendrás que hacerle un regalo a todas 😉
  • Cuantas más hijas/versiones, más posibilidades que te salga alguna rebelde

Ten pocas y buenas hijas/versiones, te darán menos guerra y entrareis todos en casa en Nochebuena.

Lo que el cliente no pide, pero exige

En desarrollo de software es habitual que los usuarios pidan más y más funcionalidades, si fuera por ellos una aplicación crecería en «sus» funcionalidades hasta el infinito.

Pero por otro lado el cliente asume que la aplicación será rápida, estable y segura, pero eso no se suele pedir, se asume que es así.

Muchos de los trabajos relacionados con la calidad de tu software, son trabajos ocultos para el usuario, pero que son igual o más importantes que añadir más funcionalidad.

Es labor de todo el equipo dedicarle tiempo a la calidad del producto, ya que llegado un momento nuestra deuda técnica es tan grande que empezamos a sufrir distintos problemas relacionados con la falta de calidad.

Todos estos trabajos relacionados con añadir más calidad a nuestro producto deben ir incluidos en cada una de nuestras iteraciones, no debe ser un trabajo puntual cuando las cosas vayan mal.

Guias de estilo en los equipos de desarrollo

Cuando desarrollamos un producto o proyecto en equipo es interesante que existan unos criterios mínimos comunes entre todos para que nuestro código y proyectos sean lo más homogéneos posibles. Con ello conseguimos importantes beneficios

  • Mantenibilidad del proyecto
  • Evitar código spaguetti
  • Optimización de recursos evitando repetir el mismo trabajo
  • Mejor lectura del trabajo por parte de todos
  • Evitar conflictos entre los desarrolladores

El hito más importante es conseguir que ningún desarrollador reconozca su trabajo entre el de sus compañeros en base al estilo personal de cada uno.

Cada persona tiene su «guía de estilo» personal que va cambiando a lo largo del tiempo y la experiencia. Debemos conseguir tener una «guía de estilo» común para el equipo y que vaya mejorando a lo largo del tiempo.

Guía de Python
Google C++ Style Guide
Guía de Velneo vDiseño

¿Cuál es tu ciclo de desarrollo? (release cycle)

Escaleras que nos ayudan a subirLa salida de una versión de un producto de software suele ser el punto final de un gran trabajo, pero el principio para muchos otros. Por este motivo, es importante tener claro y transmitir al equipo interno y los usuarios como es nuestro ciclo de desarrollo. De esta manera nadie tendrá falsas expectativas respecto al qué y el cuándo.

Nuestro ciclo de desarrollo debe aclarar al menos :

  1. Duración del ciclo de desarrollo completo.
  2. Numeración de las versiones a publicar.
  3. Tipos de versiones que aparecerán en cada ciclo (Beta, RC, Final, Parche, etc.)
  4. Condiciones que se darán para la salida de cada tipo de versión.
  5. Entregables que tendremos en cada tipo de versión.
  6. Definir cuando esa versión no tendrá más mantenimiento o soporte.

1. Duración del ciclo de desarrollo

Totalmente relacionado con las iteraciones que hagas en tu compañía. El tiempo depende de cada producto o empresa, pero es importante tenerlo definido y no cambiarlo para no confundir a ninguno de tus stakeholders

2. Numeración de las versiones

Durante la vida de una aplicación existirán muchas versiones y es importante que todos sepamos identificarlas para conocer que cambios tiene respecto al resto de versiones.

3. Que aparecerá en cada ciclo

En cada ciclo de desarrollo, generalmente, aparecerán distintos tipos de versiones:

  • Una versión beta para probar las novedades y poder distribuir entre usuarios más expertos.
  • Una versión release candidate con la supuesta versión final (Antes de los últimos detalles)
  • Una versión final que se distribuirá entre todos los usuarios.
  • Unos posibles parches que arreglarán problemas una vez publicada la versión final.

No todos los productos funcionan igual ni necesitan todos estos tipos de versión.

4. Condiciones que se darán para la salida de cada tipo de versión

Esto hace referencia especialmente a los «parches», debemos definir cuando y como saldrán los parches. No todos los cambios de nuestro software tienen porque generar un parche, en general solo los errores graves o que rompen una funcionalidad anterior deben convertirse en un parche. Publicar un parche tiene un coste operativo alto, en muchos casos con incluir ese cambio en el siguiente ciclo de desarrollo es suficiente.

5. Entregables que tendremos en cada tipo de versión

Cada tipo de versión es un mundo, en algún caso el entregable es un .zip o una url (beta), en otro son una url, instalable, pdf, documentación, vídeo, post, traducciones, etc.
Hacer un checklist de lo que incluye cada tipo de versión ayuda a preparar todo lo que liberaremos en cada parte del ciclo de desarrollo.

6. Definir cuando una versión no tendrá más mantenimiento o soporte.

Todas las versiones tienen un tiempo de vida, no podemos permitirnos dar soporte y mantenimiento a todas las versiones que han aparecido durante toda vida de una forma indefinida. Este tiempo pueden ser años y todos los stakeholders deben conocer este tiempo para saber cuando tienen para actualizarse a nuevas versiones.

Enlaces a información de ciclos de desarrollo de distintas aplicaciones :

Release Cycle de Confluence
Mcafee release cycle
Ciclo de desarrollo de Velneo
Blender Relase Cycle
Release Cycle de Fedora

Jenkins como herramienta de integración continua y mucho más

Desde hace bastante tiempo venimos usando Jenkins como herramienta de integración continua.

Aunque esta orientada a desarrolladores de Java, gracias a su inmensa cantidad de plugins, puede servirte para cualquier lenguaje de programación o plataforma ( Nosotros lo usamos con C++ y Velneo )

La idea general de la integración continua es que tu producto este permanentemente pasando todos los pasos necesarios para su liberación.

Tu herramienta de integración continua es la encargada de dirigir todos los pasos intermedios desde que un desarrollador toca algo de código hasta que el instalable está disponible para descarga. Entre las tareas que debe hacer :

  • Conexión con el control de cambios (Perforce, GIT, etc )
  • Realizar los test de que todo el proyecto es coherente
  • Realizar los test necesarios de que tu proyecto no tiene errores
  • Realizar la compilación/compactación de todos los componentes
  • Probar que las diferentes partes de tu proyecto son compatibles
  • Tests para comprobar la calidad de tu proyecto (Tamaño imágenes, calidad de código, código duplicado, errores ortográficos, etc.)
  • Creación de instalables
  • Pruebas del instalable
  • Pruebas multiplataforma
  • Subida de los instalable a su repositorio final

Jenkins te permite crear trabajos (jobs) donde se detallan todas estas operaciones mediante scritps en el lenguaje que prefieras (Python, Batch, Bash, etc.)

Otras ventajas de Jenkins:

  • Multiplataforma
  • Configuración Maestro/Esclavo (Para integraciones distribuidas)
  • Cientos de plugins
  • Fácil instalación y mantenimiento
  • Multitud de idiomas ( Español incluido )

Si usas Jenkins en tu proyecto tendrás resueltos 2 de los 12 pasos hacia un código mejor de Joel Spolsky