Mostrando entradas con la etiqueta Calidad. Mostrar todas las entradas
Mostrando entradas con la etiqueta Calidad. Mostrar todas las entradas

jueves, 21 de marzo de 2013

Working Effectively With Legacy Code

Después de estudiar la forma de crear software de la mejor manera posible, usando Patrones de Diseño, evolucionando el diseño mediante TDD, cubriendo el código de pruebas y refactorizándolo cuando se presenta una oportunidad de mejora, me sigo topando con la cruda realidad. Ésta es que la mayor parte del tiempo lo paso trabajando con código ya hecho, por mí o por otras personas, y que no está desarrollado siguiendo las buenas prácticas que ahora intento seguir. Este código es difícil de entender y de mantener y, aunque quiero llevarlo a un estado parecido al código nuevo que desarrollo, esto me parece en ocasiones prácticamente imposible.

Una solución al problema de cómo mejorar este código legado es seguir los consejos que Michael C. Feathers presenta en su libro “Working Effectively With Legacy Code”. En él se presenta su visión sobre qué es el software legado, con que mentalidad enfrentarnos a él y qué técnicas podemos usar para combatir las malas prácticas que hay en él. Este artículo es un resumen de lo que este libro cuenta.

  1. Cambiando el software: El software se puede cambiar por varias razones: añadir funcionalidad, corregir un error, mejorar el diseño u optimizar el uso de los recursos del sistema. En todos los casos se quiere cambiar algún funcionamiento, pero se desea mantener la mayor parte del ya existente.
  2. Trabajando con realimentación: La forma de cambiar el sistema sin introducir errores es trabajar con la realimentación que proporcionan los tests unitarios que cubren el código. Estos tests permiten detectar cualquier comportamiento erróneo que se introduzca en las modificaciones que realicemos. El problema del código legado es que dichos tests no existen, y hay que hacer cambios para introducirlos rompiendo dependencias entre componentes, siendo extremadamente cuidadoso.
  3. Detección y separación: Existen dos motivos para romper las dependencias, detectar cómo afecta un componente a otro, o separar los componentes entre sí y poder ejecutarlos de forma independiente. De todas formas, los componentes deben colaborar entre sí y, para aliviar las dependencias en estas colaboraciones se pueden usar dobles de prueba que sustituyan al colaborador real.
  4. El modelo de costuras: El software no se puede tratar como un listado porque esto dificulta su comprensión y la reutilización de sus componentes. Para poder probarlo es necesario buscar formas de cambiar su comportamiento sin realizar ningún cambio sobre lo que se va a probar, puntos que el autor llama costuras. Estas costuras pueden ser habilitadas de distintas formas y, en función de ello, existen los siguientes tipos: de preprocesado, de enlazado y de objeto.
  5. Herramientas: A la hora de realizar cambios sobre el código legado hay una serie de herramientas que nos van a ayudar. Estas son las herramientas de refactorización automática, los frameworks de objetos “mock” (imitación), y los frameworks de prueba (xUnit, CppUnit, CppUnitLite, Fit, Fitnesse)
  6. No tengo mucho tiempo y tengo que cambiarlo: A veces no se dispone de tiempo para poner bajo tests la clase que tenemos que cambiar. En esos casos se pueden usar una serie de técnicas que, por lo menos, permiten tener bajo tests el código que introduzcamos al hacer los cambios. Estas técnicas consisten en crear una nueva clase o método, o crear una clase o método que envuelva el código existente.
  7. Hacer un cambio se eterniza: Cuando se están haciendo cambios es importante tener realimentación rápida sobre lo que está ocurriendo. Para ello es importante que los proyectos se puedan recompilar rápidamente de forma que no se invierta demasiado tiempo esperando. Para conseguir esta rapidez se deben usar interfaces y paquetes para separar las dependencias entre clases.
  8. Cómo añadir funcionalidad: Una vez que tenemos código bajo test podemos usar las técnicas descritas en este capítulo para añadir nueva funcionalidad de forma controlada. Estas técnicas son TDD y la programación por diferencia. La programación por diferencia, basada en la herencia de implementación, es bastante discutida, pero se puede utilizar de forma inicial a la hora de introducir nuevas funcionalidades y luego, gracias a los tests, ir mejorando el diseño de forma que se elimine su uso.
  9. No puedo incluir esta clase en un test: A veces no es fácil instanciar una clase en un test por distintos motivos. Estos pueden ser la dificultad de crear ciertos objetos debidos a los parámetros de su constructor o las dependencias de éste, que el test no se pueda ejecutar con una determinada clase que depende de una base de datos o parecido, que el constructor tenga efectos colaterales dañinos o que no seamos capaces de comprobar el trabajo que se hace en el constructor. Se presentan una serie de ejemplos donde se solucionan estos problemas a partir de unas útiles técnicas.
  10. No puedo ejecutar este método en un test: Una vez se puede instanciar una clase en un test sólo hemos empezado con lo que tenemos que hacer. Ahora hay que ejecutar alguno de sus métodos y a veces hay que superar problemas como que el método no sea accesible, que se necesiten parámetros difíciles de construir en su llamada, que tenga efectos colaterales perjudiciales o que no se pueda apreciar lo que hace en alguno de los objetos que utiliza. Se presentan una serie de ejemplos donde se solucionan estos problemas a partir de unas útiles técnicas.
  11. Necesito hacer un cambio. ¿Qué métodos debo probar?: Cada cambio en el software tiene una serie de efectos que es necesario considerar. Una técnica útil es hacer un boceto para ver de forma gráfica lo que se ve afectado por cada cambio. Un buen código creará estructuras simples. Es importante saber que los efectos se pueden propagar de tres formas: los valores de retorno de un método, los objetos pasados como parámetros a un método y las variables estáticas o globales. Se pueden simplificar estos bocetos mediante la eliminación de duplicación, y esto lleva a decisiones más sencillas sobre los tests a realizar.
  12. Necesito hacer muchos cambios en un área. ¿Tengo que romper las dependencias para todas las clases implicadas?: A veces es conveniente buscar un lugar donde probar vario cambios a la vez en lugar de poner bajo tests todas las clases implicadas en un cambio. Para ello, a través de los bocetos de efectos se pueden buscar puntos de intercepción, lugares donde se puede probar un determinado cambio. Algunos puntos, donde el boceto de efectos se estrecha, son especialmente indicados para probar varios cambios a la vez.
  13. Necesito hacer un cambio pero no se qué tests escribir: En código legado necesitamos tener tests que permitan preservar el comportamiento del sistema tras las modificaciones. Esos tests se llaman tests de caracterización, y son tests sencillos que simplemente reflejan lo que el sistema hace en este momento. A partir de estos tests se puede refactorizar el código para mejorarlo.
  14. Las dependencias en librerías me están matando: Es importante no confiar demasiado en una librería concreta y llenar el código de llamadas a métodos de esa librería. El uso de forma directa de una librería no favorece la creación de tests.
  15. Mi aplicación está llena de llamadas al API: La mayoría de los sistemas contienen una lógica principal que va más allá de llamadas a la API de una o más librerías. Es importante que el diseño preserve esta lógica para poder hacer buenos tests. A esta separación se puede llegar mediante dos aproximaciones: envolver el API o hacer una extracción basada en responsabilidades.
  16. No entiendo el código suficientemente bien para cambiarlo: Para entender el código existente de cara a hacer un cambio, se pueden usar algunas técnicas de bajo nivel, como tomar notas, hacer bocetos, marcar listados de código para resaltar los aspectos importantes del mismo, hacer una refactorización informal y luego deshacerlo o borrar el código que no se usa.
  17. Mi aplicación no tiene estructura:Las aplicaciones tienden al desorden cuando todo el equipo no es consciente de dicha arquitectura. Para asegurarse que el equipo entiende la arquitectura se puede recurrir a contar la historia del sistema para obtener una visión simple del sistema en su conjunto, usar CRC o “naked CRC” para comunicar el diseño de la aplicación o escrutar las conversaciones sobre el sistema para comprobar que cuando se hace un abstracción al hablar esta tenga una correspondencia en el sistema. Es importante resaltar que el diseño es una tarea que no termina mientras siga habiendo cambios.
  18. Mi código de test está en medio: Tener el código de test mezclado con el código puede no ser bueno por razones de claridad o de recursos. Para separarlo se pueden usar convenciones de nombrado o situar uno y otro en archivos separados.
  19. Mi proyecto no es orientado a objetos. ¿Cómo hago cambios seguros?: Principalmente se habla de lenguajes procedurales. Para estos lenguajes se pueden usar las costuras de procesado o de enlazado, pero si el lenguaje tiene una extensión que sea orientada a objetos, se puede hacer modificaciones que permitan usar las costuras de objeto, que son mucho más potentes.
  20. Esta clase es muy grande y no quiero que crezca más: Las clases grandes generan confusión, dificultad a la hora de planificar las tareas de los desarrolladores y son difíciles de probar. Estas clases tienden a atraer dentro de ellas las nuevas modificaciones y no paran de empeorar. La solución es refactorizar estas clases para hacer que cumplan con el Principio de Única Responsabilidad (SRP). Esta refactorización se debe hacer separando las responsabilidades de cada clase. Para ver estas responsabilidades se pueden agrupar sus métodos, buscar métodos ocultos, buscar las decisiones sobre la misma que puedan cambiar, buscar relaciones internas usando bocetos de propiedades para observar las agrupaciones internas, buscar la responsabilidad principal, hacer refactorizaciones de prueba o centrarse en la tarea que tenemos entre manos. La estrategia a seguir cuando se han identificado las distintas responsabilidades es separarlas a medida que sea necesario en vez de hacer todo a la vez. La mejor táctica para hacerlo sería aplicar el principio de responsabilidad única a nivel de implementación en vez de a nivel de interfaz.
  21. Estoy cambiando el mismo código por todos los sitios: Muchas veces hacemos un cambio y creemos que hemos terminado, pero nos damos cuenta de que debemos hacer este mismo cambio en otras partes del sistema donde el código está duplicado. A través de la refactorización podemos ahorrarnos esta molestia eliminando las duplicidades, consiguiendo además que emerja un mejor diseño y favoreciendo la ortogonalidad del sistema, consiguiendo partes del sistema independientes entre sí.
  22. Necesito cambiar un método monstruoso y no puedo escribir tests para él: Para abordar los cambios en estos métodos monstruosos podemos usar las herramientas de refactorización automáticas, evitando en este paso todo cambio adicional que no soporten. Cuando se refactoriza de forma manual debemos ser mucho más cuidadosos y, para ello, introducir variables que nos permitan sentir los cambios en el sistema, extraer sólo aquello que conocemos, separar el código principal de lo secundario o extraer un objeto método. Se pueden introducir cambios estructurales mientras se refactoriza haciendo que los métodos sean un esqueleto de la lógica que contienen, buscando secuencias de código, extrayendo a la clase actual en un primer paso en vez de llevar el código a otra clase y extrayendo en pequeñas piezas de código.
  23. ¿Cómo sé que no estoy rompiendo nada?: Se puede reducir el riego al editar los cambios si se es plenamente consciente de lo que se está editando, editando con un único objetivo, manteniendo las firmas de los métodos y apoyándose en el compilador para identificar los cambios que se deben hacer.
  24. Nos sentimos abrumados. Esto no va a mejorar: La programación puede ser divertida, aunque trabajar con código legado sea difícil. Rehacer el proyecto desde cero tampoco es una solución porque hay que mantener el mismo avance que el proyecto y esto es muy difícil. Hay que buscar la motivación para trabajar sobre nuestro sistema, solucionando los problemas más inmediatos y haciendo evidente la mejora que podo a poco se produce en el sistema.
  25. Técnicas para romper las dependencias: En este capítulo se definen técnicas para romper las dependencias, pero que no son exactamente refactorizaciones, puesto que están pensadas para hacerse sin tests, con el fin de poder introducir estos tests que nos faltan.

