Tip Eclipse: Renombrar atributo junto a sus métodos get/set

Uno de los refactorings que más me gustan de Eclipse es el de Renombrar sobre el propio editor de código, sin necesidad de usar un diálogo o nueva pantalla. El genial Alt+May+R.

Pero como soy muy maniático con los nombres, muchas veces me da por cambiar el nombre de los atributos, por lo que tengo que ir a sus correspondientes métodos get/set y renombrarlos a mano. En el colmo de la perrería, a veces lo que hago es borrarlos y volver a generarlos automáticamente.

Ahora, con Eclipse 3.5 Galileo es mucho más sencillo. Basta con pulsar 2 veces el mismo atajo Alt+May+R sobre el nombre del atributo y aparecerá un diálogo con las opciones de renombrar también sus métodos get y set.


Encima tiene memoria y te guarda tus preferencias. Esta gente piensa en todo!

Cómo configurar el uso de memoria de un servidor en Eclipse

Antes de irme de fin de semana -qué ganas- dejo una chuletilla sobre cómo modificar la configuración de arranque y el uso de memoria de un servidor en Eclipse y en general.

Recuerda que la JVM usa 2 tipos de memoria. La memoria Heap donde se crean los objetos y que es gestionada por el GargabeCollector que se encarga de liberar memoria en caso necesario. Y la memoria PermGen que se utiliza principalmente para cargar las definiciones de las clases de forma permanente, pero también para trabajar con código nativo.

1) En Eclipse, ir a: Run -> Run configurations -> TuServidor -> Arguments -> VM Arguments

2) Para evitar el clásico java.lang.OutOfMemoryError: Java Heap space, usar las opciones de la VM:

-Xms64m
-Xmx256m

Es un ejemplo que asigna 64mb a la memoria heap de inicio y le permite crecer hasta un máximo de 256mb. Esta configuración debería ser más que suficiente si estás en desarrollo y sólo tienes una aplicación configurada para arrancar en el servidor. Antes de incrementarla, tómate unos segundos para meditar si el fallo pudiera ser causa de un memory leak.

3) Para evitar el igualmente clásico java.lang.OutOfMemoryError: PermGen space, usar las opciones de la VM:

-XX:PermSize=64m
-XX:MaxPermSize=128m

Es un ejemplo que asigna 64mb a la memoria perm de inicio y le permite crecer hasta un máximo de 128mb. De nuevo, este ejemplo debería ser más que suficiente si sólo tienes un par de aplicaciones configuradas en el servidor. Aunque todo dependerá del número de despliegues en caliente que realices habitualmente sin reiniciar el servidor.

Otra opción es intentar que el garbage collector recicle la memoria permgen. Para ello prueba a activar el recolector concurrente con los siguientes parámetros:

-XX:+UseConcMarkSweepGC
-XX:+CMSPermGenSweepingEnabled
-XX:+CMSClassUnloadingEnabled


Finalmente un par de enlaces a las páginas oficiales de opciones de la VM y la guía de tuning del gc de la jvm 5.

Primeras impresiones con Pentaho Data Integration (Kettle)

UPDATE 090814: Se añade información sobre la ejecución de una transformación y su impact.

A veces en un proyecto software es necesario extraer, transformar y cargar información de una o varias fuentes de datos. A este proceso se le conoce como ETL.

Los ejemplos típicos de procesos ETL incluyen (i) extracciones de datos desde ficheros con diversos formatos, bases de datos o servicios web, (ii) transformaciones como traducciones de valores, calculos de nuevos valores, cruces de fuentes de datos, filtrar registros, generación de claves, división de columnas o pivotar filas a columnas y viceversa, y (iii) cargas a ficheros o tablas de bases de datos.

La tarea puede llegar a ser bastante compleja, no sólo por la diversidad de las fuentes de datos sino por la variedad de transformaciones a realizar. Sobre todo en el caso de las grandes organizaciones, las llamadas Enterprise, donde cada departamento funciona como le da la gana.

Esta semana me ha tocado (lo que tienen las vacaciones, las de los demás claro) realizar un proceso ETL relativamente simple. Así que he aprovechado para probar la aplicación Pentaho Data Integration, también conocida como Kettle o Spoon, que forma parte de la suite opensource Pentaho de Business Intelligence.

La instalación es muy sencilla. Es una aplicación Java, así que necesita tener instalada una JVM. Por lo demás es simplemente descargar, descomprimir y ejecutar el script de arranque.

Con Kettle puedes crear transformaciones y trabajos (jobs) de forma visual arrastrando, uniendo y configurando los distintos pasos.

Una transformación incluye pasos de extracción, transformación y carga del tipo anteriormente comentado y muchos más. Cada uno de estos pasos se puede previsualizar por separado. Una vez diseñada la transformación, se puede validar, ejecutar, debugear, monitorizar, analizar su impacto en el rendimiento y obtener el código sql que genera.


Un trabajo te permite configurar cómo y cuando se ejecutará una transformación. Sus pasos incluyen, a parte de ejecutar una transformación existente, planificar el inicio, abortar, enviar y recibir emails, operaciones con ficheros, ejecutar un http get, evaluar condiciones sobre ficheros, servidores y tablas, ejecutar scripts sql, javascript y shell, validar xml, escribir log y usar ftp, entre otros.


Conviene tener en cuenta el impacto de la transformación sobre la base de datos a la hora de planificar su ejecución en Producción. Normalmente son tareas muy pesadas que pueden afectar al rendimiento general durante muchos minutos. Así que deben ser ejecutadas en horario de mínima actividad.

