• En General marcar “Show heap status” para mostrar un pequeño indicador en la esquina inferior derecha con el uso de Java de la memoria dinámica.
• En General -> Appearance, marcamos “Override presentation settings” para poder modificar la posición de las pestañas y el selector de perspectivas. Desmarcamos “Show text on the perspective bar” para no mostrar el nombre de la perspectiva actual en la barra de perspectivas, para lograr más espacio. Marcamos “Show traditional style tabs” para usar pestañas normales y desmarcamos “Enable animations” para desactivar las animaciones y que el entorno vaya más fluido.
• En General -> Appearance -> Colors and Fonts, expandimos Basic, seleccionamos Text Font, pulsamos Change, y seleccionamos la fuente que queramos utilizar para los editores. En mi caso suelo utilizar Bitstream Vera Sans Mono o Consolas.
• En General -> Editors -> Structured Text Editors marcamos Enable folding para contar con la característica de code folding en los editores de HTML, JSP, XML, …
• En General -> Editors -> Text Editors marcamos Insert spaces for tabs para que el editor introduzca espacios al pulsar la tecla de tabulación en lugar de caracteres de tabulación. Marcamos Show print margin para que el editor muestre una línea en la columna 80. Marcamos show line numbers para mostrar los números de línea.
• En General -> Editors -> Text Editors -> Spelling desmarcamos “Enable spell checking” para que no compruebe la ortografía, cosa que en un editor de código molesta más de lo que ayuda.
• En General -> Workspace seleccionamos Other, UTF-8 para Text file encoding para usar Unicode como juego de caracteres para los archivos que creemos y Other, Unix en New text file line delimiter para usar el caracter de fin de línea de Unix.
• En Java -> Code Style -> Formatter pulsamos “Edit…” para modificar la forma de comportarse del formateo de código automático de Eclipse. En la pestaña “Identation” del nuevo diálogo seleccionamos “Spaces only” para “Tab policy” para que utilice siempre espacios y no tabuladores. Marcamos Statements within ‘switch’ body para que indente las sentencias del switch. Cambiamos el nombre del perfil al que queramos en “Profile name” y pulsamos Ok.
• En Java -> Editor -> Save Actions marcamos Perform the selected actions on save y marcamos Format source code para que use el formateo de código automático al guardar el archivo, Organize imports para que organice los imports según el paquete y Additional actions para otras acciones. Pulsamos Configure para configurar estas otras acciones y en Code Style marcamos Convert for loops to enhanced para que sustituya los bucles que recorren colecciones por la versión for-each y desmarcamos Use modificer ‘final’ where possible para que no declare las variables que no modificamos como final. En Unnecessary Code marcamos Remove unused imports para que se eliminen los imports que no utilizamos. En Code Organizing marcamos Correct indentation y Sort members.
• Cerramos la vista de Outline, que podemos sustituir con el breadcumb, haciendo clic sobre el botón de la barra de herramientas Toggle Breadcumb, o con la vista de outline rápida, pulsando Ctrl + O.

Eclipse guarda la configuración del entorno en una carpeta .metadata dentro del directorio del espacio de trabajo. Una vez configurado basta conservar esta carpeta.

Vamos a crear una pequeña clase de ejemplo para demostrar su funcionamiento.

import java.util.EnumSet;

public class Ejemplo {
  enum Dia {
    LUNES, MARTES, MIERCOLES, JUEVES, VIERNES, SABADO, DOMINGO
  }

  public static void main(String[] args) {
    for (Dia dia : EnumSet.allOf(Dia.class))
      System.out.println(dia);
  }
}

Si abrimos la vista de navegador en Eclipse (Window -> Show View -> Navigator) y hacemos doble clic sobre el archivo que representa a nuestra clase compilada en la carpeta bin, se lanzará el visor de clases, mostrando el bytcode de la clase. También podemos utilizar la herramienta javap, incluída en el JDK:

javap -c Ejemplo

El bytecode de nuestra clase tiene el siguiente aspecto:

// Compiled from Ejemplo.java (version 1.6 : 50.0, super bit)
public class Ejemplo {

  // Method descriptor #6 ()V
  // Stack: 1, Locals: 1
  public Ejemplo();
    0  aload_0 [this]
    1  invokespecial java.lang.Object() [8]
    4  return
      Line numbers:
        [pc: 0, line: 3]
      Local variable table:
        [pc: 0, pc: 5] local: this index: 0 type: Ejemplo