domingo, 4 de marzo de 2012

Los "malos olores" del código

En estos momentos estoy estudiando "Refactoring: Improving the Design of Existing Software" de Martin Fowler. Tenía ganas de leer este libro desde hace tiempo porque es una referencia continua en muchos de los libros que he leído últimamente y, la verdad es que está cumpliendo con las expectativas que tenía.

Este libro te enseña cómo puedes mejorar el diseño de tu código a través de la refactorización del mismo, es decir, cambial su diseño sin alterar la funcionalidad del programa. Esta actividad, durante la cual no aumenta la funcionalidad de un programa, puede ser vista como una "pérdida de tiempo" que simplemente pretenda dejar el código más bonito sin aportar realmente valor.

Sin embargo, mejorar el diseño del código puede hacer que la inclusión de nuevas funcionalidades en el futuro sea mucho más sencilla, directa y rápida. De esta forma, a largo plazo, el tiempo invertido en la refactorización habrá sido recuperado gracias al tiempo que se ahorrará en los nuevos desarrollos.

De todas formas, la refactorización no se debe hacer a lo loco, sino que debe hacerse en los momentos y en aquellas partes del código donde el valor de retorno del tiempo que se va a invertir se maximice.

En cuanto a los mejores momentos para refactorizar, esto son:
  • Cuando nos topemos por tercera vez con el mismo problema y debemos eliminar las duplicidades.
  • Cuando estamos añadiendo una nueva funcionalidad y necesitamos entender lo que hay hecho, refactorizar ayuda a entender dicho código.
  • Cuando estemos arreglando un error, la refactorización ayuda a clarificar el código y a encontrar la fuente del problema.
  • Mientras se hace una revisión de código, puesto que en este momento es donde se hace evidente si el código que ha escrito un desarrollador es claro para los demás.