El uso de Kettle es muy intuitivo y ágil desde el principio, como se puede en las flash demos que hay disponibles en la wiki. De hecho, en menos de una hora ya tenía hecha una primera versión de mi transformación a la que sólo le faltaban algunos detalles de formatos. Para ser mi primera vez estuvo muy bien!

En la wiki también existe una buena cantidad de documentación. Además existe una guía de usuario en pdf bastante completa que merece la pena tener a mano como referencia.

Una sorpresa que me llevé fue que está traducida en parte al castellano. Aunque como todo no puede ser perfecto, el típico botón Ok o Aceptar ha sido traducido por Vale...

En resumen, Kettle (Spoon) me ha encantado. Es muy completo, sencillo y eficaz. Me va a hacer la vida muy fácil cuando tenga que realizar tareas de ETL.

Chuleta Maven

UPDATE 20100126: Añadido cómo configurar el máximo de memoria heap

A continuación una chuleta con buena parte de lo que llevo aprendido usando Maven estos dos últimos meses más algunas referencias.

> 1. CREAR PROYECTOS

Crear un proyecto jar
$ mvn archetype:create -DgroupId=com.example -DartifactId=example-jar-project

Crear un proyecto war
$ mvn archetype:create -DarchetypeartifactId=maven-archetype-webapp -DgroupId=com.example -DartifactId=example-war-project

> 2. ECLIPSE

Configurar plugin eclipse para descargar fuentes y javadocs de las dependencias

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-eclipse-plugin</artifactId>
<!-- Ojo, la versión 2.6 tiene bugs con AJDT -->
<version>2.5</version>
<configuration>
 <downloadSources>true</downloadSources>
 <downloadJavadocs>true</downloadJavadocs>
</configuration>
</plugin>

Crear variable M2_REPO
Ir a Window -> Preferences -> Java -> Build path -> Classpath variable -> New
Name: M2_REPO
Path: /ruta/a/tu/.m2/repository

Generar ficheros de configuración de un proyecto jar Eclipse
$ mvn eclipse:eclipse

Generar ficheros de configuración de un proyecto war Eclipse
$ mvn eclipse:eclipse -Dwtpversion=1.5

Cargar un proyecto en Eclipse
Ir a File -> Import -> General -> Existing project into Workspace -> Select root directory

Borrar ficheros de configuración proyecto Eclipse
$ mvn eclipse:clean

Ahora más que nunca, se recomienda no subir a CVS o similar los ficheros de configuración del proyecto en el IDE.

> 3. CONFIGURACIÓN DE PLUGINS MÁS COMUNES

Configurar un plugin para este pom y sus hijos
En build -> pluginManagement -> plugins

Configurar un plugin sólo para este pom
En build -> plugins

Configurar encoding y versión java de compilación

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.0.2</version>
<configuration>
 <encoding>UTF-8</encoding>
 <source>1.4</source>
 <target>1.4</target>
</configuration>
</plugin>

Configurar plugin surefire para ignorar fallos de tests, definir patrones de nombres de tests aceptados y configurar propiedades de sistema (locale) durante la ejecución de los tests

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.4.3</version>
<configuration>
 <testFailureIgnore>true</testFailureIgnore>
 <includes>
    <include>**/*Test.java</include>
    <include>**/*Tests.java</include>
 </includes>
 <systemProperties>
    <property>
       <name>user.language</name>
       <value>es</value>
    </property>
    <property>
       <name>user.country</name>
       <value>ES</value>
    </property>
 </systemProperties>
</configuration>
</plugin>

> 4. COMANDOS ÚTILES EN EL DÍA A DÍA

Borrar carpeta de construcción
$ mvn clean

Ejecutar tests
$ mvn test

Construir proyecto
$ mvn package

Instalar proyecto en tu repositorio local
$ mvn install

Instalar (desplegar) proyecto en el repositorio de la organización (necesita configuración)
$ mvn deploy

Ejecutar Maven saltándose los tests (unitarios e integración)
$ mvn xxxxxxx -Dmaven.test.skip=true

Mostrar el stacktrace de excepción
$ mvn xxxxxxx -e

Mostrar información de debug
$ mvn xxxxxxx -X

Instalar una libreria de terceros en tu repositorio local
mvn install:install-file -Dfile=ruta/a/fichero/jar -DgroupId=com.example -DartifactId=nombre_libreria -Dversion=x.y.z -Dpackaging=jar

Instalar (desplegar) una libreria de terceros en el repositorio de la organización (necesita configuración)
$ mvn deploy:deploy-file -Dfile=ruta/a/fichero/jar -DrepositoryId=id_repositorio -Durl=url_repositorio -DgroupId=com.example -DartifactId=nombre_libreria -Dversion=x.y.z -Dpackaging=jar

Ver pom efectivo (suma de poms padres)
$ mvn help:effective-pom

Ejecutar Maven en modo offline
$ mvn xxxxxxx -o

Preparar Maven para poder ejecutarse en modo offline
$ mvn dependency:go-offline

Ejecutar Maven con máximo de memoria heap configurable (ejemplo con 512m)
$ mvn xxxxxxx -DXmx512m
o editar la variable de sistema MAVEN_OPTS=-Xmx512m

> 5. DEPENDENCIAS

Ver jerarquía de dependencias
$ mvn dependency:tree

Ver dependencias en orden alfabético
$ mvn dependency:resolve

