Que le pido a un control de versiones: Administración amigable

Cuando tienes que administrar un repositorio de código una de las características más importantes es el disponer de herramientas que faciliten esa administración.

Es bastante más cómodo el disponer de herramientas con interface gráfico que el tener que recurrir a «conjuros» en una línea de comandos.

Hoy día casi todos los repositorios de código tienen algún tipo de interface administrativa de tipo gráfico.

En este aspecto destaca bastante el Git, ya que aunque de por si no dispone de administración gráfica, existen multitud de herramientas que lo complementen y hacen de el una muy interesante opción.

También es cierto que si tienes que administrar muchos repositorios el disponer de una línea de comando que te permita generar scripts, es un requisito a tener muy en cuenta. Pero para cargas relativamente bajas no lo es tanto.

Integración discontinua

Ya en la carrera, y de esto hace algún tiempo, de hecho soy de la última promoción de licenciados en informática, cuando no estaba tan en boga términos como integración continua, ya nos decían que cuanto más tarde se encuentren los fallos más caro cuesta arreglarlo. Es lo que también se conoce como deuda técnica.

Ha llovido bastante desde entonces y hoy día tenemos herramientas y técnicas para poder abordar la detección de los problemas de forma temprana. Pero muchas veces seguimos con la mentalidad de que hay que llegar a las fechas a toda costa. Y ese a toda costa suele ser dejar cadáveres por el camino. Cadáveres que como andamos con prisas no enterramos bien y más pronto que tarde se levantan de sus tumbas para exigirnos cuentas.

Creo que uno de los elementos que hacen más por estos temas de bajar la deuda técnica es la rigurosidad de nuestro cliente. Si el cliente es riguroso en sus controles de calidad, sabes que los cadáveres que dejes van a resucitar, así que procuras no dejarlos. Si el cliente no es exigente, es cuando más cadáveres suele haber, porque como nadie mira… hasta que algo peta y miran, claro.

Hoy día es relativamente sencillo el disponer de una herramienta como Jenkins o similares para realizar la integración continua. Esto nos ayuda a asegurarnos que lo que tenemos en el repositorio cumple con los criterios de calidad y si no lo hacen detectarlo cuanto antes, para que se solucione de inmediato, y a ser posible por la persona que ha roto la integración.

He estado en proyectos relativamente grandes en los que prácticamente era imposible bajarse el código y que este compilase a la primera. Pero les costaba ver que poniendo una herramienta de integración continua podían reducir el tiempo que alguien desperdiciaba cuando se tenia que bajar el código para realizar un cambio. El problema es que esos tiempos nunca se computan en las herramientas de seguimiento como tiempos improductivos. ¿Cuanto tiempo nos pasamos esperando a la máquina? Es decir sin generar valor a nuestros clientes…

Me parece que como tope la integración debe ser diaria, y si es constante mucho mejor, sobre todo con herramientas como git que facilitan el realizar commits atómicos.

Auditoría de código en un proyecto ya empezado

Cuando tienes que asumir la industrialización del desarrollo de un software ya empezado, uno de los problemas a los que tienes que enfrentarte, es que hacer con la auditoría de código, que normalmente no se cumple.

Uno de los objetivos de la industrialización es bajar la deuda técnica y uno de los parámetros tiene que ver con el cumplimiento de la auditoría de código.

Es muy complicado el llegar a los objetivos de cumplimiento de una atacada, salvo que se pueda hacer una intervención ex-profeso, cosa que no suele suceder, primero, porque normalmente suele haber cosas más importantes en las que invertir los, normalmente escasos, recursos del proyecto.

Yo lo que suelo pedir es que por lo menos la deuda técnica se vaya reduciendo. Es decir, no espero que se pare todo para cumplir la auditoría, pero si que por donde se vaya pasando se vaya haciendo el esfuerzo de adecuar el código. Que los indicadores de cumplimiento vayan subiendo.

En el peor de los casos por lo menos podrás decir que el equipo está haciendo el esfuerzo de mejorar la calidad.

Decir lo que piensas o seguir a la manada