También hay que tener en cuenta que hay momentos en los que la refactorización no ofrece más inconvenientes que ventajas:
  • Cuando en realidad lo necesario es reescribir el código porque éste no funciona como debiera.
  • Cuando estamos cerca de una fecha de entrega. La verdadera ganancia de la refactorización se hará evidente tras la entrega, lo que ya es demasiado tarde.

Por otra parte, determinar qué código necesita refactorizarse es más subjetivo. Martin Fowler presenta en su libro una serie de pistas, basadas en la idea de "malos olores" del código de Kent Beck. Estos "malos olores" son patrones que, por experiencia de Beck y Fowler, son evidencias habituales de problemas en el diseño.

A continuación resumiré estos "malos olores". Voy a intentar traducir los nombres que usan para ellos, pero dejaré también el original en inglés, porque así es más fácil encontrar referencias a los mismos:
  • Código duplicado (Duplicated Code): Si encontramos la misma estructura de código en varios sitios, lo mejor es unificarla en un único punto.
  • Método largo (Long Method): Los métodos pequeños son más claros en lo que hacen y permiten compartir el código y que se pueda elegir el método a llamar según el caso. La sobrecarga en la llamada a un método es casi despreciable, por lo que no debe ser excusa para usar métodos lo más pequeños posible.
  • Clase grande (Large Class): Una clase que hace demasiadas cosas suele tener muchas variables de instancia y, tras ellas, suele haber código duplicado. Si una clase no utiliza todas sus variables de instancia en todo momento, las que no se usen se deberían eliminar o extraer a otra clase.
  • Lista de parámetros larga (Long Parameter List): De forma distinta a lo que ocurría con tecnologías anteriores, cuando se usan objetos, no hace falta pasar a un método toda la información que necesita para su ejecución, sino sólo aquella que es imprescindible para que puede obtener todo lo que necesita.
  • Cambio divergente (Divergent Change): Cuando hay que hacer un cambio, debemos ser capaces de identificar un único punto en el programa donde éste deba hacerse. Si tenemos una clase donde debamos cambiar 3 métodos por una razón y otros 4 por otra causa distinta, tal vez este objeto debería ser dividido en 2 con distintas responsabilidades.
  • Cura de un escopetazo (Shotgun Surgery): Este caso es el contrario del anterior. Hay y que hacer un cambio y para ello deben modificarse varias clases desperdigadas por el código. Los métodos afectados deberían agruparse en una sola clase.
  • Envidia de capacidades (Feature Envy): Si un método de una clase hace referencia más a métodos y parámetros de otra clase, tal vez sea en esa otra clase donde debería estar.
  • Agrupaciones de datos (Data Clumps): Si un grupo de datos aparecen constantemente juntos y se usan siempre en los mismos momentos, estos datos deberían agruparse dentro de un objeto.
  • Obsesión por los tipos primitivos (Primitive Obsession): Existen ciertos datos que están mejor agrupados en pequeñas clases, en lugar de usar primitivas, aunque esto último parezca más sencillo. Usar clases para estos datos ofrece nuevas capacidades como añadir nueva funcionalidad o realizar comprobaciones de tipo de datos.
  • Sentencias switch (Switch Statements): A veces se encuentran las mismas sentencias switch repartidas por el código. Si se incluye un nuevo apartado clause se debe hacer para todas ellas y es fácil saltarse alguna. Normalmente esto es manejado mucho mejor a través de polimorfismo, cobre todo cuando la sentencia switch actúa en función de un valor que define el tipo de un objeto.
  • Jerarquías paralelas de herencia (Parallel Inheritance Hierarchies): Esto ocurre cuando al añadir una clase en una jerarquía se hace evidente la necesidad de añadir una nueva clase en otra jerarquía distinta. Si las instancias de una jerarquía hacen referencia a las de la otra se puede eliminar una de ellas llevando sus métodos a la otra.
  • "Clase vaga" (Lazy Class): Una clase que no hace nada está añadiendo una complejidad innecesaria y es mejor hacerla desaparecer.
  • Generalización especulativa (Speculative Generality): Cuando se añade funcionalidad especulando sobre lo que necesitaremos en el futuro, pero que en este momento es innecesario, el resultado es código más difícil de entender y mantener. Es mejor deshacerse de ello.
  • Campo temporal (Temporary Field): Si existen variables de instancia que parecen usarse sólo en algunos casos, puede ser confuso entender en cuáles. Es mejor sacar estas variables a otra clase.
  • Cadenas de mensajes (Message Chains): Estas cadenas aparecen cuando un cliente pide a otro objeto un objeto y a su vez llama a éste último para obtener otro objeto. De esta menra, el cliente se acopla a toda esta estructura de navegación y cualquier cambio en ella le afectará. Es mejor recuperar otros objetos mediante un delegado que encapsule dicha navegación y abstraiga al cliente de ella.
  • "Hombre en el medio" (Middle Man): El caso anterior no es necesario que se cumpla a rajatabla. A veces, si existen muchos métodos que delegan a una misma clase, es mejor quitarnos el delegado y referirnos a ella directamente.
  • Intimidad inapropiada (Inappropiate Intimacy): Cuando una clase se dedica a hurgar en partes de otra clase que parecen ser privadas, ha llegado el momento de desacoplar dichas clases, por ejemplo, a través de una tercera que contenga la funcionalidad común de las dos anteriores.
  • Clases alternativas con interfaces diferentes (Alternative Classes with Different Interfaces): Si tenemos dos métodos que hace los mismo pero se llaman de forma distinta, es mejor unificarlos para que se use siempre un único método.
  • Clase de librería incompleta (Incomplete Library Class): A veces una clase de una librería de tercero no hace todo lo que necesitamos y debemos adaptar su uso a nuestras necesidades ya que no podemos modificarla.
  • Clase de datos (Data Class): Las clases que solo tienen datos getters y setters son manipuladas en gran medida por otras clases. Podemos buscar este comportamiento para llevarlo a las clases que contienen los datos.
  • Legado rechazado (Refused Bequest): A veces una subclase no usa todos los métodos que hereda de su clase padre. Esto puede significar que la jerarquía no es correcta y los métodos de las clases se deben mover a donde se usan realmente.
  • Comentarios (Comments): A veces los comentarios lo que están enmascarando es uno de los "malos olores" que se han visto anteriormente. Es mejor invertir el tiempo en mejorar este código que en comentarlo.