  // Method descriptor #15 ([Ljava/lang/String;)V
  // Stack: 2, Locals: 3
  public static void main(java.lang.String[] args);
     0  ldc <Class Ejemplo$Dia> [16]
     2  invokestatic java.util.EnumSet.allOf(java.lang.Class) : java.util.EnumSet [18]
     5  invokevirtual java.util.EnumSet.iterator() : java.util.Iterator [24]
     8  astore_2
     9  goto 29
    12  aload_2
    13  invokeinterface java.util.Iterator.next() : java.lang.Object [28] [nargs: 1]
    18  checkcast Ejemplo$Dia [16]
    21  astore_1 [dia]
    22  getstatic java.lang.System.out : java.io.PrintStream [34]
    25  aload_1 [dia]
    26  invokevirtual java.io.PrintStream.println(java.lang.Object) : void [40]
    29  aload_2
    30  invokeinterface java.util.Iterator.hasNext() : boolean [46] [nargs: 1]
    35  ifne 12
    38  return
      Line numbers:
        [pc: 0, line: 9]
        [pc: 22, line: 10]
        [pc: 29, line: 9]
        [pc: 38, line: 11]
      Local variable table:
        [pc: 0, pc: 39] local: args index: 0 type: java.lang.String[]
        [pc: 22, pc: 29] local: dia index: 1 type: Ejemplo.Dia
      Stack map table: number of frames 2
        [pc: 12, full, stack: {}, locals: {java.lang.String[], _, java.util.Iterator}]
        [pc: 29, same]

  Inner classes:
    [inner class info: #16 Ejemplo$Dia, outer class info: #1 Ejemplo
     inner name: #59 Dia, accessflags: 16408 static final]
}

Como vemos en realidad el bucle for each se convierte en un bucle que utiliza un iterador.

Si usamos el decompilador jad el resultado será:

import java.io.PrintStream;
import java.util.EnumSet;
import java.util.Iterator;

public class Ejemplo {
  static final class Dia extends Enum {
    public static Dia[] values() {
      Dia adia[];
      int i;
      Dia adia1[];
      System.arraycopy(adia = ENUM$VALUES, 0,
          adia1 = new Dia[i = adia.length], 0, i);
      return adia1;
    }

    public static Dia valueOf(String s) {
      return (Dia) Enum.valueOf(Ejemplo$Dia, s);
    }

    public static final Dia LUNES;
    public static final Dia MARTES;
    public static final Dia MIERCOLES;
    public static final Dia JUEVES;
    public static final Dia VIERNES;
    public static final Dia SABADO;
    public static final Dia DOMINGO;
    private static final Dia ENUM$VALUES[];

    static {
      LUNES = new Dia("LUNES", 0);
      MARTES = new Dia("MARTES", 1);
      MIERCOLES = new Dia("MIERCOLES", 2);
      JUEVES = new Dia("JUEVES", 3);
      VIERNES = new Dia("VIERNES", 4);
      SABADO = new Dia("SABADO", 5);
      DOMINGO = new Dia("DOMINGO", 6);
      ENUM$VALUES = (new Dia[] { LUNES, MARTES, MIERCOLES, JUEVES,
          VIERNES, SABADO, DOMINGO });
    }

    private Dia(String s, int i) {
      super(s, i);
    }
  }

  public Ejemplo() {
  }

  public static void main(String args[]) {
    Dia dia;
    for (Iterator iterator = EnumSet.allOf(Ejemplo$Dia).iterator(); iterator
        .hasNext(); System.out.println(dia))
      dia = (Dia) iterator.next();
  }
}

que como vemos no está demasiado mal, pero dista bastante del original.

Por último este es el resultado de JD-GUI:

import java.io.PrintStream;
import java.util.EnumSet;
import java.util.Iterator;

public class Ejemplo {
  public static void main(String[] args) {
    for (Iterator localIterator = EnumSet.allOf(Ejemplo.Dia.class)
        .iterator(); localIterator.hasNext();) {
      Ejemplo.Dia dia = (Ejemplo.Dia) localIterator.next();
      System.out.println(dia);
    }
  }