Analizar uso de dependencias
$ mvn dependency:analyze

> 6. RECURSOS

Ciclos de vida
http://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html

Estructura estándar de carpetas
http://maven.apache.org/guides/introduction/introduction-to-the-standard-directory-layout.html

Propiedades
http://docs.codehaus.org/display/MAVENUSER/MavenPropertiesGuide

Pom
http://maven.apache.org/ref/2.2.1/maven-model/maven.html

Plugins más comunes
http://maven.apache.org/plugins/index.html

Documentación oficial
http://maven.apache.org/guides/index.html

Libro gratuito: Maven La Guía Definitiva
http://www.sonatype.com/books/maven-book/reference/

Gestor de repositorios Nexus
http://nexus.sonatype.org/index.html

Evaluando WireframeSketcher, plugin Eclipse para diseñar prototipos de pantallas

Me encuentro sumido en un nuevo proyecto, consistente en realizar una fase de análisis de una importante aplicación para gestionar de expedientes en un organismo público. Oh sí, metodología en cascada en toda regla...

Pero a lo que iba, una de las partes más importantes del entregable para el cliente son las pantallas, si no la más. Hasta ahora cuando me ha tocado hacer un esbozo de pantalla, alias wireframe, he sobrevivido con lo primero que he pillado. Pero esta vez, dada la cantidad de pantallas a hacer, me lo he tomado un poco más en serio y he descubierto esta pequeña maravilla: WireframeSketcher.

WireframeSketcher es un plugin para Eclipse que permite dibujar un wireframe de forma intuitiva, ágil y rápida. Muy rápida. Su paleta de componentes es muy completa, sirve tanto para aplicaciones web, como de escritorio. Destacar, también, una ayuda inteligente que te facilita alinear los componentes en base a guías. El acabado es estupendo, agnóstico a estilos y colores, como todo buen wireframe, y se exporta a PNG. Como muestra este screencast.

Requiere Eclipse 3.3. Se puede instalar de forma automática desde Eclipse usando http://wireframesketcher.com/updates como update site. Decir también que cuenta con su propia perspectiva y que de rendimiento va muy bien, no enlentece a Eclipse.

Aunque no todo iba a ser bueno. No es gratis. Pero tiene una versión de prueba permanente gratuita que lo único que hace es añadirte la marca de agua EVALUATION a las imagenes exportadas de las pantallas.
La otra buena noticia es que no es caro, 50-80 dolares cuesta una licencia. Para mí merece la pena, digo el dinero. Así que espero que mi jefe no ponga problemas.

Por qué Maven

Maven es la última pieza que he decidido acoplar en mi entorno de desarrollo o ecosistema software. Para los que no lo conozcais, Maven es una herramienta para gestionar el ciclo de vida de un proyecto Java. Desde mi primer trabajo hasta ahora he estado usando Ant para esta tarea con excelentes resultados.

Entonces por qué cambiar

Soy un apasionado de la parte de construcción de proyectos, lo que en inglés llaman Build Engineering. Llevo ya muchos proyectos, de desarrollo y mantenimiento, de todos los sabores y algún sinsabor también, hasta proyectos con un único servidor de desarrollo compartido y proyectos cero automatizados. Así que he comprobado y sufrido la importancia del sistema de construcción de un proyecto. Hasta que punto es capaz de multiplicar la productividad del equipo, aumentando la velocidad y eficacia de ejecución de los procesos del ciclo de vida.
En mi opinión más importante que usar tal framework o tal otro. Aún más valioso si queremos realizar testing e integración continua. Y en definitiva el camino para convertir nuestra profesión en una verdadera ingeniería.

Por eso, en mi opinión usar Maven, sobre otras alternativas, aporta las siguientes ventajas.

Estandariza la estructura de directorios

Hasta ahora cada proyecto ha tenido una estructura arbitraria, basada en el criterio del lider técnico, en la estructura de generación del IDE corporativo o simplemente copiada de otro proyecto. Así es común encontrarse con que en cada proyecto un mismo tipo de fichero se encuentra en carpetas diferentes sin ninguna razón especial, dificultando el día a día de los que trabajan con varios proyectos de forma paralela.

Maven propone una misma estructura para todos los proyectos, pero permitiendo que pueda configurarse de forma personalizada en caso necesario (convención sobre configuración).

Estandariza el ciclo de vida

Si la estructura de directorio de cada proyecto es un mundo, del ciclo de vida ni hablamos. Cada proyecto tiene sus propias fases, con su nombre, orden y requisitos que hay que aprenderse...

Maven aporta una implementación de ciclo de vida. Sin tener que programar nada. De modo que ejecutar cualquier fase del ciclo de vida es siempre igual en todos los proyectos Maven. Para el desarrollador común aprender a manejar un proyecto Maven implica haber aprendido a manejar todos los proyectos Maven.

Además este ciclo de vida es extensible, permitiendo, en caso necesario, añadir tareas personalizadas implementadas en Java o Ant, entre otros lenguajes.

Reutilización

El año pasado implantamos Hudson como servidor de integración continua. Además de las tareas de test y construcción lo usamos para sacar informes de calidad de código y cobertura. Todo mediante scripts Ant. Pero nuestros proyectos son muchos, muy hetereogeneos y ninguno usaba checkstyle, findbugs, ni cobertura, así que no fue nada inmediato configurarlos para Hudson, no es que nos llevara horas, pero si un rato por proyecto al tener que añadir librerias y modificar el script Ant.