Podemos buscar ocurrencias de estos patrones en nuestro código y seguro que encontramos unos cuantos. Luchando contra ellos usando las refactorizaciones que Fowler presenta en su libro, conseguiremos un código mucho más claro con el que trabajar.

miércoles, 5 de enero de 2011

Clean Code

Durante los últimos meses he estado leyendo y releyendo el libro “Clean Code: A Handbook of Agile Software Craftmanship” de Robert Martin. En este libro, el autor trata por qué hemos de escribir código limpio y cómo hacerlo.


Código Limpio. Este tema es algo que me interesa particularmente en estos momentos. Cuando eres un desarrollador con responsabilidades puntuales dentro de un proyecto y sin relevancia ninguna en cuanto a las decisiones que toma el arquitecto de turno, lo único importante es quitarte el muerto de encima cuanto antes para evitar las típicas preguntas de: ¿Cómo vamos (¿Vamos? Pero si lo estoy haciendo sólo yo…)? ¿En qué estado está esta tarea? ¿Qué pongo en el Project, 80%, 90%...? ¿Podemos hacer la entrega ya?

Sin embargo, cuando tienes cierto grado de responsabilidad sobre un proyecto y te interesa que su evolución no se complique es importante hacer entender a los miembros del equipo que la responsabilidad de cada uno va más allá de quitarse el muerto de encima, sino que cada uno debe hacer lo mejor que pueda por tener un código lo más comprensible posible. Al código comprensible es a lo que Robert Martin llama código limpio.

Este libro está dividido en tres partes:
  • En una primera parte, se explica qué es el código limpio y cómo llegar a él.
  • La segunda parte son ejemplos más complejos de refactorización de código en busca de código más limpio.
  • La tercera parte es una recopilación de pistas que ayudan a encontrar código que no está todo lo bien que debería estar y que debería ser refactorizado.

En este resumen del libro me voy a centrar en la primera parte de él, puesto que la segunda y la tercera parte son bastante directas.

Capítulo 1 - NOMBRES

La lectura del código es la actividad a la que se dedica más tiempo, incluso para escribir nuevo código hay que leer lo que ya hay escrito. Un mal código puede llegar a arruinar un proyecto, dificultando las modificaciones y alargando los plazos de entrega. El único responsable de ello es el programador que no se toma en serio su trabajo y no es profesional.

Para evitar estas situaciones se debe hacer un código limpio, pero, ¿qué es código limpio?. Según varios autores conocidos, las características del código limpio son:
  • Fácil de leer, expresivo y sencillo.
  • Probado mediante tests automáticos.
  • Hace una única cosa.
  • No existe duplicidad en él.
  • Utiliza el menor número de elementos posibles.
  • Realiza abstracciones de elementos similares.

Para conseguir un código limpio se debe prestar atención a cada uno de los elementos que componen un sistema a nivel de código: variables, funciones, clases, comentarios, tests y el propio sistema. Además existen una serie de aspectos, como son la diferenciación entre objetos y estructuras de datos, el comportamiento en los límites del sistema, el manejo de errores y la concurrencia que afectan directamente al código y a su comprensión. Capítulo a capítulo se va analizando cómo mejorar en cada uno de estos elementos

Tembién habla de la regla del Boy Scout “Hay que dejar el código mejor de cómo lo encontraste”. Esto va en la línea de la mejora continua del código y de la imposibilidad de hacerlo perfecto a la primera.

Capítulo 2 - NOMBRES

Un buen nombre da mucha más información que cualquier otra cosa. Para conseguir buenos nombres hay que usar nombres descriptivos y claros. Deben ser legibles y evitar codificaciones complejas.

Capítulo 3 - FUNCIONES

Una buena función es aquella de la que se puede inferir su comportamiento de un solo vistazo. Para ello deben ser cortas, hacer una única cosa y mantenerse dentro del mismo nivel de abstracción.

Es importante usar buenos nombres y reducir al mínimo el número de argumentos. Pero lo principal es eliminar toda la duplicidad.

Capítulo 4 - COMENTARIOS

Los comentarios no pueden maquillar el mal código. La necesidad de comentarios para aclarar algo es síntoma de que hay código mal escrito que debería ser rediseñado. Es preferible expresarse mediante el propio código.