Suelo seguir a Andrés Pérez Ortega, me parece que tiene ideas interesantes, algunas un poco radicales, pero que te hacen replantearte tus ideas y mejorarlas u otras veces simplemente reafirmarte.

Así que estaba leyendo una entrada en su blog sobre el decir lo que piensas y me ha venido automáticamente a la mente una serie de situaciones que he vivido de seguidismo tecnológico.

Esto de la arquitectura de aplicaciones web va por modas. Por ejemplo con EJB, que era la solución a infinitos problemas. Yo he desarrollado algún proyecto con EJB, en las que no usábamos nada de lo que proporcionaba los EJB, eso si pagamos el sobrecoste en comunicaciones y en velocidad de desarrollo (eran tiempos en los que no existía el debug en remoto).

Tres cuartos de lo mismo con los servicios SOA o el JPA o etc…

No es que sean malas herramientas o especificaciones, el problema suele venir cuando se utilizan para cosas que no son.

Creo que es labor de un arquitecto el pensar muy bien que necesidades reales tiene el proyecto a corto y medio plazo. Hacer una lista y ver que herramientas o tecnologías son las necesarias. La arquitectura tiene mucho de pensar y buscar, buscar y pensar.

Aveces nos ofuscamos con pensar a muy largo plazo, que es una excusa perfecta para justificar grandes inversiones en tecnología, y no nos damos cuenta que lo más probable es que ese planteamiento suponga un gasto real a corto, pero un incierto rendimiento económico a largo plazo.

Como se comenta en la programación extrema lo más probable es que cuando llegues a necesitar esa flexibilidad, si es que la necesitas, probablemente hayas aprendido cosas y seas capaz de hacerlo de mejor forma que la que lo harías hoy.

Son pensamientos que van muy en la línea de mantener las cosas sencillas

Git a palo seco o edulcorado

Estoy usando, para una serie de proyectos personales, el Git como repositorio de código.

En uno de los proyectos estoy usando un git, por decirlo de alguna forma, a palo seco. Es decir sin ningún tipo de capa por encima, estilo GitHub, GitLab, Gitorious, etc. En el otro proyecto estoy usando GitHub, ya que es un proyecto público.

Como comenté el una entrada del proyecto MyCloudChest el motivo es que quiero que sea un repositorio privado y gratuito. Así que lo monté en mi RaspberryPi.

Para un proyecto personal es suficiente, ya que no tengo que gestionar muchos usuarios ni hay mucha concurrencia. Pero esta solución no es tan adecuada para un proyecto un poco más grande. Por lo menos comparado con las posibilidades que te proporcionan estos tipos de productos que complementan la funcionalidad de Git.

Estos productos, aparte de tener una administración mediante un web, que siempre es más agradable que la línea de comandos, proporcionan una serie de facilidades que me parecen muy interesantes.

Sobre todo la gestión de permisos en las ramas y la funcionalidad de merge o pull request. De tal forma que los programadores tienen que solicitar a un responsable que les acepte el cambio y lo incluya en la rama principal.

Que le pido a un control de versiones: Poca morralla

Es una de las cosas más molestas cuando tienes que pasar el código a otra persona fuera del repositorio es el tener que andar limpiando la cantidad de ficheritos o carpetas que incluye el repositorio para su gestión.

Así que una de las cosas que le pido a un sistema de control de versiones es que estos ficheros internos no estén dispersos por todas las carpetas.

En este aspecto, tanto el git como el Rational Team Concert son los mejores, ya que solo utilizan una carpeta en el raíz del proyecto.

Defender la jerarquia

Las empresas y los proyectos software no son sistemas democráticos, son más bien jerárquicos, más o menos rígidos. Es una estructura de delegación. Sobre todo en proyectos grandes y muy industrializados. Cada persona tiene una responsabilidad sobre la que se le va a exigir y sobre la que tiene autoridad. Cuantas más responsabilidades tienes, normalmente más necesidad tienes de delegar ciertas tareas o áreas en otras personas.

En esta entrada quiero hablar sobre la defensa de esa jerarquía. A veces te encuentras con problemas o divergencias con compañeros, vamos a poner por ejemplo un programador, que se quejan de, vamos a poner su analista (o superior o responsable o jefe o supervisor o …) y recurren a ti como, vamos a poner jefe de proyecto (o superior de su superior).