Mientras que con Maven si habría sido inmediato gracias a su sistema de reutilización, tanto de uso de plugins como de herencia de configuración. Fue el momento que empecé a pensar en serio en usar Maven, hasta entonces no me salian las cuentas ventajas/coste.

Integración

La integración de Maven con las herramientas y frameworks que usamos en la actualidad es total. Además de las citadas anteriormente están Eclipse, Selenium, CVS, SVN, Hibernate y Axis2.

Gestión de dependencias

Uno de los problemas más complejos a la hora de configurar un proyecto es la gestión de dependencias. Hasta ahora yo siempre he optado por incluir todas las dependencias en la propia estructura del proyecto y por tanto en el scm. A pesar de la posible redundancia y malgasto de espacio por tener muchas dependencias repetidas entre todos los proyectos.

Maven aporta un sistema de gestión de dependencias basado en repositorios y una fuerte configuración en el proyecto.


También destacar que Maven está basado en la experiencia, criterio y buenas practicas de la gente de Apache. Como puede apreciarse en las características que trae de serie, como filtering, perfiles, arquetipos, sistema multi-módulo y construcción del sitio web del proyecto. Y esto es todo, ya iré contando como me va...

Tip Eclipse: Generar metodos hashCode() y equals()

Hoy toca un tip más sobre Eclipse de los varios que llevo ya en el blog. Se trata de cómo generar los métodos hashCode() y equals() de forma automática.

Abre la clase Java a la que quieras añadirle los métodos y desde el menú Source (Alt+May+S), selecciona la opción Generate hashCode() and equals() (h). Dentro de la pantalla podrás seleccionar los atributos que quieras que participen en la implementación, la localización dentro del fichero Java, si generar comentarios y si usar instanceOf para comprar los tipos.

El código generado es limpio y eficaz. La única pega que le veo es que en los bloques if de 1 línea no usa llaves. Afortunadamente ésto se ha corregido a partir de la versión 3.5 de Eclipse. Otra opción es usar la funcionalidad de realizar acciones al guardar ficheros Java en Eclipse.
También echo de menos poder elegir que use el método get correspondiente en lugar del atributo directamente, me viene a la memoria algún problemilla con Hibernate...

Realizar acciones al guardar en Eclipse

Hoy en día todos estamos más que acostumbrados a que Eclipse compile nuestros ficheros Java cuando los guardamos. Pero ¿sabías que también puede realizar otras acciones?

La pantalla para configurar las acciones que realiza Eclipse al guardar ficheros Java está en Window -> Preferences -> Java -> Editor -> Save Actions.

Las acciones principales que puede realizar son formatear el código, de todo el fichero o sólo las líneas modificadas, y organizar los imports.

Pero además se pueden configurar otras acciones adicionales como:

• Forzar el uso de bloques en sentencias if, while, for y do
• Forzar el estilo de bucle Java 5, es decir for (Object elemento : myArray)
• Añadir/Eliminar paréntesis en expresiones
• Forzar el uso del modificador final en atributos, parámetros o variables locales
• Forzar el uso de this
• Controlar los cualificadores en los accesos estáticos
• Eliminar código no usado
• Eliminar castings innecesarios
• Añadir anotaciones @Override y @Deprecated
• Eliminar espacios en blanco innecesarios
• Corregir indentación
• Ordenar atributos y métodos
  

Generador de gifs de progreso en 3d

No soy de subir posts para compartir links. Para eso prefiero usar delicius. Pero ya en el pasado hice un post sobre un generador de gifs de progreso y ahora he encontrado otro con unos modelos en 3d fantásticos.

Así que ya sin más, os presento a Preloaders, un generador online de gifs de carga con más de 35 modelos diferentes, 16 de ellos en 3d más opciones para seleccionar el tamaño, color y velocidad de animación. Espero que os guste.

2 meses después de Hudson

2 meses después de implantar Hudson como servidor de integración continua dentro del modelo de construcción de software de mi equipo de desarrollo, llega el momento de hacer valoraciones y un poco de retrospectiva.

Por qué Hudson

Existen varios servidores de integración continua disponibles a coste cero además de Hudson, como Cruise Control, Continuum y Luntbuild. En su momento estuve probando Cruise Control pero finalmente elegí Hudson por su mayor facilidad de uso, es realmente intuitivo y muy vistoso, junto con su volcada comunidad y número de plugins en constante crecimiento, que ofrecen una cierta seguridad en el soporte para la integración con otras herramientas.

Para los que no tengais mucho tiempo para hacer vuestras propias pruebas, podéis echar un vistazo al estupendo estudio que hicieron en Xnoccio.

Dificultades

Como ante cualquier intento de cambio significativo en la rutina de un equipo, la principal dificultad suele ser de naturaleza humana y no técnica. Cuando hablé de ello, sólo recibí muestras de escepticismo e indiferencia, en definitiva resistencia al cambio. Ya me pasó con el uso del testing, que costó más de la cuenta implantarlo pero que hoy todos aprecian su valor.

Como además coincidió con que ibamos hasta el cuello de trabajo, ya no es que no tuviera tiempo (en realidad Hudson se instala y configura en 5 minutos) es que no me cabía una tarea más en la cabeza. Así que la cosa se fue alargando hasta que un nuevo compañero se atrevió a instalarlo en nuestro servidor de demos. 2 meses después y con 5 proyectos ya configurados, las dudas y la resistencia se han esfumado. Eso sí, algún programador aún podría sacarle más partido si quisiera.