Hay situaciones en las que los comentarios son apropiados, como cuando tratan de:
  • Aspectos legales del código.
  • Advertir de consecuencias.
  • Comentarios TODO.
  • Remarcar la importancia de algo.
  • Javadocs en APIs públicas.

Sin embargo, en el resto de los casos pueden llevar a confusión y deberían ser evitados.

Capítulo 5 - FORMATEO

El formateo afecta directamente a la legibilidad del código. El código se lee de arriba abajo y de izquierda a derecha. Los espacios verticales y horizontales permiten separar ideas y conceptos distintos.

Se debe mantener un estilo uniforme, y para ello se debe consensuar con todo el equipo las reglas de formateo. Las reglas elegidas no son tan importantes como el hecho de que todo el mundo se atenga a ellas.

Capítulo 6 - OBJETOS Y ESTRUCTURAS DE DATOS.

No todo se puede solucionar usando sólo objetos o sólo estructuras de datos. Hay que aprender a diferenciar en qué situaciones son más convenientes unos u otros. Los objetos esconden sus datos y exponen funciones que permiten manipularlos, mientras que las estructuras de datos exponen datos pero no tiene funciones que operen sobre ellos.

Capítulo 7 - MANEJO DE ERRORES

El código de manejo de errores oculta la verdadera funcionalidad del código. Hay que mantenerlo lo más separado posible de la lógica de negocio para no dificultar la comprensión de ésta última.

Para no complicar el manejo de errores hay que escribir los bloques try-catch-finally en primer lugar permite identificar los puntos del programa en los cuáles se puede producir una excepción. Se deben usar excepciones en lugar de códigos de retorno. Las excepciones deben proporcionar suficiente información sobre el error y el momento en que se ha producido. Además, las excepciones no comprobadas son menos invasivas a nivel de código.

También se debe evitar pasar null como parámetro de una llamada a un método o devolverlo como valor de retorno. Esto introduce complejidad adicional debido a las comprobaciones necesarias.

Capítulo 8 - FRONTERAS

Los sistemas dependen de paquetes de terceros o de componentes desarrollados por otros equipos. Hay que definir de forma clara la frontera entre el código y el exterior para poder acomodar de forma sencilla los futuros cambios, minimizando las partes de nuestro código que dependan de elementos externos.

Los tests ayudan a experimentar con el código externo viendo cómo puede cubrir nuestras necesidades. También permiten comprobar que las nuevas versiones de la librería siguen cumpliendo con nuestras necesidades.

Encapsular el conocimiento adquerido a través de los tests en un interfaz entre nuestro sistema y el código de terceros permite localizar en ún único punto las modificaciones debidas a posibles cambios en código que está fuera de nuestro control.

Capítulo 9 - TESTS UNITARIOS

En TDD los tests de seben escribir en primer lugar. Las 3 reglas de TDD son:
  • No se debe escribir código de producción hast que no se tenga un test unitario que falle.
  • No se debe escribir más de un test unitario que lo necesario para que éste falle.
  • No se debe escribir más código de producción uqe el necesario para que pase un tests unitario que fallaba.

Se debe dar la misma importancia al código de test que al de producción. Los tests permiten que el código de producción se pueda modificar sin temor a introducir nuevos errores, asegurando su mantenibilidad.

El número de assert por cada test debe ser lo más bajo posible. Se debe testear un único concepto en cada test, lo que permite ir aclarando los distintos conceptos progresivamente, mejorando el conocimiento sobre el código.

Las reglas FIRST sobre el código de test son:
  • Fast: Se deben ejecutar rápido y muy a menudo.
  • Independent: Las condiciones de un test no deben depender de un test anterior.
  • Repeteable: Se deben poder ejecutar en cualquier entorno.
  • Self-Validating: El propio test debe decir si se cumple o no, no debe hacer falta realizar comprobaciones posteriores al test.
  • Timely: Los tests se deben escribir en el momento adecuado, que es justo ante de escribir el código de producción, lo que permite escribir código fácilmente testeable.

Capítulo 10 – CLASES

Las clases se deben organizar situando en primer lugar las constantes públicas, después las variables estáticas privadas, variables de instancia privadas y, a continuación, los métodos. Los métodos privados se encuentran junto a los métodos públicos que los usan.

Se debe mantener la encapsulación de las clases. Las clases deben ser pequeñas y con un número reducido de responsabilidades. Se consigue una alta cohesión si todos los métodos de una clase hacen uso de todas sus variables privadas.

Las nuevas funcionalidades se deben de introducir extendiendo el sistema, no modificando el código existente. Las clases concretas contienen detalles de implementación y las clases abstractas expresan conceptos. La dependencia en clases concretas es un riesgo en caso de cambio. Según el principio de inversión de dependencia las clases deben depender de abstracciones.

Capítulo 11 – SISTEMAS

Es importante reconocer y separar las distintas responsabilidades de un sistema.

En primer lugar, se deben separar el proceso de construcción de un sistema de su uso. El proceso de construcción se encarga de crear y conectar entre sí los objetos necesarios para la ejecución de la aplicación. Se debe modularizar y separar de la lógica de ejecución, permitiendo una estrategia independiente para resolver las dependencias de la aplicación.

La inyección de dependencias permite que los objetos sólo se encarguen únicamente de la lógica de negocio. Un elemento contenedor se encarga de inyectar las dependencias de cada objeto de forma externa.

No se puede construir sistemas de forma correcta a la primera hay que ir implementando las historias de que se dispone, y después refactorizar y expandir el sistema para seguir implementando nuevas historias. TDD, refactorización y código limpio permiten esto a nivel de código.

A nivel de sistema, es difícil crecer de sistemas simples a sistemas complejos debido a las dependencias en la arquitectura que se usa. Para evitar estos problemas, se deben separar las distintos responsabilidades de un sistema. Para lograr esta separación se pueden usar proxys, frameworks AOP Java puros o aspectos AspectJ.

Se debe construir la lógica de la aplicación en base a POJOs a través de tests, e ir evolucionando de lo simple a lo complicado, interconectando los distintos aspectos necesarios.

Capítulo 12 – EMERGENCIA