Puede ser que tu opinión concuerde con el criterio del analista, con lo que lo que haces es refrendarlo. Pero puede ser que no coincida.

Esta situación puede ser delicada ya que se puede entender como un cuestionamiento del criterio del analista.

El problema viene porque si socabas la autoridad o criterio de ese analista puedes encontrarte con que lo anulas, ya que el programador ve que el jefe de proyecto no respalda al analista, con lo que cada vez el programador se siente con más libertad para no seguir los criterios del analista, pensando que cuando se monte lío, recurrirán al jefe de proyecto y este le dará la razón.

Siempre que he me he encontrado en una situación de estas he procurado no socabar el criterio o autoridad, ya que eso se acabaría volviendo en mi contra. Pero tampoco refrendando al analista incondicionalmente.

He estado en alguna situación rocambolesca en la que he sido yo el que ha estado en medio, no siendo respaldado por mi jefe, y lo más curioso es el motivo, por un afán de mi jefe de ir de colega con los programadores… Menos mal que mi jefe a su vez tenia un jefe que puso un poco de cordura.

Hay que tener mucho tacto en este tipo de situaciones, en las que se pone en cuestión la jerarquía.

Decálogo X: Que lo vise el jefe

El décimo punto del decálogo de la industrialización del software con respecto a los traspasos a la infraestructura del cliente es que: «No se traspasa ningún proyecto sin que hay sido aprobado por el responsable del proyecto».

Este es el punto más burocrático y se refiere a que el traspaso, que básicamente es una entrega de un producto, o de una parte de un producto, debe ser autorizada por el responsable de ese proyecto.

Si algo va mal a el le van a pedir cuentas, así que lo normal es que quiera tener un cierto control sobre ese paso.

Decálogo IX: Calidad, Calidad y Calidad

El noveno punto del decálogo de la industrialización del software con respecto a los traspasos a la infraestructura del cliente es que: «No se traspasa nada sin que haya pasado los controles de calidad».

Si no pasas los controles de calidad es que no has terminado. Y si no has terminado ¿porque traspasas?

El cliente te va a parar el traspaso en algún entorno posterior a los tuyos y vas a tener que volver a hacer el trabajo. O lo peor de todo, si el cliente no tiene un buen control de calidad, te lo van a poner en producción, y luego va a haber fuegos artificiales y según Murfy en el peor momento cuando te pille a contra pie.

Decálogo VIII: Toda la información en la tarea

El octavo punto del decálogo de la industrialización del software con respecto a los traspasos a la infraestructura del cliente es que: «Cada tarea recogida en el gestor de tareas debe contener toda la información para realizar el traspaso».

Como hemos comentado en otros puntos no siempre una tarea se pone en producción nada más terminada, que es cuando tienes fresco lo que has hecho. También hay que tener en cuenta que si algo va mal en un traspaso cuanta más información tengas recogida de forma accesible más fácil va a ser recordar que es lo que si hizo y porque.

Es por ello que en el gestor de tareas en cada tarea hay que recoger la información necesaria para poder reconstruir la tarea.

He tenido compañeros muy diligentes que se apuntaban en la libretita todos los ficheros que iban cambiando y todo lo que iban haciendo. Me parece genial esa actitud, pero lo que les decía a esos compañeros es que si en vez de hacerlo en su libretita, que solo la conoce la persona, si lo haces, exactamente el mismo trabajo, en el gestor de tareas queda recogido para cualquiera que tenga que continuar esa tarea.

Estuve en un proyecto en el que en un periodo de tiempo muy corto tuvimos dos bajas médicas inesperadas de una cierta duración, que nos hizo un roto muy grande, ya que el equipo no era muy amplio, así que una baja de una persona suponía una perdida grande.

Si no llega a ser porque teníamos todo recogido en el gestor de tareas y otra persona pudo retomar el trabajo, ciertamente con dificultades, pero muchas menos de las que hubiese tenido si no lo hubiésemos tenido todo recogido.