La única dificultad técnica vino en forma de OutOfMemory después de hacer el build de nuestro proyecto estrella. La fase de testing dura más de media hora y creaba los informes con un log bastante grande debido a la baja categoría de log configurada. Esto provocaba el OutOfMemory durante el análisis del parser dom de Hudson. Lo raro era que por más memoria que le asignaramos seguía fallando. La solución fue tan sencilla como subir la categoría del log a error, pero en mi opinión deberían mejorar ese parser porque tampoco los informes eran tan enormes.

Qué hace Hudson por mi

Todos nuestros proyectos cuentan con un script Ant para realizar las tareas de build, testing y varios tipos de revisiones de código que forman parte de nuestro modelo de construcción de software.

Hudson se encarga ejecutar este script sobre la última versión del proyecto de forma automatizada, bajo demanda o planificada periódicamente, para posteriormente publicar los correspondientes informes con gráficas de tendencias y detalles muy cuidados. De este modo se puede disponer de toda la información sobre la salud de un proyecto actualizada y disponible a sólo un par de clicks de ratón.

En concreto las tareas que se ejecutan son:

• Build. Compila, copia y, en algunos casos, genera código como los ficheros de mapeo Hibernate. En definitiva construye la aplicación para poder ejecutar los tests sobre ella.
• Test. Ejecuta todos los tests definidos para el proyecto.
• Checkstyle. Ejecuta el analizador de código Java Checkstyle para obtener un informe de la calidad del código. Revisa todo, desde sintaxis a tamaños, métricas, defectos de programación, código copy/paste, javadoc, etc. La configuración por defecto es, en mi opinión, excesivamente rigurosa con la sintaxis y el javadoc. Recomiendo dedicarle un rato y crear tu propia configuración.
  
• FindBugs. Ejecuta el analizador de código Java FindBugs en busca de posibles defectos y malas prácticas de programación que no cubre Checkstyle. Es bastante listo.
  
• Tareas abiertas. Detecta los todo y fixme contenidos en el proyecto.
  

Una de las cosas que hace Hudson que más me gusta, es que en la pantalla de cada build te muestra los comentarios hechos en los últimos commits. Esto es realmente útil para hacerte una idea rápida de por donde va el desarrollo y que se hizo el último día.

Futuro

A corto plazo quiero añadir las siguientes tareas:

• Cobertura. Sin duda la métrica que nos falta es el nivel de cobertura de los tests sobre el código del proyecto. Hice mis pruebas con el mismo Cobertura pero daba un extraño error con unas clases de nuestro proyecto estrella. Así que probaré EMMA ya que con su plugin para Eclipse no he tenido problemas.
  
• Selenium. Hasta ahora todos los tests ejecutados son a nivel de código Java. Una vez probadas las bondades del testing en este nivel, es el momento de dar el siguiente paso y llevarlo a la parte web. Si bien hemos probado Selenium, sólo lo hemos usado para cargar formularios muy largos o hacer un tour por todas las pantallas de la aplicación, pero siempre ejecutándolo luego de forma manual. El objetivo es usarlo más profundamente y automatizar también este tipo de tests.
• Despliegue. Otro paso lógico, una vez construida la aplicación es hacer que se despliegue automaticamente en nuestro servidor de demos. Además de que resulta imprescindible para los tests Selenium. De hecho en principio sí teniamos el despliegue configurado pero nuestro servidor de demos tiene poca memoria, de modo que en pocos días había que reiniciarlo porque daba un OutOfMemory y no hay más. La solución pasa por automatizar también un reinicio del servidor.
  

Beneficios

Las ventajas de la integración continua son obvias, (1) detección temprana y automatizada de errores, (2) disponibilidad inmediata de las últimas versiones de los artefactos generados, (3) conocimiento actualizado del estado y calidad del código del proyecto y (4) ahorro del tiempo que supone la automatización de las tareas que forman parte del modelo de construcción del proyecto.

Ahora cada mañana lo primero que hago es navegar por nuestro Hudson. Basta con un par de minutos para revisar el estado de cada proyecto y tomar las medidas necesarias para que el equipo pueda iniciar la corrección de cualquier fallo detectado o situación sospechosa. Un par de minutos.

Además en estos 2 meses ha dado tiempo a observar otros gratos efectos secundarios a la implantación de Hudson.

• Mayor calidad del código. Antes de implantar Hudon ya habiamos empezado a usar Checkstyle desde Eclipse pero sólo han empezado a verse verdaderos resultados al automatizar las revisiones diariamente y publicar los informes.
• Disminución del número de tests fallidos. Antes algunos tests dejaban de funcionar y se podían quedar así semanas y semanas. Normalmente hasta que me daba cuenta yo y obligaba a arreglarlos. Ahora con Hudon en plan chivato intervengo mucho menos.
• Mejores tests. El hecho de tener que arreglar los tests ha servido para comprobar de primera mano la importancia de programar tests repetibles e independientes.
• Mayor sentido de la responsabilidad del código. Poco a poco se va notando que cada programador cuida más su código y el proyecto en general. Nadie quiere romper una build y empieza a verse en los comentarios de los commits como toman la iniciativa para reducir las faltas de las revisiones de código.
  

Y, por qué no decirlo, también está la satisfacción de estar creando un verdadero modelo de construcción de software moderno, ágil y que cuida la calidad.

Búsqueda incremental en Eclipse