Las siguientes 4 reglas dadas por Kent Beck permiten crear buenos diseños según se trabaja en ellos, conocer nuestro sistema y aplicar buenos principios de diseño:
  • Ejecutar todos los tests: Los tests verifican que el sistema se comporta según lo esperado. Al construir un sistema testeable se intenta que las clases sean simples y tengan un único propósito, y se trata de reducir el acoplamiento.
  • Eliminar la duplicación: La duplicación implica trabajo adicional, más riesgo y mayor complejidad.
  • Expresar la intención del programador: Usar un código lo más expresivo posible facilita el mantenimiento. Se deben escoger buenos nombres, funciones y clases pequeñas y tests bien escritos.
  • Minimizar el número de clases y métodos: Siguiendo las recomendaciones anteriores uno se puede exceder creando demasiadas clases pequeñas. Hay que tener cuidado y mantener un número reducido de clases.

Durante la refactorización de puede aplicar todo nuestro conocimiento para mejorar el diseño: aumentar la cohesión, reducir el acoplamiento, separar responsabilidades, reducir funciones y clase, escoger nombres mejores, etc.

Se dedicar tiempo a estas tareas después hacer que el software funcione. No se debe pasar a la siguiente tarea sin repasar lo hecho. Es imposible conseguir un código limpio a la primera, hay que repasarlo una y otra vez para conseguir mejorarlo progresivamente.

Capítulo 13 – CONCURRENCIA

La concurrencia es otro de los aspectos que pueden estar presentes en el código. Permite desacoplar lo que que ocurre de cuándo ocurre, y mejorar tanto el rendimiento como la estructura de una aplicación.

Desde el punta de vista estructural se puede percibir la aplicación como un grupo de computadoras colaborando entre sí, haciendo el sistema más fácil de entender y permitiendo separar las responsabilidades. La concurrencia permite mejorar los tiempos de respuesta y la eficiencia de una aplicación.

Se deben tener en cuenta las siguientes ideas sobre la concurrencia:
  • Introduce cierta sobrecarga.
  • Es compleja de manejar.
  • Los errores causados por ella son difícilmente reproducibles
  • Normalmente requiere cambios en el diseño.

El problema de la concurrencia es que los distintos hilos de una aplicación pueden entrelazarse siguiendo múltiples flujos de ejecución, lo que puede provocar problemas inesperados en situaciones normales.

Para defendernos de los problemas de concurrencia es importante que cada clase tenga una única responsabilidad,seperando la gestión de hilos se del resto del código. Hay que conocer las librerías que manejas y entender los distintos modelos de ejecución. Las secciones sincronizadas lo más pequeñas posibles.

Ejecutar pruebas de forma frecuente es la mejor manera de encontrar los posibles errores en el código. Sin embargo, es difícil hacer tests cuando hay concurrencia. Se deben tratar los fallos espúreos como posibles problemas de concurrencia e instrumentar el código para forzar la aparición de errores.

CONCLUSIONES FINALES

Todas estas buenas prácticas sobre cómo escribir código limpio se deben ejecitar de forma constante para adquirir buenos hábitos y ser capaces de hacerlo de forma natural. Siguiendo estas prácticas el autor nos promete conseguir un código con el que será mas fácil trabajar y hará mucho menos frustrante nuestro día a día.

Una idea que se repite en varios puntos del libro es que debemos de ser capaces de exprimir las capacidades de nuestro entorno de trabajo. Conocer nuestro entorno de trabajo nos puede simplificar enormemente nuestro trabajo, puesto que puede realizar por nosotros un montón de actividades de forma automática y nos ofrece una serie de ayudas que nos pueden ayudar en el día a día haciendo innecesarias algunas convenciones que sólo sirven para complicar el código.

Otra cosa que me ha gustado de este libro es la bibliografía en que se basa. No es excesivamente grande, pero me ha servido para sacar unas buenas recomendaciones sobre otros libros a leer:
  • Agile Software Development: Principles, Patterns and Practices, Robert Martin.
  • Implementation Patterns, Kent Beck.
  • Test Driven Development, Kent Beck.
  • Extreme Programming Explained: Embrace Change, Kent Beck.
  • Refactoring: Improving the Design of Existing Code, Martin Fowler et al..
  • Design Patterns: Elements or Reusable Object Oriented Software, Gamma et al..
  • The Pragmatic Programmer, Andrew Hunt, Dave Thomas.

martes, 28 de septiembre de 2010

Error extraño en Sonar con JFreeChart y Novell SecureLogin

Durante algún tiempo no he podido visualizar los gráficos de las estadísticas generados en Sonar a través de JFreeChart en mi equipo del trabajo.

Revisando los logs de Sonar encontré las siguientes trazas:

2010.09.23 11:57:21 ERROR org.mortbay.log Error for /chart
java.lang.NoClassDefFoundError:
Could not initialize class org.jfree.chart.JFreeChart
...
2010.09.23 11:57:21 ERROR org.mortbay.log Error for /chart
java.lang.UnsatisfiedLinkError:
no sljava in java.library.path
...

Al parecer, el error es debido a que no encontraba la librería sljava.dll en la ruta descrita por la propiedad java.library.path, definida en el archivo wrapper.conf de la configuración de Sonar.

Esta librería es una librería de Novell SecureLogin, que tengo configurado en mi equipo y parace que es la instalación de este producto lo que provoca el error.

La solución ha sido tan sencilla como llevar la librería sljava.dll a la ruta de java.library.path. Ahora bien, ni idea de qué está pasando...

jueves, 11 de febrero de 2010

Sonar: Métricas de calidad del código

Según su propia web, Sonar es una plataforma que permite gestionar la calidad del código controlando los 7 ejes principales de dicha calidad del código:
  • Arquitectura y diseño
  • Duplicaciones
  • Pruebas unitarias
  • Complejidad
  • Errores potenciales
  • Reglas de codificación
  • Comentarios

Sonar realiza varios análisis de nuestro código a través de otras herramientas (Checkstyle, PMD, Cobertura…) y presenta de manera unificada a través de su interfaz la información generada por ellas en forma de métricas.