  static enum Dia {
    LUNES, MARTES, MIERCOLES, JUEVES, VIERNES, SABADO, DOMINGO;
  }
}

PMD se puede utilizar desde linea de comandos, o puede integrarse con multitud de IDEs y herramientas, como Eclipse, NetBeans, Maven o JEdit. Y aunque algunos de los casos que comprueba PMD ya se tengan en cuenta en Eclipse, sigue siendo una utilidad muy interesante para añadir a nuestra caja de herramientas.

Para instalar el plugin de PMD para Eclipse tenemos que añadir la URL desde la que actualizar el software, http://pmd.sourceforge.net/eclipse, en el diálogo Help -> Software updates -> Available Software -> Add Site, marcar el componente correspondiente dependiendo de nuestra versión de Eclipse y seleccionar Install.

Una vez terminado el proceso podremos gestionar las reglas de PMD desde Window -> Preferences -> PMD -> Rules Configuration. En la misma sección también podemos añadir nuevas reglas utilizando consultas XPath.

Al instalar PMD tendremos acceso a una nueva perspectiva a la que podemos acceder desde Window -> Open Perspective -> Other -> PMD. Para empezar a utilizar PMD haremos clic con el botón derecho sobre el proyecto, el paquete o la clase que queramos comprobar y seleccionaremos PMD -> Check code with PMD.

En la vista Violations Overview podremos ver un resumen de las reglas que incumple nuestro código, con el nombre de la regla, el número de violaciones por paquete, clase y método y el número de violaciones cada 1000 líneas de código.

En Violations Outline podremos ver una pequeña descripción de la regla que rompe nuestro código, asi como la línea de código en el que se encontró el error. Si hacemos clic sobre una de las entradas de la lista se abrirá la clase correspondiente en la línea a corregir. Si necesitamos más información sobre el error podemos hacer clic sobre este y seleccionar Show Details, donde podremos consultar una descripción completa de la regla, asi como ejemplos y la expresión XPath utilizada.

La forma más sencilla de instalar este plugin es utilizar el sistema de actualizaciones de software de Eclipse. En el diálogo Help -> Software updates -> Available Software -> Add Site introducimos la URL desde la que instalar el plugin, “http://eclipse-cs.sourceforge.net/update”, marcamos nuestra nueva fuente y seleccionamos Install.

Si entramos ahora en Window -> Preferences ->Checkstyle veremos las opciones de configuración relativas a Checkstyle. Como vemos en Global Check Configurations, Checkstyle utiliza por defecto las convenciones de la guía de estilo de Sun (Sun Checks), pero podemos editarlas o crear un nuevo conjunto de reglas fácilmente. El plugin también incluye un conjunto de normas basadas en las convenciones de Sun, ligeramente modificadas para adaptarse mejor a la configuración por defecto del formateador de código de Eclipse: Sun Checks (Eclipse).

Para activar Checkstyle para uno de nuestros proyectos haremos clic con el botón derecho sobre él, seleccionaremos Properties y en la sección dedicada a Checkstyle marcaremos Checkstyle active for this project. En esta sección podemos seleccionar también el conjunto de normas que nuestro proyecto debe de seguir, asi como posibles excepciones.

Una vez activado Checkstyle para el proyecto veremos los Warnings relativos a los estándares de código en la vista Problems, así como en el propio editor, donde las advertencias se muestran con fondo amarillo. También podemos recurrir a la vista Checkstyle violations (Window -> Show view -> Checkstyle -> Checkstyle violations), que está más especializada y permite agrupar los problemas, generar informes en formato rtf, y lanzar la vista Checkstyle violations chart, con un gráfico de tarta con los distintos problemas encontrados en el código.

Para instalar Subclipse podemos usar el sistema de actualizaciones de software de Eclipse: abrimos el diálogo Help -> Software updates -> Available Software -> Add Site e introducimos la URL desde la que instalar el plugin, en este caso, para la última versión al escribir estas líneas, “http://subclipse.tigris.org/update_1.4.x”. Marcamos nuestra nueva fuente y seleccionamos Install. Tendremos que aceptar la licencia del plugin, que se descargará desde la web correspondiente y se instalará automáticamente.

Una vez instalado Subclipse lo primero que tenemos que hacer para comenzar a trabajar con Subversion es abrir la perspectiva SVN Repository Exploring desde Window -> Open perspective -> Other -> SVN Repository Exploring, o bien mostrar la vista de repositorios de SVN haciendo clic sobre Window -> Show View -> Other -> SVN -> SVN Repositories. Para añadir un nuevo repositorio haremos clic con el botón derecho sobre SVN Repositories y seleccionaremos New -> Repository Location, donde introduciremos la URL del repositorio.

Por supuesto si vamos a utilizar nuestro propio repositorio en local tendremos que descargar e instalar el servidor de Subversion primero. Si no tienes experiencia te recomiendo la distribución VisualSVN (Windows) que incluye una herramienta de gestión gráfica que lo hace todo muy sencillo.

Una vez añadido nuestro repositorio podemos hacer un checkout del código almacenado en él haciendo clic con el botón derecho sobre él y seleccionando Checkout, añadir un proyecto ya existente a un repositorio haciendo clic con el botón derecho sobre el proyecto y seleccionando Team -> Share Project, hacer un commit haciendo clic con el botón derecho sobre el proyecto y seleccionando Team -> Commit, … Como vemos, todo muy rápido y sencillo, y sin tener que abandonar por un momento nuestro IDE.

Veamos los pasos a seguir para lograr esta interacción.

1. Descargamos Eclipse desde su página web. La versión que nos interesa, dado que vamos a desarrollar con JEE, es la llamada Eclipse IDE for Java EE Developers (163 MB)
2. Descargamos y descomprimimos el zip de la última versión core de Tomcat.
3. Iniciamos Eclipse. Nos dirigimos a Window -> Preferences -> Server -> Runtime Environment, pulsamos Add y seleccionamos nuestra versión de Tomcat. Marcamos Create a new local server si no está seleccionado.
4. Pulsamos Next y buscamos el directorio en el que instalamos Tomcat. Pulsamos Finish y OK. El nuevo servidor debería mostrarse en la pestaña Servers. También se habrá creado un proyecto nuevo Servers con los archivos de configuración de nuestra instancia de Tomcat.
5. Ahora vamos a probar el servidor creando una pequeña aplicación web. Seleccionamos File -> New -> Dynamic Web Project, rellenamos el nombre que queramos darle a la aplicación y pulsamos Finish.
6. Hacemos clic con el botón derecho sobre la carpeta WebContent de nuestro nuevo proyecto y seleccionamos New -> JSP. Le damos como nombre index.jsp y pulsamos Finish. No necesitamos hacer nada más, puesto que el descriptor de despliegue que se crea por defecto ya indica que index.jsp es uno de los welcome-file.
7. Sustituimos el contenido de index.jsp por el siguiente, que debería mostrar la cabecera User-Agent, con la información del navegador

<html>
<body>
Tu navegador es <%= request.getHeader("user-agent") %>
</body>
</html>

8. Arrastramos el proyecto desde el explorador de proyectos al servidor Tomcat en la pestaña Servers para asociarlo.
9. Hacemos clic con el botón derecho sobre el servidor y seleccionamos Start.
10. Abrimos la página http://localhost:8080/nombre_aplicacion/. Si todo ha funcionado correctamente deberíamos ver nuestro user-agent en pantalla
11. Desarrollamos nuestra aplicación usando JSP, Servlets, JDBC, Hibernate, o cualquier otra tecnología que nos interese.
12. Una vez terminada la aplicación solo resta crear un archivo WAR para poder distribuirla fácilmente. Hacemos clic con el botón derecho sobre nuestro proyecto, seleccionamos Export -> WAR File, e introducimos el nombre a utilizar y la ruta en la que queramos guardar el WAR.

El plugin necesario para desarrollar en C/C++ con Eclipse se llama CDT (C/C++ Development Tooling). Veamos como instalarlo.

Instalar Eclipse

El primer paso, evidentemente, es instalar Eclipse. Eclipse viene en forma de un archivo zip/tar.gz que podemos descargar desde la sección correspondiente de su web pulsando sobre Eclipse SDK 3.2.1 y eligiendo el mirror más cercano al lugar donde nos encontramos.

Una vez descargado basta con descomprimir en el directorio de nuestra elección.

Instalar CDT

Descargamos la última versión para nuestro sistema operativo, la 3.1.1 a la hora de escribir estas líneas, desde la página de descargas del proyecto. El plugin no es más que un archivo zip/tar.gz que deberemos descomprimir en la carpeta de Eclipse, añadiendo así los archivos correspondientes a las carpetas features y plugins.

Si ejecutamos Eclipse ahora entre las perspectivas que podemos seleccionar (Window -> Open Perspective -> Other) tendremos una dedicada a C/C++. Para crear un nuevo proyecto seleccionaremos File -> New -> Managed Make C Project o Managed Make C++ Project dependiendo del lenguaje a utilizar. En los proyectos “managed” (gestionados), a diferencia de los standards, Eclipse se ocupa de generar un makefile por nosotros.

Lo único que nos falta es, claro está, un compilador con el que generar los binarios. En Linux normalmente suelen estar instalados gcc y g++. En Windows necesitaremos instalarlos, bien usando MinGW o usando Cygwin.

Instalar Cygwin

Descargamos el instalador desde la web de Cygwin. Al ejecutarlo nos preguntará si queremos instalar desde internet, descargando los archivos necesarios desde la web (Install from Internet); descargar los archivos pero no instalarlos (Download Without Installing) o instalar usando paquetes previamente descargados que tenemos en una cierta carpeta (Install from Local Directory). Si es la primera vez que instalamos Cygwin, seleccionaremos Install from the Internet.

Se nos preguntará también dónde instalarlo (C:\Cygwin está bien, no queremos rutas que contengan espacios), el directorio donde descargar los paquetes y el mirror desde el que deseamos descargarlos. Por último no tendremos más que seleccionar los paquetes a descargar y pulsar siguiente para que comience la descarga e instalación (si no sabes muy bien lo que vas a necesitar, te aconsejaría que descargaras todos los binarios de la rama Base y Devel).

Una vez instalado, añadiremos el directorio bin de la distribución al path, de forma que se pueda llamar a los binarios desde cualquier carpeta de Windows: botón derecho sobre Mi Pc -> Propiedades, Opciones Avanzadas -> Variables de Entorno, en Variables del sistema hacemos doble clic sobre Path y añadimos al final de Valor de variable ;c:\cygwin\bin (el ; es para separar distintas entradas). Podemos comprobar que lo hemos hecho correctamente abriendo una ventana de línea de comandos (Inicio -> Ejecutar, escribimos cmd) y escribiendo gcc -v.

Instalar Simple Indent

A estas alturas de tutorial ya estaríamos listos para empezar a trabajar con C/C++ en Eclipse, pero para hilar fino vamos a instalar otro plugin que nos permitirá dar formato a los archivos .c, .cpp y .h con un simple Ctrl + F; se trata de Simple Indent. Simple Indent utiliza astyle para formatear el código, así que tendremos que tenerlo instalado en el sistema (no os preocupeis porque viene como parte de Cygwin).

La instalación es tan sencilla como descargar el archivo .jar correspondiente y copiarlo a la carpeta plugins de Eclipse. Una vez que iniciemos el programa podremos seleccionar SimpleCodeFormatter en Windows -> Preferences -> C/C++ -> Code Formatter y cambiar las opciones del programa y la ruta donde encontrarlo en Simple Indent Preferences (como es el estilo al que estoy acostumbrado a mí me gusta tener –style=java, pero entre los predefinidos teneis para elegir ansi, gnu, kr y linux; podeis ver más información escribiendo astyle -h en la línea de comandos).

Programando con C/C++ en Eclipse

Como ya dijimos, para crear un nuevo proyecto en C/C++ en Eclipse seleccionamos File -> New -> Managed Make C Project o Managed Make C++ Project. Solo tenemos que escribir un nombre para el proyecto y podemos pulsar sobre Finish, porque normalmente no necesitaremos tocar ninguna de las otras opciones.

Para añadir un nuevo archivo al proyecto pulsamos con el botón derecho sobre el proyecto y seleccionamos New -> Source File o Header File.

La compilación la realiza Eclipse automaticamente, creando un archivo ejecutable en la carpeta Release o Debug, aunque tendremos que indicarle al linker dónde se encuentran las librerías que va a necesitar haciendo clic con el botón derecho sobre el proyecto, Properties -> C/C++ Build -> Tool Settings -> GCC C Linker -> Libraries y añadiendo el directorio “C:\cygwin\lib\gcc-lib\i686-pc-mingw32\3.3.3″ en Library search path (seleccionamos Debug en Configuration y volvemos a hacer lo mismo).

Visto hace unos días en Download Squad.