Ultimamente me ha dado por redescubrir Eclipse. Que si plugins, atajos, templates,... es soprendente lo fácil que es descubrir una nueva o simplemente desconocida funcionalidad.

Lo último ha sido la búsqueda incremental, en inglés Incremental Find. Una funcionalidad más que recomendable para aquellos que encontréis mejorable el clásico diálogo de búsqueda del editor (Ctrl+F), sobretodo después de usar todos los dias el buscar de Firefox.

Para usar la búsqueda incremental sobre un fichero basta con abrirlo en el editor y pulsar Ctrl+J. Ojo porque no aparecerá ningún diálogo ni nada visual salvo la frase Incremental Find en la barra de estado. En ese momento tecleamos la palabra a buscar y Eclipse irá buscando según tecleamos. Para moverte entre las distintas ocurrencias puedes usar las fechas arriba y abajo.

Cómo hacer que Eclipse ignore una carpeta

A veces la carpeta build puede hacerse muy molesta cuando trabajamos con Eclipse, como cuando estamos buscando un fichero con el atajo Ctrl-May-R y acabamos editando la copia contenida en la carpeta build o cuando Eclipse se pone a validar todos sus ficheros.

Para hacer que Eclipse ignore una carpeta basta con pulsar con el botón derecho sobre ella, seleccionar Properties y hacer click en Derived. Rápido y efectivo, aunque podría haber sido más intuitivo.

Java Templates en Eclipse: Logger

Los Templates del editor Java de Eclipse son estupendos. Ya sabeis, cuando estás programando una clase Java, tecleas por ejemplo for, pulsas Ctrl + Espacio y te aparece un popup con las posibles estructuras del bucle for para autocompletar. La de teclas que te puedes ahorrar en un par de años!

No sólo existen templates para las estructuras de control, también hay para traza, declaración de métodos, inicialización de atributos, constantes, lazy y más. La pantalla donde gestionar los templates está en Window -> Preferences -> Java -> Editor -> Templates.

Ahora piensa en una línea de código que repitas en casi todas tus clases y para la que no haya un template en Eclipse. ¿Es ésta?

private static final Log logger = LogFactory.getLog(NombreClase.class);

Si es así, puedes crearte un template, llamémosle logger, con este simple código:

private static final ${loggerType:newType(org.apache.commons.logging.Log)} logger =
   ${logFactoryType:newType(org.apache.commons.logging.LogFactory)}
   .getLog(${enclosing_type}.class);

Aquí te dejo otro para el típico debug (evitando procesar el posible mensaje):

if (logger.isDebugEnabled()) {
   logger.debug(${msg});
}

Y tú, ¿usas alguno más que no vaya de serie?

Útiles atajos de teclado en Eclipse

Es obligación de un buen programador sacarle el máximo partido a las herramientas que usa en el día a día. El primer paso es conocer una buena parte de los atajos de teclado de tu IDE favorito, en mi caso Eclipse.

Y aquí os dejo una lista de los atajos que yo encuentro más útiles:

• Ctrl + T: Navegar por la jerarquía del tipo seleccionado. Mucho más útil que el típico Ctrl + click cuando el tipo es un interface.
  
• Ctrl + May + G: Buscar las ocurrencias del tipo o variable seleccionado por todo el workspace.
  
• Ctrl + H: Abrir la ventana de búsquedas.
  
• Ctrl + May + R: Buscar y abrir por nombre de fichero.
  
• Ctrl + May + T: Buscar y abrir por nombre de tipo.
  
• Ctrl + E: Navegar por los ficheros abiertos.
  
• Ctrl + O: Navegar por lista de atributos y métodos. Si lo pulsas 2 veces añade los atributos y métodos de las clases padre.
  
• Ctrl + L: Ir a número de línea.
  
• Alt + May + L: Mostrar la lista de todos los atajos de teclado. Si pulsas 2 veces abres la ventana de configuración de atajos de teclado donde podrás ver, modificar y crear nuevos atajos.

Y tú, ¿conoces alguno más?

Generador de gifs de progreso

El otro día teniamos que poner la típica animación de progreso para amenizar la espera al usuario mientras nuestra última aplicación prepara un informe realmente costoso. Yo en principio sólo había pedido que se reutilizará la típica animación del circulito que ya tenemos. De ahí mi sorpresa cuando mi compañero me llama para que elija que animación me gusta más y me enseña este generador online de gifs de carga o progreso: http://www.loadinfo.net/.
La verdad que fue todo un punto por su parte. Da gusto ver como los miembros de tu equipo evolucionan y demuestran iniciativa.

Volviendo a la herramienta, tiene 132 animaciones diferentes donde elegir, 3 tamaños diferentes (16x16, 24x24 y 48x48) y te permite definir el color de la figura y el fondo.

UPDATE el gif alojado en blogger no se movía y lo he tenido que subir a http://www.imageshack.us/, un servicio gratuito de alojamiento de recursos multimedia.

Revisiones de código automatizadas con Eclipse (II): Cómo crear tu propia configuración en CheckStyle

En mi anterior post de Revisiones de código automatizadas con Eclipse aproveché para hacer una mini presentación de varios de los plugins más conocidos de Eclipse para analizar código Java. Posteriormente yo decidí usar el plugin de David Schneider para CheckStyle, principalmente por la facilidad con la que puedes configurar tu propio juego de reglas.