A través de la interfaz de Sonar podemos ver de forma detallada los puntos débiles de nuestro proyecto como errores potenciales en el código, escasez de comentarios, clases demasiado complejas, escasez de cobertura de las pruebas unitarias, y más.

Lo mejor es ilustrar la potencia de esta herramienta con un ejemplo de su uso, para lo cual vamos instalarla en nuestro equipo en primer lugar desde la página web del proyecto Sonar.

Descargamos la versión actual, que en este momento es la 1.12. Una vez que hemos descargado Sonar, tenemos un archivo .zip que podemos descomprimir en cualquier lugar, yo lo haré en la carpeta D:\java.

Por sencillez, para las pruebas vamos a lanzar el servidor de Sonar en modo standalone, aunque lo ideal sería instalarlo en un servidor de aplicaciones. Desde la línea de comandos vamos a la carpeta D:\java\sonar-1.12\bin\windows-x86-32 (estoy haciendo la prueba en Windows) y ejecutamos StartSonar.bat:

Esto lanzará el servidor de Sonar, al que podremos acceder desde la URL http://localhost:9000/:

Como acabamos de instalar Sonar, la interfaz aparecerá prácticamente vacía hasta que empecemos a analizar nuestros proyectos. Para ello iremos a uno de nuestros proyectos, gestionados con Maven, y le pediremos a Sonar que lo analice mediante el target de Maven mvn sonar:sonar:

Si ahora refrescamos la interfaz de Sonar, veremos que aparece el nuevo proyecto analizado:

Además ya nos va mostrando información sobre el proyecto, como el porcentaje de cumplimiento de las reglas de análisis o el porcentaje de cobertura de las pruebas unitarias. Pero, si queremos más información, no tenemos más que pinchar sobre nuestro proyecto para ir a la siguiente pantalla:

Aquí se empieza a ver la potencia de Sonar. En una interfaz compacta nos muestra una cantidad importante de información sobre el código del proyecto como:
  • medida en líneas de código
  • complejidad de los componentes
  • cantidad de comentarios introducidos
  • duplicidad del código
  • cobertura del código
  • conformidad respecto a ciertas reglas de codificación
  • violaciones del código

Para ampliar la información, podemos, por ejemplo, acceder a las violaciones tipo major de las reglas de codificación:

Sonar nos muestra información sobre las reglas que se están incumpliendo, y los paquetes y clases en que esto ocurre. Y, si pinchamos sobre una de las clases Sonar muestra cuál es el código que está incumpliendo estas reglas y da indicaciones para corregirlo:

A mí Sonar me ha parecido una maravilla, y no he hecho más que empezar a ver sus posibilidades. Os invito a que utilicéis esta herramienta y exploréis su interfaz en busca de toda la información que ofrece sobre el código del proyecto.

Referencias:
Página web del proyecto Sonar
Métricas en Java: Sonar
Analizando la calidad del código Java con Sonar

jueves, 12 de noviembre de 2009

La Deuda Técnica

¿Quién no se ha encontrado en el siguiente dilema? Tenemos que añadir una nueva funcionalidad al sistema y tenemos prisa. Podemos hacerlo rápido y de forma no óptima, más enrevesado o menos eficiente, satisfaciendo las exigencias de entrega. O podemos (si es que podemos…) saltarnos estas exigencias y sentarnos a pensar y hacerlo mejor, con diseño más claro y mantenible.

La Deuda Técnica es una metáfora ideada por Ward Cunningham que ayuda a pensar sobre este problema. Viene a decir que en caso de hacer las cosas rápido y de manera chapucera se incurre en una “deuda” que vamos a tener que pagar en el futuro, en forma de esfuerzo de desarrollo, como consecuencia de postergar el buen diseño en la implementación. Y a medida que se siga postergando este esfuerzo y el desarrollo deficiente se siga recubriendo con nuevos desarrollos que lo enmascaren o lo usen, esta deuda será cada vez más elevada y difícil de pagar.

No se quiere decir que no sea sensato incurrir en esta deuda. En ciertas ocasiones es una decisión acertada asumir esta deuda para resolver una situación determinada en un proyecto. Sin embargo, hay que tener en cuenta las repercusiones que puede tomar en el futuro y hay que tratar de satisfacer esta deuda cuanto antes para evitar que crezca desmesuradamente, es decir, que un mal planteamiento en una funcionalidad de la aplicación comprometa la buena marcha del proyecto en el futuro.

Sobre esta idea, Martin Fowler ha desarrollado el “Cuadrante de la Deuda Técnica”. Según él, una deuda técnica asumida en un proyecto puede clasificarse de dos formas:
  • Prudente o imprudente.

  • Advertida o inadvertida.

La combinación de estas clasificaciones produce cuatro situaciones distintas:
  • Deuda prudente y advertida: Se produce cuando somos conscientes de que estamos asumiendo un mal diseño para salir de una situación puntual, como una entrega. Posteriormente se debe evaluar la conveniencia de “pagar la deuda técnica” solucionando esta carencia en función del interés que acarree.

  • Deuda prudente e inadvertida: Se produce cuando, con el paso del tiempo, se descubren cómo se deberían haber hecho las cosas. Inevitable, ya que según avanza el proyecto, se aprende de él. Llegado el momento, también se debe evaluar si resulta interesante mejorar el diseño con lo que hemos aprendido o si esto implicaría un esfuerzo demasiado alto.

  • Deuda imprudente y advertida: Se deshecha el diseño porque se pretende acelerar el desarrollo. Según la “Hipótesis de Resistencia al Diseño”, esto se puede lograr hasta un punto determinado del proyecto en el que deja de ser posible conseguir un beneficio de obviar el diseño porque la calidad del código se degrada.

  • Deuda imprudente e inadvertida: No se conocen las técnicas de diseño ni se es consciente de que se están tomando decisiones incorrectas.

Conviene saber en qué situación nos encontramos. Si bien las tres primeras situaciones se pueden asumir en un momento determinado dentro de un proyecto, la última resulta mucho más peligrosa, porque implica no saber hacia dónde se dirige el proyecto.

Referencias:

La Deuda Técnica
El Cuadrante de la Deuda Técnica
La Hipótesis de Resistencia al Diseño

viernes, 6 de noviembre de 2009

EclEmma: Visualizar la cobertura de los tests unitarios en Eclipse

Hace algún tiempo publiqué un post sobre herramientas de calidad del código. A las que yo publiqué, Dirty Affairs añadió otra, EclEmma, a la cual he estado echando un vistazo.

EclEmma es una herramienta para Eclipse que permite visualizar la cobertura del código de los tests unitarios que hemos hecho. Existen otras herramientas como Cobertura, que generan informes, pero que no permiten visualizar esta informacuón de forma gráfica directamente en Eclipse.

EclEmma se instala en Eclipse de forma sencilla, desde Help -> Software Updates -> Available Software -> Add Site, se añade el sitio http://update.eclemma.org/ y pasamos a realizar la instalación del plugin.

Una vez instalado el plugin y reiniciado Eclipse, aparece una nueva opción en la barra de herramientas:

A través de este botón, podemos lanzar los tests de forma que EclEmma analizará qué parte del código se está cubriendo en ellos. Veamos un ejemplo práctico.

He creado una clase OperadorAritmético, que realiza las operaciones de suma y division:
package com.roldan.tests;

public class OperadorAritmetico {

public static int suma(int a, int b) {
return a + b;
}

public static int division(int a, int b) throws Exception {
if(b==0) {
throw new Exception();
}
return a / b;
}
}

Para probar esta clase he creado una clase de test que, en principio, solo prueba la suma:
package com.roldan.tests;

import org.junit.Assert;
import org.junit.Test;

public class OperadorAritmeticoTest {

@Test
public void suma() {

int a = 5;
int b = 3;

int suma = OperadorAritmetico.suma(a, b);

Assert.assertEquals(8, suma);
}
}

Ahora lanzamos las pruebas para el proyecto, sitándonos en la raíz del proyecto y yendo al botón de EclEmma antes mostrado, seleccionamos la opción Coverage as -> JUnit Test:

Vemos como las instrucciones de la clase OperadorAritmetico has sido coloreadas, con verde aquellas que han sido cubiertas en las pruebas y con rojo aquellas que no. La pestaña Coverage muestra el informe de cobertura del proyecto.

Ahora queremos arreglar un poco esta situación y hacer un prueba para la división:
@Test
public void division() {

int a = 8;
int b = 4;

int division;
try {
division = OperadorAritmetico.division(a, b);
Assert.assertEquals(2, division);
} catch (Exception e) {
Assert.fail();
}
}

Si ahora volvemos a realizar las pruebas, vemos que la situación se ha mejorado, aunque todavía queda código sin cubrir:

De esta forma, podemos ir mejorando progresivamente la cobertura de las pruebas para asegurar el buen funcionamiento de nuestro código.

Referencias:
http://tratandodeentenderlo.blogspot.com/2009/10/herramientas-de-analisis-de-calidad-del.html
http://www.eclemma.org/
http://cobertura.sourceforge.net/

jueves, 1 de octubre de 2009

Herramientas de análisis de calidad del código

Existen muchas herramientas que nos permiten analizar el código desarrollado y parecen ser ampliamente usadas. Me había propuesto escribir un artículo describiendo el uso de algunas de ellas, pero visto que esta información ya existe y es fácilmente localizable en Internet, me voy a limitar a enumerar estas herramientas y hacer una breve descripción de para qué sirve cada una.

Las herramientas sobre las que voy a hablar son:
  • Checkstyle
  • PMD
  • Findbugs
  • JDepend
  • JavaNCSS
  • Cobertura

Checkstyle (http://checkstyle.sourceforge.net/)

Checkstyle ayuda a escribir código que se adhiera a unas convenciones de codificación determinadas. Además, en las últimas versiones se le han añadido nuevas características que permiten también encontrar problemas en el diseño de las clases, encontrar código duplicado o buscar patrones de error conocidos.

Checkstyle tiene plugins que permiten que sea usado desde cualquier IDE, como Eclipse (http://eclipse-cs.sourceforge.net/), resaltando sobre el código los errores encontrados por el analizador. También poseee un plugin para Maven 2 (http://maven.apache.org/plugins/maven-checkstyle-plugin/) que permite generar informe sobre lor errores encontrados.

PMD (http://pmd.sourceforge.net/)

PMD busca en el código fuente ciertos patrones de error, código no usado, código no óptimo, expresiones demasiado complicadas y código duplicado.

Podemos usarlo tanto en Eclipse (http://pmd.sourceforge.net/integrations.html#eclipse) como en Maven (http://maven.apache.org/plugins/maven-pmd-plugin/project-info.html).

Findbugs (http://findbugs.sourceforge.net/)

Se trata de otra herramienta que realiza análisis estático de código en busca de errores.

También puede ser usado en Eclipse (http://findbugs.sourceforge.net/manual/eclipse.html) como en Maven (http://mojo.codehaus.org/findbugs-maven-plugin/2.0.1/).

JDepend (http://clarkware.com/software/JDepend.html)

Jdepend proporciona métricas de cálidad entre los paquetes de un proyecto en términos de su extensibilidad, reusabilidad, y mantenibilidad.

Como las herramientas anteriores, se puede usar en Eclipse (http://andrei.gmxhome.de/jdepend4eclipse/) y en Maven (http://mojo.codehaus.org/jdepend-maven-plugin/).

JavaNCSS (http://www.kclee.de/clemens/java/javancss/)

Esta herramienta permite recoger métricas sobre el código fuente, como el número de líneas, paquetes, clases o métodos.

Al igual que todas las herramientas anteriores, se puede susar en Eclipse (http://freshmeat.net/projects/jncss4eclipse/) y en Maven (http://mojo.codehaus.org/javancss-maven-plugin/dependencies.html).

Cobertura (http://cobertura.sourceforge.net/)

Esta herramienta permite calcular la cantidad de código al que acceden los tests.

En este caso, no se dispone de un plugin para Eclipse, pero si que podemos usar esta herramienta desde Maven (http://mojo.codehaus.org/cobertura-maven-plugin/).


Os animo a que probéis estas herramientas. ¿Conocéis alguna más que pueda resultar útil para el desarrollo de un proyecto Java?