Al final lo que intentas con este tipo de herramientas es asegurarte de que el código de tus proyectos sigue un mismo estilo que asegura un mínimo de calidad y, sobretodo, facilita su mantenimiento. Ahora bien, un estilo es algo subjetivo de por sí y necesita definirse, así que cuanto más facil sea definirlo mejor. Otras ventajas significativas son su facilidad de uso, que los mensajes de las reglas están en castellano y la posibilidad de implementar tus propias reglas.

Instalación
Instalar el citado plugin de CheckStyle en Eclipse es tan sencillo como ir a la opción Help -> Software Updates -> Find and Install. Añadir como Remote Site la url: http://eclipse-cs.sourceforge.net/update/ e ir dándole al botón de siguiente...

Crear una nueva configuración
Una vez instalado puedes configurarlo de forma global en la opción Window -> Preferences -> CheckStyle. Aunque tambien puedes configurar cada proyecto individualmente.


Desde esta pantalla puedes crear tus propias configuraciones o juegos de reglas desde cero o copiando una ya existente. Las configuraciones iniciales (Sun y Sun-Eclipse) no pueden modificarse. Tambien puedes exportar/importar configuraciones e indicar la que se usará por defecto.

Añadiendo reglas
Llegados a este punto selecciona tu nueva configuración y pulsa el botón Configure. En la pantalla de configuración podrás examinar el conjunto de reglas disponible, añadir y parametrizar las reglas de tu elección. Uno de los parametros más importantes es la prioridad. Existen tres niveles de prioridad para las reglas que se comparten con los mensajes del propio Eclipse: error, advertencia e información.


El conjunto de reglas disponible es muy completo y está clasificado en los siguientes grupos:

• Comentarios Javadoc: facilitar el mantenimiento pasa por comentar el código, pero luego los comentarios también hay que mantenerlos... CheckStyle tiene muchas reglas para los javadoc y es muy flexible. Te permite, por ejemplo, obligar a comentar los nombres de clases, todos los métodos menos los get/set y los atributos públicos.
  
• Convenciones de nombres: puedes definir una expresión regular para el nombre de todo. En este punto yo copio las reglas de Sun.
  
• Cabeceras: expresiones regulares para la cabecera de los ficheros.
  
• Imports: reglas para los import, como no usar *, imports sin usar, etc.
  
• Violaciones de tamaño: define un máximo para el tamaño de tus clases, métodos, líneas y número de parametros de un método.
  
• Espacios en blanco: un montón de reglas para definir donde se ponen espacios en blanco y tabuladores en el código.
  
• Modificadores: establece un orden para los modificadores y evita modificadores innecesarios.
  
• Bloques: reglas para los bloques de codigo y sus llaves.
  
• Problemas en la codificación: aquí hay de todo, desde malas prácticas tipo asignaciones internas y posibles fuentes de bugs como definir un método equals que no es el equals(Object), a cosas más estéticas o pijillas, como que el default sea el último elemento en un switch o parentesis innecesarios.
• Diseño de clases: varias reglas sobre el diseño de interfaces y clases, con especial atención en las excepciones.
  
• Duplicados: te permite definir un mínimo de líneas para buscar codigo duplicado en tus clases.
  
• Métricas: define máximos para métricas como complejidad ciclomática, complejidad de expresiones lógicas, npath, líneas de código seguidas sin comentar y dependencia de clases.
  
• Misceláneo: variables final, indentación, un buscador de expresiones regulares y varias cosas más.
  
• J2EE: reglas para EJBs.
• Otros: internos a CheckStyle y activados por defecto.
  
• Filtros: para eventos de auditoria del propio CheckStyle, no hace falta mirarlos.

Cómo usar CheckStyle
La configuración que indiques por defecto se asignará inicialmente a todos tus proyectos, aunque puedes configurar cada proyecto individualmente con una, varias o ninguna configuración.

Además puedes elegir entre tener CheckStyle activado todo el tiempo o usarlo a petición. Todo ello pulsando el botón derecho sobre el proyecto y yendo al menú de CheckStyle. Conforme se incumplan reglas irán saliendo los mensajes correspondientes en la vista Problems de Eclipse ordenados por prioridad y en español!

Pero una vez instalado el plugin, creada la configuración y distribuida entre los miembros del equipo, pasa a ser responsabilidad del programador usar la herramienta y autorevisar su código. Y aquí empieza lo difícil, ¿cuántas reglas y de qué tipo permitirás que no se cumplan en un commit? ¿qué hacer cuando alguién no cumple con las revisiones? ¿cómo detectarlo? ¿todo esto se puede automatizar un poco más?

La única respuesta que tengo cierta es para la última pregunta: sí, con integración continua... pero eso será ya otro post.

Cómo invocar un webservice desde eclipse

Otra herramienta que he descubierto en mi vuelta a los webservices es el Web Services Explorer de eclipse, una de las muchas aportaciones de IBM al ide que permite invocar servicios web de una forma visual y relativamente sencilla desde nuestro eclipse.

Para usarlo hay que tener instalada la Web Tools Plataform en tu eclipse (lo más cómodo es bajarse el all-in-one) y pulsar en la opción Run -> Launch the Web Services Explorer.

Lo siguiente será seleccionar el webservice a invocar, para ello podemos cargar su WSDL pulsando en el segundo botón de la derecha (WSDL Page) y luego en WSDL Main en Navigator.
A continuación debemos introducir la URL donde esté publicado el WSDL del servicio web y pulsar en Go.

Tras unos instantes, si todo va bien, se habrá generado un cliente para el webservice y podrás ver sus operaciones y sus endpoints. Estos últimos son editables.

A partir de aquí es tan sencillo como seleccionar una operación y rellenar los datos necesarios para invocar al servicio web. Las peticiones y respuestas se pueden ver tanto en el interfaz gráfico (modo Form) como en XML (modo Source).

Como punto negativo decir que a veces el interfaz gráfico no se genera correctamente con mensajes muy complejos y además no es que sea muy intuitivo. Aunque no lo parezca, si haces doble-click sobre los títulos de los paneles se maximizan.

NetTool: cliente HTTP y tunneling TCP en Java

Lo mejor de trabajar en equipo y ser colaborativo es que se aprenden muchas cosas, desde algo sencillo como un atajo con el Eclipse a descubrir una herramienta que es una joya como NetTool.

NetTool te permite hacer de cliente HTTP y tunneling TCP de forma muy sencilla. Un cliente HTTP viene muy bien para hacer peticiones directamente contra una aplicacion web, pero sobretodo contra servicios ajax o incluso servicios web y ver el resultado en un momento. Especialmente para hacer pruebas de seguridad XSS.

El tunneling se hace también de forma muy sencilla y te permite examinar el tráfico que ocurre entre dos extremos de una comunicación TCP. Ideal para ver lo que realmente está pasando cuando un equipo hace el servidor y otro el cliente, algo falla y todo el mundo se echa las culpas entre sí, ¿os suena?.

Además la aplicación está hecha en Java, es decir es multiplataforma, y su interfaz está más que cuidada, facilitando su uso enormemente. No es por hacer publicidad, que no me llevo nada, pero también tiene un montón de looks&feels, incluyendo JGoodies! En definitiva, muy recomendable.

Revisiones de código automatizadas con Eclipse

No es fácil establecer una política de revisiones de código que funcione. Por un lado está la resistencia que puede ofrecer el programador que va a ser revisado y por otro la dificultad de encontrar el tiempo necesario que tiene que dedicar el programador que tiene que hace la revisión.

Una buena idea para evitar malos rollos y optimizar el tiempo del equipo es automatizar las partes repetitivas y propensas a descuidar de las revisiones, como los estándares de codificación, longitudes de clases y métodos, código duplicado, malas prácticas, etc. dejando las revisiones por parejas para temas de más alto nivel y diseño.

Entonces un primer paso de una política de revisiones de código debe ser integrar herramientas de este tipo en el ide de los programadores, para que ellos solos puedan mejorar y asegurar la calidad de su código.

A continuación os comento algunas de estas herramientas que he instalado en mi eclipse para evaluar y poder mejorar el proceso de desarrollo de mi equipo.

PMD
Detecta posibles bugs, malas prácticas, código duplicado y código excesivamente complejo en base a un potente juego de reglas configurables.
He tenido problemas al instalarlo copiándolo directamente a la carpeta plugins del eclipse y tuve que hacerlo con el Find and Install del menú Help/Software Updates del eclipse. Es sencillo, sólo hay que añadir http://pmd.sourceforge.net/eclipse como New Remote Site y continuar el asistente.

La primera impresión que te llevas al analizar tu código con PMD es un poco avergonzante, es increible la cantidad de reglas que saltan en cada clase del que hasta ahora era un código del que te sentias orgulloso. Algunas de ellas son bastante discutibles, como evitar construcciones tipo if (x!=y)..;else..; a favor del operador ?, no usar más de una sentencia return en un método o declarar variables y parametros final.

La prioridad por defecto de las reglas no me gusta, mete mucho ruido en el análisis. Por ejemplo, da la misma importancia a que un parametro no sea final que a un método que se salte el número máximo de líneas o de complejidad ciclomática. A su favor, decir que detecta código duplicado además de malos usos de excepciones, loggers, constantes, clases antiguas como Vector, etc. En conclusión, una herramienta útil pero que necesita de una buena y larga configuración para hacerla efectiva.

CheckStyle
Otro analizador de código Java que cuenta con dos plugins para Eclipse, el de David Schneider y el de Marco van Meegen. Yo prefiero el primero con diferencia. Se instala via eclipse añadiendo la url http://eclipse-cs.sourceforge.net/update/ como New Remote Site en Help -> Software updates -> Find and install.

CheckStyle tiene un juego muy completo de reglas, que a diferencia de PMD tiene en cuenta también los estándares de codificación de Sun, con reglas hasta para los espacios y tabuladores. Ésto provoca que hacer un análisis con CheckStyle emita un buen número de violaciones, algunas importantes y otras no tanto.

Afortunadamente es muy flexible de configurar. Es realmente sencillo crear una nueva configuración e ir añadiendo las reglas que quieras, con la prioridad y parametros de tu gusto. Merece la pena.
Como punto negativo decir que el icono de violación en el editor podía estar más cuidado y cambiar de color según la severidad de la violación. Además no tiene una perspectiva propia en Eclipse, hay que añadir las vistas a mano.

FindBugs
Se puede instalar desde Eclipse usando http://findbugs.cs.umd.edu/eclipse como New Remote Site.

No es tan completo como los anteriores, sólo sirve para encontrar posibles bugs y malas prácticas. Aún así es muy bueno en lo que hace, tiene su propia perspectiva en Eclipse con una interfaz muy cuidada que lo hace muy fácil de usar.

Entonces como herramienta única no es suficiente, pero si se puede usar junto a otra que realice la parte de reglas sintácticas y métricas.