Un murciano en el Polo

Lo nuevo de Java 7

2012-02-15T17:00:00.000+01:00

En julio de 2011 Mark Reinhold presentó la primera versión de de Java 7. Entre la versiones 5 y 6 no hubo grandes modificaciones ni del lenguaje ni de la VM pero la versión 7 sí que nos trajo cambios significativos. A la espera que Java 8 vea la luz en Octubre de este año, os presento una lista de 7 cambios de señor Java 7. La lista completa la podéis consultar aquí.

Cadenas en switchs

Si amigos por fin, no entiendo el motivo para no incorporar antes esta característica que tanto he echado en falta en multitud de ocasiones. Antes sólo lo podíamos utilizar con tipos básicos como char, byte, short, int,Character, Byte, Short, Integer o tipo enumerado (desde la versión 5). Ahora nos podemos olvidar de colocar sentencias if-else interminables y las comparación con el método equals de String, teniendo un código mucho más limpio y entendible.

public void testStringSwitch(String direction) {

        switch (direction) {

             case "up":

                 y--;

             break;



             case "down":

                 y++;

             break;



             case "left":

                 x--;

             break;



             case "right":

                 x++;

             break;



            default:

                System.out.println("Invalid direction!");

            break;

        }
    }

Antes cuando definíamos por ejemplo una lista genérica y queríamos instanciarla mediante su constructor debíamos indicar el tipo tanto en el momento de la definición como en el momento de instanciarla dinámicamente. Ahora ya no tendremos que indicarla en el momento de la asignación dinámica (en el constructor) porque se infiere de la definición del tipo.

Antes de Java 7:

List strings = new ArrayList();

En Java 7:

List strings = new ArrayList();

En casos de tipos más complejos puede ser muy útil no repetir de nuevo todos los tipos:

Gestión múltiple de excepciones

Antes teníamos que definir en varias sentencias try-catch el código para crear una instancia por Reflection, crear nuevos recursos como ficheros, etc... Ahora todo esto se puede compactar en una única línea separando las excepciones con el carácter "|".

Antes de Java 7:

try {
    Class a = Class.forName("wrongClassName");
    Object instance = a.newInstance();
} catch (ClassNotFoundException ex) {
    System.out.println("Failed to create instance");
} catch (IllegalAccessException ex) {
    System.out.println("Failed to create instance");
} catch (InstantiationException ex) {
   System.out.println("Failed to create instance");
}

Después de Java 7:

try {
    Class a = Class.forName("wrongClassName");
    Object instance = a.newInstance();
} catch (ClassNotFoundException | IllegalAccessException |
   InstantiationException ex) {
   System.out.println("Failed to create instance");
}

Try-Catch con gestión de recursos

En Java 7 tenemos la posibilidad de gestionar los diferentes recursos (File, Statement, ResultSet, Socket...) mediante sentencias try-catch sin tener que poner la sentencia finally. Dicha sentencia se utiliza para asegurar que se ejecuta un código determinado después de un bloque try-catch, bien se produzcan excepciones o no. Normalmente aquí se cerraban los recursos que abríamos mediante el bloque try-catch, asegurando la correcta gestión de los diferentes recursos.

Antes de Java 7:

try {
            in = new BufferedReader(new FileReader("test.txt"));

            String line = null;
            while ((line = in.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            try {
                if (in != null) in.close();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }

En Java 7:

       try (BufferedReader in=new BufferedReader(new FileReader("test.txt")))
       {
            String line = null;
            while ((line = in.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }

Mejorada la API de IO

Hay varios cambios en el paquete java.nio, sobre todo relacionados con el rendimiento. También se han realizado mejoras del paquete java.io (sobre todo de la clase java.io.File), lo que ha desencadenado que se crease un nuevo paquete (java.nio.file).

Entre las las clases más relevantes de este paquete están:

java.nio.file.Path. Interfaz que sustituye a la clase java.io.File.

java.nio.FileSystem. Para obtener las rutas de los diferentes ficheros.

java.nio.FileSystems. Factoría con la que se puede obtener una instancia de FileSystem mediante el método getDefault().

java.nio.Files. Contiene los métodos estáticos necesarios para las operaciones con ficheros. Por ejemplo, abajo podemos ver como podemos leer todas las líneas de un fichero y guardarlas en una lista mediante el método readAllLines. Con esta clase también podemos crear enlaces simbólicos a ficheros (imposible antes de Java 7). Otra característica que se añade en Java 7 es la posibilidad de establecer permisos de ficheros en una sistema de ficheros compatible con POSIX mediante el método Files.setPosixFilePermissions. Antes de esto sólo se podía haver mediante la interfaz JNI o mediante 'hackeos' con System.exec().

Mediante la API del WatchService también podemos recibir notificaciones sobre diferentes elementos. Por ejemplo, podemos indicar que se nos notifique cuando se creeen ficheros, modifiquen o se borren ficheros en un directorio del sistema de ficheros determinado.

Ejemplo de lectura de fichero con Java 7:

List lines =  Files.readAllLines(
       FileSystems.getDefault().getPath("test.txt"), StandardCharsets.UTF_8);

       for (String line : lines) System.out.println(line);

Soporte para lenguajes no Java (invokedynamic)

En la versión 7 hay una nueva instrucción a nivel de bytecodes llamada invokedynamic. Esta instrucción no podrá ejecutarse desde Java pero será muy útil para los lenguajes dinámicos que corran bajo la JVM.

En un lenguaje con tipado estático como Java todos los tipos de las variables se conocen en tiempo de compilación mientras que en un lenguaje tipado dinámicamente como JRuby, Groovy,... esto no es así.

Cuando en un lenguaje dinámico que corre bajo la JVM invocamos un método de un objeto que desconoce, se invoca ese método a nivel de bytecode mediante la reflection de Java.

A modo de ejemplo, en un lenguaje dinámico llamaríamos al método de un objeto desconocido de esta forma:

def veamos( objeto )

    objeto.salvar()
end

Que en un lenguaje Java sería algo similar a hacer esto:

Method m = objeto.getClass().getMetodo("salvar");

m.invoke( objeto )

Actualmente hay varios tipos de reflexión en Java:

invokevirtual. Para llamar a un método de un objeto.
invokeinterface. Para llamar a métodos de interfaces (objeto debe implementar interfaz).
invokestatic. Para llamar a un método de una clase.
invokespecial. Para llamar a constructores.

Con Java 7 se añade invokedynamic, para llamar a un método de un objeto desconocido. Esto hará que a nivel de bytecode, las llamadas a este tipo de métodos desde otros lenguajes tipados dinámicamente ya no se apoyarán en la reflection de Java, sino en esta nueva instrucción.

Las ventajas de esto es que se mejora el rendimiento a la misma vez que hace que la JVM sea independiente del lenguaje, por lo que aumenta la interoperabilidad entre componentes creados en otros lenguajes y los programas escritos en Java.

JLayerPane

Componente similar a uno proporcionado en el proyecto JXLayer, que sirve para añadir efectos a componentes Swing. JLayerPane permite decorar los componentes gráficos de Swing y añadir eventos a los mismos sin modificar el código de esos componentes.

JLayerPane (Foto: sellmic)

Via: sellmic

Cobol, no recomendado para menores de 50 años

2012-02-10T13:58:00.002+01:00

Por necesidades del proyecto en el que trabajo he pasado del mundo Eclipse, Java, Spring, Hibernate, Maven y Subversion al mundo COBOL/CICS/DB2. ¿Qué si se nota la diferencia? No, no he notado apenas diferencias a la hora de desarrollar (modo ironia ON).

Os daré mi visión general de cómo se desarrolla en este lenguaje y lo compararé con el desarrollo con Eclipse. Esta destinado para que el programador que no tenga ni idea de Cobol pueda hacerse una pequeña idea (Dios mio no siento las piernas!!!). Perdonad todos los coboleros por mis explicaciones de este lenguaje porque no llevo mucho tiempo con él y apenas se hacer nada.

Primer programa

Escribir un programa en Java que escriba 'Hola Mundo' por pantalla es relativamente sencillo. Te creas una clase Java, con un método main y escribes una línea System.out.println ("Hola Mundo"). Luego ejecutas tu mini-programa desde Eclipse/NetBeans con tu JRE y en la ventana Output de Eclipse te sale tu mensajito.

En COBOL, es un poquitín más complicado. Para comenzar tiene un entorno de desarrollo más tedioso en el que tienes que moverte casi siempre con teclado. Crear, editar, borrar, copiar y pegar programas se hace de forma similar al ultraconocido vi de Unix. Te puedes hacer dos tipos de programa y siempre lo tienes que indicar en la cabecera: ONLINE o BATCH.

ONLINE son programas que se utilizan para interactuar con el usuario. Ejemplo: Se arranca una transacción que arranca el programa A. El programa A envía un mapa (ventana tipo formulario) y termina el programa (aunque no la Tx). El usuario rellena la información y cuando la introduce se vuelve a reanudar la Tx anterior, lanzándose de nuevo el programa A. El programa recibe el mapa y procesa los datos del usuario realizando la lógica oportuna.

BATCH son programas que se ejecutan background sin necesidad de interactuar con el usuario. Se lanzan desde un archivo JCL, que es un archivo en el que se definen una serie de pasos o acciones mediante un lenguaje de script (parecidos a los scripts UNIX). Aparte de lanzar los programas que creamos mediante JCL, normalmente tendremos disponibles una serie de programas útiles que podemos definir en nuestros JCLs para copiar, crear y borrar ficheros, acceder a BBDDs, transformar ficheros, ect...

Al igual que en Java todos son objetos y se ejecutan mediante un entorno controlado que es la JVM, en una máquina Mainframe hay un sistema operativo (ej.: z/OS) que se encarga de lanzar transacciones que se corresponden con la ejecución de uno o más programas realizados en COBOL. Cada Tx. tiene asociada una cola que será la que gestiona la ejecución de esa Tx.

Pienso que la forma más fácil de escribir un 'Hola Mundo' en COBOL es crear un programa BATCH que tenga la estructura básica obligatoria con un párrafo (son como procedimientos o bloqués de código con nombre) que haga un DISPLAY (como el System.out). Luego crearemos un JCL que lance este programa, los submitimos(jaja, ejecutamos vamos) y listo. En definitiva, más líneas de código y dos elementos (JCL y Programa BATCH).

Estructura de programa

Si en un programa Java típico tendríamos clases, cada una de ellas con atributos con tipos determinados y métodos con una interfaz determinada, en Cobol un programa tiene una estructura dividida en secciones obligatoria, cada una de ellas con un fin:

IDENTIFICATION DIVISION, donde se describe el nombre del programa, el autor, fecha creación....

ENVIRONMENT DIVISION. Datos referentes a la máquina donde se escribe el programa. Tiene una subsección llamada INPUT-OUTPUT-SECTION donde se definen por ejemplo los ficheros que se utilizan en el programa y tipos de ficheros.

CONFIGURATION SECTION.

FILE SECTION. Se define el nombre lógico de los ficheros de la INPUT-OUTPUT-SECTION indicando el tipo de fichero, su acceso y la COPY asociada a su estructura.
WORKING-STORAGE-SECTION. Variables de trabajo que utiliza el programa. Se borran una vez que finaliza la Tx. asociada.
LINKAGE-SECTION. Variables que se utilizan para la comunicación con otros programas de otras Tx.

PROCEDURE DIVISION. Se definen los bloques de código de los que consta el programa.

Mientras que en un programa java la información entre un objeto A y otro B se pasaría mediante un mensaje tipo B.metodo(a,b), en COBOL deberíamos rellenar los datos de a y b en la LINKAGE SECTION mediante una copy (EST-AB) y el programa A llamaría al PROGRAMA B mediante la sentencia LINK (misma TX) o XCTL (diferente Tx) indicando la COPY que se utiliza para llamar al programa B (EST-B).

Para la comunicación entre programas también se pueden utilizar las colas. Hay dos tipos de cola, colas TD (que son generales a todos los programas y de solo lectura) y colas TS (que se pueden crear desde los programas y son de lectura/escritura).

Normalmente cuando queremos trabajar con una estructura de datos en un programa COBOL definimos COPYS, que son ficheros en los que se define un conjunto de campos con una longitud y tipos determinados y luego hacemos un INCLUDE de esa COPY en el programa. En Java lo que haríamos sería crear una clase diferente y luego incluir esta clase con una relación de clientela.

Tipos

En Java hay muchos tipos predefinidos en la JRE tipos numericos (int, double, long...), cadenas (String), colecciones (Stack, List, Vector...), recursos (File, Socket,... ) además podemos crear tipos personalizados creando clases.

En COBOL, los campos pueden ser o PIC X (alfanumérico) o PIC 9(numérico) indicando entre paréntesis la longitud que ocupa el mismo.

PIC 9(2). Campo numérico de 2 caracteres.
PIC(X). Carácter alfanumérico.

Simplemente esto, aunque se pueden crear tipos numéricos comprimidos (COMP-3), formateados (Z), numericos con decimales sin signo y con signo... En general es esto. Las listas de elementos se pueden crear con la palabra OCCURS:

01 ESTRUCTURA_PROGRAMA.

05 CAMPO-LISTA OCCURS 4 TIMES.

10 CAMPO1 PIC X.

10 CAMPO2 PIC 9.

CAMPO-LISTA es una lista de 4 elementos formados por campo1 y campo2.

Entorno de desarrollo

Hay múltiples entornos de desarrollo en Java (IDE, NetBeans, Intelligent Idea, JBuilder...). En COBOL desconozco si hay muchos o pocos y lo que se puede hacer con cada unos de ellos, aunque me imagino que todos serán similares. Aquí tenemos uno en el que se puede:

Crear, modificar y borrar fuentes Cobol y mapas. (¿Eclipse? ¿UltraEdit?, ¿dónde estáis?, os necesito). Mucho teclado y teclas F1..F12, como los frikis.

Realizar la compilación de fuentes y mapas. Compilar es fácil pero compilar un programa sin errores es tarea harto difícil. Si acabarás de conocer al compilador de COBOL se presentaría diciéndote: 'Hola soy el compilador de COBOL y te voy a joder la vida...'. Se queja hasta por la columna en la que defines una sentencia. Es muy importante que cada sección y cada sentencia esté en su sitio, obligando al programador a dejar todo atado y bien atado.

Utilidades para la gestión de ficheros.

Utilidades para el manejo de DB2. Bendito TOAD, cuanto te echo de menos!!!

En general los fuentes COBOL están en librerías, mientras que los fuentes java se encuentran en paquetes. Agrupaciones lógicas al final. Cuando se compilan los fuentes Java se generan .class que pueden empaquetarse en .JAR. En COBOL cuando se compilar los fuentes, copys, mapas, rutinas, ect.. se crean ficheros con todo el código linkado y se dejan el librerías especiales para que luego puedan ser ejecutadas correctamente.

Ficheros

Utilizar un fichero en código Java es muy sencillo. Con una línea de código podemos comenzar a leer o escribir de un fichero:

BufferedReader in = new BufferedReader(new FileReader("foo.in"));

Sin embargo en COBOL tenemos que hacer varias cosas:

Primero tenemos que definir el tipo de ficheros y nombre lógico en el programa en la ENVIRONMENT-SECTION.

Tenemos que asignar la estructura del fichero (mediante una copy por ejemplo) y asignarla al fichero, además de indicar el tipo de fichero en la sección DATA-DIVISION.

Definir los ficheros (de entrada o salida) en el JCL que lance el programa que utiliza los ficheros. Aquí es donde se indicará la ruta física de los ficheros.

Hay varios tipos de ficheros: aleatorios (acceso aleatorio), secuenciales (acceso secuencial) y ficheros VSAM (acceso por clave). En programas BATCH se puede acceder a todos los tipos de ficheros mientras que en programas ONLINE se suelen utilizar sólo los VSAM. Además, a los ficheros VSAM se accede de forma diferente desde programas ONLINE y BATCH.

Bases de datos

En Java se utilizan los drivers JDBC para acceder a todas las diferentes bases de datos. Se accede mediante un objeto DataSource pasando una cadena de conexión de una BBDD o mediante JNDI obteniendo un DataSource desplegado en un servidor de aplicaciones.

El acceso de los programas COBOL a BBDDs se resume a DLI y DB2.

DLI es una ¿base de datos? jerárquica. Es bastante antigua. Se divide de forma jerárquica (árbol) donde cada nodo hoja es un segmento. Cada segmento contiene una información determinada y tiene un nodo padre menos el nodo raíz. Para acceder a una información puede que tengamos que recorrer varios segmentos antes de llegar a ella.

DB2. Otra base datos bastante antigua.

Desarrollo gráfico

En entorno Java hay muchos frameworks para desarrollar aplicaciones gráficas tanto web como de escritorio (JavaFX, JSF, GWT, ZK... ). Dichos frameworks permiten realizar ventanas complejas con una gran diversidad de controles gráficos diferentes.

En COBOL, las aplicaciones gráficas están basadas en pantallas de 24 líneas de 80 caracteres y no hay más (el CICS).

Hay herramientas para definir las etiquetas y campos de los mapas y definir en qué posición va cada cosa. La comunicación con los programas se realiza mediante colas y COMMAREAS y con las sentencias SEND / RECEIVE.

Definición de mapa COBOL

Control de versiones y pases a producción

En desarrollo Java (y en cualquier lenguaje) normalmente hay un programa de control de versiones (SourceSafe, CVS, Subversion, GIT...) para controlar las diferentes versiones de la aplicación que estamos generando, coordinar los cambios de todos los programadores y saber quién ha hecho qué cosa y cuándo. También suele existir una herramienta de integración continua (CruiseControl, Hudson, Jenkins...) que se encarga gestionar todo el ciclo de vida de las aplicaciones, desde empaquetado de la aplicación hasta su despliegue en los diferentes entornos.

En CICS, al menos aquí, no hay control de versiones. Hay entornos y se hacen copias de seguridad de todos los elementos del código en producción. Si estás en desarrollo puedes meter la mata y perder alguna que otra hora de trabajo.

Conclusiones

En definitiva, aunque COBOL (Common Business Oriented Language) se creó en 1959 y se haya sustituido en muchos casos por entornos PCs con aplicaciones visuales, todavía sigue teniendo buena salud en entornos bancarios. Se creo en una época en que la compatibilidad entre los diferentes sistemas no era la mejor y tenía una característica clave para su éxito, era fácil de entender programas codificados en COBOL hasta para una persona que no era programadora. Hoy en día por ejemplo, se sigue utilizando hasta en un 70% de las transacciones del Reino Unido.

Salu2. Jose.

Frases de cine, televisión y libros

2012-01-28T21:53:00.001+01:00

Hoy os pongo algunas frases de alguna película, libro o serie de televisión que me han gustado durante este periodo de Navidad.

La primera es de la película Los Descendientes, película que por cierto os recomiendo encarecidamente, de las mejores que he visto en el último año. George Clooney hablando de sus hijos: "Hay que darle a los hijos lo suficiente para que hagan algo en la vida, pero no tanto para que no hagan nada"

Cartel de la película Los Descendientes

La segunda es de la serie Cuentame, del episodio de la semana pasada. Paquita le contaba al cura del pueblo sus penas porque su padre la había abandonado y se había ido a Benidorm y este le responde: 'Conforme nos hacemos mayores más pensamos en nosotros mismos y menos en el prójimo, pues vemos más cercana la muerte'.

La tercera y última es del libro Los girasoles ciegos, de la segunda historia. Es un poema que escribe un padre que huye de la Guerra Civil Española, refugiándose en las montañas asturianas:

'Un lobo le dijo a un niño

que con su carne tierna iba a pasar el invierno

EL niño le dijo al lobo que sólo comiera una pierna

porque siendo aún tan tierno

iba a necesitar muy pronto que estuviera bien cebado

porque llegaríaun momento, en que, aunque cojito,

necesitaría un asado de lobo como alimento.

Se miraron, se olisquearon y sintieron tanta pena

de tener que hacerse daño,

que se pusieron de acuerdo para repetir la escena

evitándose el engaño de que

para sobrevivir dos personas que se quieran

sea siempre necesario que,

al margen de sus afectos, unos vivan y otros mueran'

(Y como corolario:)

Ambos murieron de hambre.

Salu2.

Soluciones Alchemy Classic 442 elementos

2012-01-28T11:41:00.002+01:00

Después de la resaca navideña y de la cuesta de enero, volvemos para informar la agradable sorpresa que nos ha dado a los fans de Alchemy Classic la empresa NIASOF, tras actualizar el juego Alchemy Classic.

Una nueva versión con 442 elementos, interfaz mejorada de grupos y lo más importante, nuevos elementos que descubrir.

La gran novedad de esta actualización son los puntos que tienes asignados, con los que puedes conseguir pistas sobre los elementos que no has abierto todavía como:

Conseguir un subelemento de un elemento, con 100 puntos.

Conseguir el grupo de un subelemento de un elemento (qué lío , jeje), con 35 puntos.

Me gusta, me gusta el enfoque de esta nueva versión aunque los elementos que han sacado me parecen poco originales. Parece que se van agotando las ideas para los elementos nuevos.

Aquí van las soluciones:

Carbon = Tierra + Turba

Sol = Estrella + Tierra

Espacio = 3 x Estrella

Estrella = Helio + Hidrógeno

Oso Panda = Oso + Bambú

Girasol = Sol + Flor

Animales de pezuña hendida = Mamíferos + Calzado antiguo

Renos = Ciervos + Frío

Elefantes = Mamíferos + Manguera

Rumiantes = Animales de pezuña hendida + Hierba

Tiburón martillo = Tiburones + Herramientas

Ciervos = Animales de pezuña hendida + Cuerno

Motor a reacción = Motor de combustión interna + Fuegos Artificiales

Astrolabio = Reloj mecánico + Estrella

Cable = Cobre + Cuerda

Caja Fuerte = Contenedor + Monedas

Esquís = Calzado antiguo + Nieve

Estufa = Piedra + Fuego + Carbon

Fuegos artificiales = Mecha + Pólvora

Mapa Estelar = Mapa + Estrella

Mecha = Cuerda + Pólvora

Monedas = Forjar + Oro

Panel Solar = Sol + Pila

Patines antiguos = Calzado antiguo + Huesos

Planisferio = Mapa estelar + Astrolabio

Telescopio = Estrella + Catalejo

Yunque = Acero + Herramientas

Ábaco = Monedas + Madera + Huesos

Banco = Edificio incompleto + Caja Fuerte

Forjar = Edificio incompleto + Estufa + Yunque

Fábrica de comida = Estufa + Edificio incompleto + Harina

Invernadero de naranjas = Cristal + Edificio Incompleto + Flores

Panadería = Estufa + Edificio incompleta

Planetario = Mapa estelar + Edificio incompleto

Planta de energía solar = 3 x Paneles Solares

Avión = Motor de combustión interna + Ornitoptero

Avion Jet = Avion + Motor a reacción

Carro = Rueda + Madera

Ornitoptero = Mecanismo incompleto + Pájaros

Planeador = Ornitoptero + Aire

Trineo = Esquís + Carro

Caramelo = Ázucar + Fábrica de comida

Semillas de Girasol = Girasol + Herramientas

Adornos de año nuevo = Coníferas + Cristal

Calcetines de Navidad = Ropa + Árbol de Navidad

Calcetines de Navidad con Ceniza = Calcetines de Navidad + Ceniza

Calcetines de Navidad con Regalos = Calcetines de Navidad + Caramelo

Cometa = Aire + Serpientes

Cuerno = Vino + Animales Fósiles

Globo = Goma + Helio

Guirnalda = 2 x Bombilla Incandescente + Cable

Osito de Peluche = Árbol de Navidad + Oso

Renos de Navidad = Trineo + Renos

Arbol de Navidad = Adornos de año nuevo + Coníferas

Arbol de Navidad con guirnalda = Árbol de Navidad + Guirnalda

Teoría de la relatividad (for dummies)

2011-12-14T16:00:00.000+01:00

La física es una materia que siempre me ha interesado. Me encantaba encontrarme en exámenes con problemas de distancias recorridas por balas o calcular la fuerza con que se atraen dos cuerpos o dos cargas, sobre todo cuando al final de los problemas me salía un número dividido por 0, :(.

En aquella época para mí el espacio y el tiempo eran absolutos y la ecuación que relacionaba ambas magnitudes era velocidad=espacio/tiempo. Einstein era un tipo con el pelo blanco que había metido los dedos en un enchufe y que salia en una foto sacando la lengua, pero ignoraba la importancia y magnitud de sus descubrimientos.

Albert Einstein

Relatividad de Galileo

El concepto de relatividad lo introduce por primera vez Galileo. Según este principio la velocidad de un objeto es relativa al observador y se calcula como la suma algebraica de velocidades, dependiendo del sistema de referencia que se adopte. Ejemplo:

Imaginemos un tren a 100 km/h y un pasajero sentado en él. ¿A qué velocidad se mueve el tren para el pasajero? Para él, el tren no se mueve porque el pasajero se mueve junto al tren.

¿Y para un pasajero que ve el tren desde un anden acercarse por la izquierda? Para esa persona el tren se movería a 100 km/h.

Si el pasajero se levanta y comienza a andar a 5km/h hacia la derecha (en sentido a la dirección del tren). ¿A qué velocidad se movería el pasajero del tren con respecto al del anden? Pues a 105 km/h ¿Y si se mueve en sentido contrario? Pues entonces se movería a 95km/h

Los sistemas en los que las velocidades de sus componentes permanecen constantes se llaman sistema inerciales.

Física antes de Einstein

A finales del siglo XIX la física se sustentaba sobre dos grandes pilares: los principios de la cinemática y dinámica establecidos por las leyes de la Mecánica Clásica de Newton y las obsevaciones del campo magnético y eléctrico condensadas por Maxwell en la Teoría del Electromagnetismo. Según Maxwell tanto el campo magnético y eléctrico se desplazaban en el espacio en forma de ondas y la velocidad de esas ondas era igual que la de la luz. Según estas ecuaciones, la velocidad de las ondas era independiente del observador y del foco que emite las ondas, así que algo no cuadraba con la ley de la Mecánica Clásica de Newton, ambas teorías chocaban.

Como las ondas necesitaban un medio físico para desplazarse (las ondas de sonido necesitaban el aire), llegaron a la conclusión que las ondas de luz también necesitaban un medio para desplazarse. A dicho medio se le llamó 'ETER' y se llegó a la conclusión que llenaba todo el espacio vacío del Universo. Para probar la existencia de este medio invisible, los señores Michelson y Morley realizaron un experimento consistente en emitir haces de luz en el sentido del movimiento de la tierra y otros en otras direcciones. Los haces de luz en dirección al movimiento de la Tierra deberían desplazarse más rápido, pero observaron que todos los haces de luz se movían a la misma velocidad sin importar la dirección.

Lorentz presentó unas ecuaciones según las cuales el espacio y el tiempo se contraían o expandían dependiendo del movimiento, pero no encontró ninguna interpretación física para este hecho.

Teoría de la Relatividad Especial

Fue Albert Einstein en 1905 quien encajó todas estas piezas en la Teoría de la Relatividad Especial, utilizando para ello las ecuaciones matemáticas de Lorentz. Según su teoría:

La velocidad de la luz es constante sin importar la fuente que la emitió (ignorando los principios de la ley de la Mecánica Clásica). Nada puede ser más rápido que la velocidad de la luz.

El tiempo y el espacio son relativos. Según la velocidad a la que el observador mida el espacio o el tiempo obtendrá un resultado u otro.

Energía y masa son equivalentes, es decir, se puede transformar masa en energía. E=mc2. Esto también contradecía las leyes de la Mecánica Clásica de Newton. Este postulado está demostrado hoy en día, pues sabemos que un cuerpo con masa en reposo puede transformarse en energía mediante fisión nuclear (bomba atómica), fusión nuclear y creación y aniquilación de materia.

En nuestro mundo de bajas velocidades no podemos observar como los objetos se encogen y el tiempo pasa más lento, porque las velocidades que podemos alcanzar están muy lejos de la luz. Pero si la velocidad de la luz fuera de 100km/h, podríamos observar todos estos fenómenos perfectamente. Podríamos ver como los coches se encogen a 90km/h y como el tiempo pasa más lento para un pasajero dentro del coche.

Aquí os dejo un video divulgativo que explica todo esto:

Según todo esto tendremos que la suma relativa de dos velocidades es:

u = v + w / (1 + ((v * w) / c2)), siendo igual al modelo de Newton para velocidades bajas

Ejemplo:

Si voy en una nave a 0,9c y disparo una bala dentro de la nave a 0,9c, según la teoría de Newton la velocidad de la bala sería 1,8c pero esto no pueder ser. Aplicando la fórmula de Einstein:

u = 0,9c + 0.9c / 1 + (1'8c2 /c2) = 1,8c / 1,81 = 0,994 c (no llegamos a velocidad de la luz)

Si ocurren dos sucesos en un tiempo t en un sistema de referencia, en otro sistema de referencia con velocidad V el tiempo t' se medirá de la siguiente forma:

t' = t / raiz cuadrada(1-V2/c2)

Ejemplo: Paradoja de los gemelos

Si dos gemelos se separan y uno viaja en una nave (por ejemplo el Halcón Milenario) por el espacio a 0,9c durante 1 año y el otro se queda en tierra, cuando vuelva de su viaje habrán pasado para su hermano:

t' = 1 / raiz cuadrada ( 1 - 0,81) = 1 / 0,435 = 2,29 años

Lo mismo ocurre para la longitud de los objetos que viajan a velocidades cercanas a la luz:

L' = L * raiz cuadrada(1-V2/c2)

Ejemplo:

Si vamos en una nave de 30 metros de longitud a velocidad 0,9c y un observador nos ve desde fuera, la longitud de la nave que mediría es:

L' = 30 * raiz cuadrada(1 - 0,81) = 13,07 metros

Teoría de la Relatividad General

La Teoría de la Relatividad Especial solo era válida para sistemas inerciales. Lo que hizo Einstein en 1915 fue ampliar su teoría para sistemas acelerados (incluyó la gravedad) en lo que se conoce como Teoría de la Relatividad General. Las matemáticas de esta teoría son bastante más complejas. Esta teoría afirma que:

La gravedad o atracción entre dos cuerpos con masa es consecuencia de la curvatura del espacio. Es decir, el sol curva el espacio alrededor de la Tierra para que ésta gira alrededor suyo.

La fuerza que sentimos al frenar en un sistema acelarado (frenar un coche) tiene la misma naturaleza que la fuerza de atracción entre masas.

Según Newton si el Sol desapareciese, la Tierra y todos los planetas saldrían de sus órbitas con un lapso de tiempo 0. Según Einstein no, porque tardaría lo mismo la gravedad que la velocidad de la luz en dejar de actuar sobre los planetas. Me gusta mucho este video divulgativo, que explica como se produciría una ola gigante en el espacio curvo hasta llegar a la Tierra, momento en el cual saldríamos disparados en una órbita recta:

Por último os dejo una explicación de Carl Sagan sobre la cuarta dimensión que me parece interesante:

Referencias: wikibooks | astroverada | portalplanetas | biblioteca digital

Estadísticas Internet 2011

2011-12-12T16:30:00.000+01:00

MarketShare es una web especializada en publicar datos estadísticos sobre cómo navegan las personas en Internet, es decir, qué sistemas operativos se utilizan, con qué buscador se realizan más búsquedas o qué navegador abren cuando quieren visitar las diferentes páginas web. Recopilan datos de más de 40000 webs diferentes intentando realizar el muestreo de la forma más representativa posible. La proporción de cada uno de los tipos de webs donde se recopilan datos es:

43% son webs de comercio electrónico
29% se clasifican como otros (gobiernos, organizaciones, marketing de buscadores,etc...)
18% son webs corporativos
10% son webs de contenido

Vamos a realizar un extracto de los sistemas operativos que se utilizan, los navegadores y buscadores tanto en el ámbito de sobremesa/portátiles como en el de los móviles/tables en el año 2011 hasta noviembre.

Ordenadores sobremesa y portátiles

El sistema operativo utilizado por la mayoría es Windows, con un 92,23%. Le siguen muy de lejos Mac y Linux con un ligero aumento durante el 2011. En el mundo Windows, el más utilizado sigue siendo Windows XP seguido de Windows 7 y Windows Vista. Destacar la subida de Windows 7 durante el año, más de un 10%.

En el apartado SSOO el dominador Internet Explorer con un 52,64%, seguido de Mozilla FireFox con un 22,14% y Google Chrome con 18,18%. IE y Mozilla han bajado durante el año mientras que mi querido Google Chrome ha subido un 7%, :).

El buscador más utilizado sigue siendo Google, con un apabullante 83,38%. En segundo lugar está Yahoo con un 6,19% y Baidu con un 4,41%. Bing no llega al 4% en cuarta posición.

Estadísticas 2011 uso de sistemas operativos

Estadísticas 2011uso sistemas operativos por versiones

Estadísticas 2011 uso de navegadores

Estadísticas 2011 uso de navegadores por versiones

Estadísticas 2011 de uso de buscadores

Móviles y tablets

El dominio de Microsoft en móviles no existe, siendo el sistema operativo más utilizado para navegar iOS con un 54,04%. De esta forma, se mantiene otro año más como el favorito por los internautas para navegar con el móvil. Le siguen JavaME (19,69%) y Android (16,72%) que sube. El barco de Symbian se hunde con un 5,27%.

Tras la bajada de la navegación con iPhone y la subida con el iPad, la navegación con los gadgets de Apple se equilibra con un 26,71% y 24,91% respectivamente. Destacar la subida del nuevo Android 2.3 hasta el 8,53%.

En cuanto a navegadores Safari se mantiene como el más utilizado (55,03%), seguido de Opera Mini (20,09%) y Android Browser que sube hasta 16,36%. Symbian también baja colocándose en cuarto lugar con un 3,03%. Safari 5.0 y el nuevo Safari 5.1 son las versiones más utilizadas seguidas de Android Browser 4.0.

El dominador de las búsquedas en dispositivos móviles es también Google, con un 90,98%. Le siguen muy muy lejos Yahoo, Baidu y Bing.

Estadísticas 2011 uso de sistemas operativos

Estadísticas 2011uso sistemas operativos por versiones

Estadísticas 2011 uso de navegadores

Estadísticas 2011 uso de navegadores por versiones

Estadísticas 2011 de uso de buscadores

Salu2.

¿Es mejor apostar en unos sorteos qué en otros?

2011-12-04T23:35:00.001+01:00

Ya estamos en el mes de la lotería de Navidad, uno de los sorteos más famosos por su carácter popular y por las fechas en las que se celebra. Los españoles invertimos mucho dinero y sueños en dicho sorteo pero, ¿Por qué jugamos más a unos sorteos qué a otros? ¿Es mejor jugar a unos determinados sorteos que a otros? ¿Por qué?

Para todas estas preguntas existe una respuesta, la esperanza matemática (no confundir con probabilidad).

La esperanza de una variable aleatoria X (variables cuya valor se determina mediante el azar) que formaliza la idea de valor medio de un fenómeno aleatorio (un sorteo por ejemplo). Para una variable discreta se calcula como la suma de cada suceso aleatorio por la probabilidad de que ocurra.

Hablando en cristiano, la definición de esperanza en el ámbito de los sorteos sería la relación que existe entre lo que podemos ganar o perder y la probabilidad de ganarlo o perderlo.

Ejemplos de juegos

Por ejemplo, imaginemos un juego en el que ganamos 20 euros por acertar el número de un dado y cada apuesta vale 1 euro.

E = P(acertar) x 20 + P(fallar) x -1 = 1/6 x 20 - 5/6 = 15/6 = 2,5

Este juego es cojonudo porque la esperanza es mayor que uno, es decir, por cada euro que invertimos tenemos la esperanza de ganar 2,5.

Ahora imaginemos la ruleta americana. En este juego se paga 35 euros a 1 por acertar el número, teniendo 38 números la ruleta. Si la apuesta vale 1 euro:

E=P(acertar) x 35 + P(fallar) x -1 = 1/38 x 35 - 37/38 = -0.0526

Este juego es desfavorable para el jugador, porque por cada euro que apostemos perderemos unos 5 céntimos. Si fuera favorable estarían los casinos llenos.... y arruinados...

Por último, imaginemos el juego de ganar un euro por acertar la cara o cruz de una moneda. La apuesta vale un euro:

E=P(acertar) x 1 + P(fallar) x -1 = 1/2 - 1/2 = 0

Este sería un juego justo, puesto que la esperanza es 0, ni ganamos ni perdemos.

¿Y los sorteos más famosos?

Este año en la Lotería de Navidad hay más números que el año pasado (100.000 vs 85.000) aunque para compensar este año los premios son mayores (400.000 vs 300.000). A pesar de todos estos cambios no es peor jugar al sorteo de Navidad del 2011 que al 2010, porque la esperanza es la misma. ¿Por qué? Porque el 70% de la recaudación se destina a premios igual que el año pasado, por tanto, la esperanza es de 0,7. Esto quiere decir que por cada 100 euros invertidos se recuperaran 70. Esto claro está se puede calcular. Si vemos la tabla de premios:

Premios Loteria Navidad 2011

Para calcular la esperanza sumamos las probabilidades de todos los casos que se pueden producir cuando compramos un décimo por la ganancia o pérdida del suceso:

E = P(Primer Premio) x Ganancia Primer Premio + P(Segundo Premio) x Ganancia Segundo Premio + P(Cuarto Premio) x Ganancia Cuarto Premio + ...... + P(Fallar) x Pérdida por Fallo = 1/100.000 x 400.000 + 1/100.000 x 125.000 + 2/100.000 x 20.000 + .... + 99.999/100.000 x -20 = -15

Lo que quiere decir que por cada décimo de loteria de 20 euros recuperaremos 15 euros. Está claro que unos lo harán y otros no, hablamos globalmente entre todos los participantes.

En otros sorteos como la Primitiva o el Euromillón esto es diferente, puesto que en este tipo de sorteos el Bote se suma a lo recaudado por los participantes, es decir, lo que se reparte en premios es diferente cada semana.

Por ejemplo sabemos que el Euromillon reparte el 50% de lo recaudado en premios y la Primitiva el 55%. Por tanto la esperanza de ambos sorteos es de 0,5 y 0,55 respectivamente.

Lo bueno es que en estos sorteos hay botes. Así que la esperanza subirá cuanto más bote haya. En general, la esperanza será mayor que uno cuando el 50% o 55% de lo recaudado más el bote del sorteo sea mayor que lo que vale comprar todos los boletos de los sorteos con todas las combinaciones posibles. Esto es muy raro que pase.

Por ejemplo, si tengo más dinero que un torero y compro todos los boletos del Euromillon con todas las posibles combinaciones me gasto 152.550.720 euros.

Boletos posibles = C (50,2) * C(9,2) = 76.275.360

Precio para comprarlos = 152.550.720 euros

Para que la esperanza sea mayor que 1, el 50% de lo recaudado más el bote debería ser mayor a 152.550.720 euros.

Lo bueno de estos sorteos es que tienen bote pero la esperanza la conocemos a posteriori. Merece la pena jugar cuando hay un bote muy alto, cuanto más alto más esperanza. Para la Loteria de Navidad sabemos la esperanza a priori y nunca llegará a 1, por lo que será siempre desfavorable para el jugador.

Mucha suerte a todos!!!

Salu2.

Referencias: Estadística para todos | Microsiervos

Ejemplo logback

2011-11-30T18:59:00.004+01:00

El otro día os hablaba de las bondades de logback. Como ya os dije, SFL4J es una capa de abstracción para nuestros sistemas de logging (similar a JCL) que liga una implementación concreta en el momento de la compilación. Logback es una implementación concreta de SFL4J, pero podemos utilizar SFL4J con diversas librerías de logging como log4j o java.util.logging.

En el siguiente gráfico vemos un dibujo sacado de la documentación oficial de SFL4J en el que se muestran varios escenarios de uso de SLF4J:

Escenarios de uso de SLF4J

En la gráfica podemos varios escenarios:

En el primer escenario (SLF4J unbound) no se liga ninguna implementación de SLF4J, por lo que no se escribe log. Sólo tendremos el jar slf4j-api.jar.

En el segundo escenario (SLF4J bound to logback-classic) ligamos logback a SLF4J. Esto lo explicaremos más adelante en nuestro ejemplo.

En el tercer escenario (SLF4J bound to log4j) ligamos log4j a SLF4J. Migrar de una aplicación en la que tenemos log4j y JCL es sencillo. Se puede hacer manualmente o mediante SLF4J Migrator. En ambos casos las librerías se deben incorporar a mano en nuestra aplicación y son slf4j-api.jar y slf4j-log412.jar. La librería log4j también debería estar en nuestro classpath.

En el cuarto escenario (SLF4J bound to java.util.logging) ligamos java.util.logging a SLF4J. Para ellos utilizamos el jar slf4j-jdk14.jar y el sistema de logging que contiene la JVM.

El sexto escenario se utiliza cuando queremos que una aplicación que escribe log no lo escriba. Se liga a una implementación que no escribe log (o lo envia a /dev/null). Para ello como siempre necesitamos el jar slf4j-api.jar y como binding el slf4j-nop.jar.

Me he puesto manos a la obra y he utilizado logback en una aplicación que se expone como servicio web. A continuación vemos los pasos más importantes. El proyecto lo he realizado con Eclipse 3.3 y el plugin WST instalado:

Creamos una aplicación web con Eclipse. En dicha aplicación una clase Java (en el paquete es.jpascu) será la implementación de un servicio web con Axis 1.4. Ver mi post anterior de creación de servicios web con Axis en Eclipse.

En la implementación del servicio web y en las clases donde queramos que se escriba log importamos estas dos clases:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

Después nos definimos un Logger en cada una de ellas:

final Logger logger = LoggerFactory.getLogger(MiWs.class);

Luego escribimos varias sentencias de log por el código con varios niveles de log como log.debug("Mensaje"), log.info("Mensaje") y log.error("Mensaje")... Eso a nuestra elección...

Después incluimos las librerías de SLF4J (slf4j-api-1.5.11.jar) y logback (logback-classic-1.0.0.jar y logback-core-1.0.0.jar) como veíamos en el escenario 2 de la imagen de arriba:

Librerías de aplicación web con WS Axis y logback

Un tema importante es el caso de librerías de terceros que utilizan otro sistema de log, como ejemplo Axis 1.4 que utiliza JCL junto con log4j. Para utilizar este tipo de librerías (por eso he hecho el servicio web, para utilizar Axis) debemos incluir una librería que nos haga de puente para este tipo de aplicaciones y eliminar el commons-logging de nuestro classpath si estuviese. En nuestro caso, el jar puente es jcl-over-slf4j-1.5.11.jar (último escenario de la imagen de arriba).

Por último, nos quedaría añadir a nuestro classpath el fichero de configuración de logback. El fichero puede ser lo complejo que queramos y podemos añadir muchas características de logback (jmxConfigurator, MDC, nuevos appenders...). Si queréis podéis consultar la documentación de SLF4J. Yo os pongo un fichero sencillito que configura un file appender con un filtro de mensajes de nivel INFO, 300 días de historia y 5 líneas en los mensajes de trazas. Vosotros podéis ir añadiendo lo que queráis para probar las diferentes características de logback:


 
 
  
   INFO
  
  
   rutaDirectorioLog/aplicacion.log
  

  
  
   
    %date %-5level %logger{20} - %message%n %exception{5}
   
  

  
   
    /opt/bea/weblogic92/aplicaciones/logs/internacionalGBC/internacionalGBC.log.%d{yyyy-MM-dd}.log
   
   
   30
  
 


 
  
   
    %date{HH:mm:ss.SSS} %-5level %logger{10} - %message%n

Espero haber ayudado a integrar logback en vuestras aplicaciones.

Salu2.

JAXB: Leer y escribir ficheros XML

2011-11-24T21:00:00.001+01:00

Muchas veces en nuestras aplicaciones debemos manejar documentos XML (Extensible Markup Language). Este lenguaje se ha convertido en un estándar para intercambio de datos entre programas y aplicaciones a través de Internet. En un esquema XML (o XSD) podemos definir los elementos que pueden aparecer en un documento XML así como las relaciones entre los mismos.

JAXB (Java Architecture for XML Binding) es un estándar Java para transformar un esquema XML (o XSD) en una representación a objetos java. Mediante la API de JAXB podemos mapear un objeto Java a un documento XML ("marshall") y el proceso contrario, es decir, a partir de un esquema XML crear su conjunto de objeto Java asociado ("unmarshall").

JAXB

Resumiendo lo que nos proporciona JAXB es:

Generación de objetos Java a partir de un XSD a través de un compilador

Proporciona capacidades de marshall/unmarshall (escribir fichero XML desde java y al contrario)

Integración con Maven a través de xjc (desde Java 1.6)

Validación de nuestro documento XML a partir de un XSD

Existen otras herramientas para manejar XML desde Java como por ejemplo Xstream. Mi amigo y compañero el señor Fuente lo explica perfectamente en un tutorial. Depende de los requisitos de nuestro proyecto deberíamos utilizar una u otra herramienta, puesto que cada una tiene sus ventajas e inconvenientes. Con Xstream no se pueden generar clases Java a partir de un esquema de datos dado y con JAXB sí. Sin embargo, Xstream es más sencillo de utilizar y las clases del modelo que se mapean a/desde XML no necesitan añadir etiquetas adicionales (pueden ser simples beans).

A continuación os voy a poner unos ejemplos con JAXB. Los ejemplos los he realizado con Eclipse 3.6 (Helios) y Java 1.6. En esta versión se incluyen las capacidades de JAXB (es una ventaja no añadir ninguna librería adicional).

El ejemplo consiste en crear dos entidades Java, Empresa y Empleado. Una Empresa está compuesta por un conjunto de Empleados. Las anotaciones que se utilizan en estas dos clases son las siguientes:

@XmlRootElement(name = "empleado"). Define que el elemento raíz del objeto Java se llamará empleado.

@XmlType(propOrder = { "dni", "nombre", "edad", "puesto" }). Define el orden de los elementos dentro de otro elemento.

@XmlElement(name = "cargo"). Sirve para cambiar el nombre de un elemento en el documento XML. Por defecto el elemento aparece con el nombre del atributo de la clase Java pero podemos cambiarlo con esta etiqueta. En el ejemplo se cambia el nombre puesto por cargo. Se puede utilizar en los atributos tipo lista para indicar cómo se llamará cada elemento de la lista.

@XmlElementWrapper(name = "empleados"). Para crear un wrapper llamado empleados que englobe la estructura XML de los objetos Empleado.

A continuación tenéis el código de la clase Empresa:

package es.jpascu.jaxb;

import java.util.ArrayList;

import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name = "empresa")
public class Empresa {
 private String cif;
 private String nombre;
 private ArrayList empleados;

 public String getCif() {
  return cif;
 }

 public void setCif(String cif) {
  this.cif = cif;
 }

 public String getNombre() {
  return nombre;
 }

 public void setNombre(String nombre) {
  this.nombre = nombre;
 }

 @XmlElementWrapper(name = "empleados")
 @XmlElement(name = "empleado")
 public ArrayList getEmpleados() {
  return empleados;
 }

 public void setEmpleados(ArrayList empleados) {
  this.empleados = empleados;
 }

}

Y el código de la clase Empleado:

package es.jpascu.jaxb;

import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;

@XmlRootElement(name = "empleado")
@XmlType(propOrder = { "dni", "nombre", "edad", "puesto" })
public class Empleado {
 private String dni;
 private String nombre;
 private int edad;
 private String puesto;
 public String getDni() {
  return dni;
 }
 public void setDni(String dni) {
  this.dni = dni;
 }
 public String getNombre() {
  return nombre;
 }
 public void setNombre(String nombre) {
  this.nombre = nombre;
 }
 public int getEdad() {
  return edad;
 }
 public void setEdad(int edad) {
  this.edad = edad;
 }
 @XmlElement(name = "cargo")
 public String getPuesto() {
  return puesto;
 }
 public void setPuesto(String puesto) {
  this.puesto = puesto;
 }
 
 
}

Por último, ponemos el código de una clase de prueba que hace uso de la API de JAXB para rellenar el modelo de objetos Java (empresa y empleados) y crear un XML a partir del mismo. Posteriormente, con el XML guardado en disco, se realiza el proceso contrario, cargar la información del XML en el objeto Empresa. El código lo tenéis aquí:

package es.jpascu.jaxb;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;

public class JaxbTest {
 private final static String XML_EMPLEADOS = "./info-empleados.xml";

 public static void main(String[] args) throws JAXBException, IOException {

  // Primero rellenamos los objetos Java y generamos un XML

  ArrayList empleados = new ArrayList();

  Empleado empleado1 = new Empleado();
  empleado1.setDni("12345678C");
  empleado1.setNombre("Carlos Pérez Ruíz");
  empleado1.setEdad(29);

  Empleado empleado2 = new Empleado();
  empleado2.setDni("87654321C");
  empleado2.setNombre("Claudia Ortiz Zaldo");
  empleado2.setEdad(31);

  Empresa empresa = new Empresa();
  empresa.setCif("A58818501");
  empresa.setNombre("TECNOMUR S.L.");
  empleados.add(empleado1);
  empleados.add(empleado2);
  empresa.setEmpleados(empleados);

  // Creamos el contexto e instanciamos el marshaller
  JAXBContext context = JAXBContext.newInstance(Empresa.class);
  Marshaller m = context.createMarshaller();
  m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
  m.marshal(empresa, System.out);

  Writer w = null;
  try {
   w = new FileWriter(XML_EMPLEADOS);
   m.marshal(empresa, w);
  } finally {
   try {
    w.close();
   } catch (Exception e) {
   }
  }

  // Ahora leemos el XML e instanciamos las clases Java
  System.out.println("Salida desde el fichero XML: ");
  Unmarshaller um = context.createUnmarshaller();
  Empresa empresa2 = (Empresa) um
    .unmarshal(new FileReader(XML_EMPLEADOS));

  for (int i = 0; i < empresa2.getEmpleados().toArray().length; i++) {
   System.out.println("Empleado " + (i + 1) + ": "
     + empresa2.getEmpleados().get(i).getNombre() + " con DNI "
     + empresa2.getEmpleados().get(i).getDni() + " y "
     + empresa2.getEmpleados().get(i).getEdad() + " años");
  }

 }
}

Referencias: Oracle | Vogella

Hacer magia con un Iphone

2011-11-24T15:30:00.001+01:00

El otro día en una de las noticias del telediario de relleno (las mejores) vi a un ilusionista haciendo una presentación con teléfonos móviles, más concretamente 3 Iphones. Hoy leo que este personaje se llama Marco Tempest. Es suizo y aparece en la serie de televisión "The Virtual Magician", serie que se emite en más de 50 países.

Combina la magia tradicional con las nuevas tecnologías (proyecciones de video, Iphones, Ipads...) y como resultado podemos ver actuaciones de lo más divertidas y originales.

Es este video que os pongo mezcla trucos de manos con la tecnología de los IPhone.

Interfaz Comparator. Comparadores en Java

2011-11-23T16:30:00.000+01:00

Cuando trabajamos con las colecciones en Java a veces necesitamos ordenar primero los elementos para luego realizar una determinada acción.

Si trabajamos con objetos o tipos simples como números (java.lang.Number, int) o cadenas (java.lang.String) la ordenación es más fácil. Para ordenar un array de este tipo lo único que tenemos que hacer es utilizar la sentencia siguiente y ya tendríamos nuestro array ordenado:

java.util.Arrays.sort(arrayDeNumeros);

Pero imaginemos ahora que tenemos que realizar una determinada acción sobre un tipo complejo (Persona, Departamento...). Si queremos ordenar un array de objetos complejos debemos decir primero qué criterios de ordenación se deben seguir. ¿Cómo se hace esto? Pues con la interfaz java.util.Comparator.

Hay dos opciones: implementar la interfaz Comparator en la propia clase del objeto que queremos ordenar o bien hacerlo en una clase diferente. La opción más elegante es la segunda, tener clases diferentes que implementen la interfaz Comparator por cada método de ordenación que queremos definir.

Por ejemplo, imaginemos que tenemos una clase llamada Numero que representa los números posibles de un sorteo de lotería. A veces queremos ordenar la lista de números del sorteo por el valor del propio número y otras veces queremos ordenar la lista por la probabilidad con la que hayamos calculado que puede aparecer el número en un sorteo.

El código de la clase Numero es el siguiente:

public class Numero {

 private int numero;

 private int valor;

 private float probabilidad;

 private int numeroSorteos;

 private int tipoItem;

 private float peso;

 private String anillo;

 /**
  * @param numero
  * @param valor
  * @param probabilidad
  * @param numeroSorteos
  * @param tipoItem
  * @param peso
  * @param anillo
  */
 public Numero(int numero, int valor, float probabilidad, int numeroSorteos,
   int tipoItem, int peso, String anillo) {
  this.numero = numero;
  this.valor = valor;
  this.probabilidad = probabilidad;
  this.numeroSorteos = numeroSorteos;
  this.tipoItem = tipoItem;
  this.peso = peso;
  this.anillo = anillo;
 }

 public Numero() {

 }

 public int getNumero() {
  return numero;
 }

 public void setNumero(int numero) {
  this.numero = numero;
 }

 public int getValor() {
  return valor;
 }

 public void setValor(int valor) {
  this.valor = valor;
 }

 public float getProbabilidad() {
  return probabilidad;
 }

 public void setProbabilidad(float probabilidad) {
  this.probabilidad = probabilidad;
 }

 public int getNumeroSorteos() {
  return numeroSorteos;
 }

 public void setNumeroSorteos(int numeroSorteos) {
  this.numeroSorteos = numeroSorteos;
 }

 public int getTipoItem() {
  return tipoItem;
 }

 public void setTipoItem(int tipoItem) {
  this.tipoItem = tipoItem;
 }

 public float getPeso() {
  return peso;
 }

 public void setPeso(float peso) {
  this.peso = peso;
 }

 public String getAnillo() {
  return anillo;
 }

 public void setAnillo(String anillo) {
  this.anillo = anillo;
 }

 @Override
 public boolean equals(Object obj) {
  if (obj == null)
   return false;

  if (!(obj instanceof Numero)) {
   return false;
  }

  Numero item = (Numero) obj;
  if (this.numero == item.numero) {
   return true;
  }
  return false;

 }

 @Override
 public int hashCode() {
  // TODO Auto-generated method stub
  return this.numero;
 }

}

Para crear el comparador que ordena los números por su valor nos creamos una clase que implemente Comparator y sobrescriba el método compare(Object,Object). Este método devuelve un número negativo, cero o un número positivo si el primer argumento es menor, igual o mayor que el segundo argumento. Para ordenar tendremos en cuenta al atributo valor.

El código lo tenéis aquí:

class ItemComparator implements Comparator {

 public void ItemComparator() {
 }

 public int compare(Object arg0, Object arg1) {
  Integer item1 = ((Numero) arg0).getValor();
  Integer item2 = ((Numero) arg1).getValor();  
  return item1.compareTo(item2);
 }

}

Para crear el comparador que nos ordenará la lista de números por probabilidad haremos lo mismo pero esta vez lo que haremos será sobrescribir el método compare(Object,Object) ordenando por el atributo probabilidad.

El código lo tenéis aquí:

class ProbabilidadComparator implements Comparator {
 public ProbabilidadComparator() {

 }

 public int compare(Object arg0, Object arg1) {  
  Float item1 = ((Numero) arg0).getProbabilidad();
  Float item2 = ((Numero) arg1).getProbabilidad();  
  return item1.compareTo(item2);
 }

}

Por último, para hacer la ordenación de nuestro array le pasaremos al método sort de la clase java.util.Arrays la implementación de la clase Comparator que queramos, dependiendo del criterio de ordenación que queramos utilizar.

En el siguiente código ordenamos el array por probabilidad:

...
Arrays.sort(n, new ProbabilidadComparator());
...

Como siempre, espero haberos ayudado con vuestros programas en Java.

Salu2.

La mayoría

2011-11-22T19:00:00.003+01:00

Cada vez que se encuentre usted del lado de la mayoría, es tiempo de hacer una pausa y reflexionar, Mark Twain

JFreeChart. Gráficas en Java

2011-11-22T16:00:00.001+01:00

Hace algunos años buscando una librería Java para mi proyecto de fin carrera encontré JFreeChart. Revisando el proyecto veo que ha seguido siempre activo y se sigue utilizando ampliamente entre la comunidad de desarrolladores.

JFreeChart es una librería Java 100% libre creada por David Gilbert. Sirve para la creación de gráficas profesionales en nuestras aplicaciones Java. Para consultar todos los detalles podéis ir a la página del proyecto.

A continuación vamos a utilizar la librería para crear un gráfico de tipo tarta (pie chart) en el que se muestre el número de escaños de cada partido en las Elecciones Generales de 2011. Vamos a utilizar el IDE Eclipse aunque podemos utilizar cualquier otro.

Lo primero que tenemos que hacer es crear un proyecto Java en Eclipse. Le llamamos por ejemplo jfreechart y creamos un paquete de código fuente que se llame es.jpascu.graficos.

Proyecto en Eclipse

Después descargamos las siguientes librerías de la página de descargas del proyecto jfreechart y las añadimos como dependencias a nuestro proyecto. Las podemos meter en una carpeta llamada lib.

jcommon-1.0.16.jar

jfreechart-1.0.13.jar

Para añadir liberías a nuestro proyecto pulsamos con el botón derecho sobre el proyecto y en la pestaña Libraries de la opción Java Build Path le damos al boton Add JARS.

Añadir dependencias a un proyecto Java

Una vez que hemos creado el proyecto y añadido las dependencias creamos la clase que pintará nuestra gráfica. Este código se puede modificar fácilmente para incluirlo en un servlet o JSP.

El código de nuestra clase quedaría como sigue:

package es.jpascu.graficos;

import javax.swing.JFrame;

import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.PiePlot3D;
import org.jfree.data.general.DefaultPieDataset;
import org.jfree.data.general.PieDataset;
import org.jfree.util.Rotation;

public class PieChart extends JFrame {

 private static final long serialVersionUID = 1L;

 public PieChart(String applicationTitle, String chartTitle) {
  super(applicationTitle);
  // Creamos el conjunto de datos con las votaciones
  PieDataset dataset = createDataset();

  JFreeChart chart = createChart(dataset, chartTitle);
  // Ponemos el gráfico en un panel
  ChartPanel chartPanel = new ChartPanel(chart);
  // Dejamos el tamaño por defecto
  chartPanel.setPreferredSize(new java.awt.Dimension(500, 270));
  // Lo añadimos a nuestra aplicación (PieChart)
  setContentPane(chartPanel);

 }

 /**
  * Creates a sample dataset
  */

 private PieDataset createDataset() {
  DefaultPieDataset result = new DefaultPieDataset();

  result.setValue("PP", 186);
  result.setValue("PSOE", 110);
  result.setValue("CIU", 16);
  result.setValue("IU-LV", 11);
  result.setValue("AMAIUR", 7);
  result.setValue("UPyD", 5);
  result.setValue("EAJ-PNV", 5);
  result.setValue("ERC", 3);
  result.setValue("BNG", 2);
  return result;

 }

 /**
  * Creates a chart
  */

 private JFreeChart createChart(PieDataset dataset, String title) {

  JFreeChart chart = ChartFactory.createPieChart3D(title, // chart title
    dataset, // data
    true, // include legend
    true, false);

  PiePlot3D plot = (PiePlot3D) chart.getPlot();
  plot.setStartAngle(290);
  plot.setDirection(Rotation.CLOCKWISE);
  plot.setForegroundAlpha(0.5f);
  return chart;

 }

 public static void main(String[] args) {
  PieChart demo = new PieChart("Elecciones Generales 2011",
    "Escaños obtenidos por partido");
  demo.pack();
  demo.setVisible(true);
 }
}

Resultado de la ejecución

Tenemos muchas posibilidades. A continuación os pongo un ejemplo con una gráfica de barras en 3D con la comparación entre las elecciones del 2008 y 20012.

package es.jpascu.graficos;

import javax.swing.JFrame;

import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.axis.CategoryAxis;
import org.jfree.chart.axis.CategoryLabelPositions;
import org.jfree.chart.plot.CategoryPlot;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.data.category.DefaultCategoryDataset;

public class BarChart extends JFrame {

 private static final long serialVersionUID = 1L;

 public BarChart(String applicationTitle, String chartTitle) {
  super(applicationTitle);
  // Creamos el conjunto de datos con las votaciones
  DefaultCategoryDataset dataset = createDataset();

  JFreeChart chart = createChart(dataset, chartTitle);
  // Ponemos el gráfico en un panel
  ChartPanel chartPanel = new ChartPanel(chart);
  // Dejamos el tamaño por defecto
  chartPanel.setPreferredSize(new java.awt.Dimension(500, 270));
  // Lo añadimos a nuestra aplicación (PieChart)
  setContentPane(chartPanel);

 }

 /**
  * Creates a sample dataset
  */

 private DefaultCategoryDataset createDataset() {
  DefaultCategoryDataset result = new DefaultCategoryDataset();
  
  result.setValue(186, "PP", "2011");
  result.setValue(110, "PSOE", "2011");
  result.setValue(16, "CIU", "2011");
  result.setValue(11, "IU-LV", "2011");
  result.setValue(7, "AMAIUR", "2011");
  result.setValue(5, "UPyD", "2011");
  result.setValue(5, "EAJ-PNV", "2011");
  result.setValue(3, "ERC", "2011");
  result.setValue(2, "BNG", "2011");
  
  result.setValue(154, "PP", "2008");
  result.setValue(169, "PSOE", "2008");
  result.setValue(10, "CIU", "2008");
  result.setValue(2, "IU-LV", "2008");
  result.setValue(0, "AMAIUR", "2008");
  result.setValue(1, "UPyD", "2008");
  result.setValue(6, "EAJ-PNV", "2008");
  result.setValue(3, "ERC", "2008");
  result.setValue(2, "BNG", "2008");
  
  
  
  return result;

 }

 /**
  * Creates a chart
  */

 private JFreeChart createChart(DefaultCategoryDataset dataset, String title) {

  JFreeChart chart = ChartFactory.createBarChart3D(title, "Partido",
    "Escaños", dataset, // data
    PlotOrientation.VERTICAL, true, // include legend
    true, false);
  CategoryPlot plot = (CategoryPlot) chart.getPlot();
  CategoryAxis xAxis = (CategoryAxis) plot.getDomainAxis();
  xAxis.setCategoryLabelPositions(CategoryLabelPositions.UP_45); // Inclinamos 45 grados las etiquetas del eje X  
  plot.setBackgroundAlpha(0.5f);
  return chart;

 }

 public static void main(String[] args) {
  BarChart demo = new BarChart("Elecciones Generales 2011",
    "Escaños obtenidos por partido");
  demo.pack();
  demo.setVisible(true);
 }
}

Resultado de la ejecución

Por último, otra cosa que nos será útil será guardar la gráfica en un fichero en disco. Con la clase ChartUtilities podemos guardar las gráficas en formato JPG o PNG.

Cuando hemos creado nuestra gráfica (subclase de JFreeChart) la guardamos en disco con el siguiente código:

...
ChartUtilities.saveChartAsJPEG(new File("c:\\tmp\\grafica.jpg"), chart, 500, 300);
...

Si queremos mostrar la gráfica desde un servlet o JSP, sólo tendremos que incluir una etiqueta HTML img con el atributo src a la ruta donde hayamos guardado la imagen.

Espero que toda esta información os haya sido útil.

Salu2.

Referencias: Vogella

Sistema D'Hondt. Fórmula de votación en España

2011-11-21T16:00:00.009+01:00

Aprovechando las recientes elecciones de ayer se me ocurrió investigar sobre el sistema de votaciones en España.

El sistema D'Hont fue el utilizado para repartir los escaños entre los partidos en las elecciones de ayer, sistema en vigor desde 1985 de acuerdo a la Ley Orgánica del Regimen Electoral General (LOREG).

Un video ilustrativo del funcionamiento de este sistema se puede ver en Microsiervos y os lo dejo a continuación:

Entre otros países, se utiliza en Argentina, Austria, Bélgica, Bulgaria, Colombia, Croacia, Ecuador, Eslovenia, España, Finlandia, Francia, Grecia, Guatemala, Irlanda, Israel, Japón,Países Bajos, Paraguay, Polonia, Portugal, República Checa, Suiza, Turquía, República Dominicana, Uruguay y Venezuela.

Tras escrutar todos los votos, se calcula una serie de divisores para cada lista. La fórmula de los divisores es V/N, donde V representa el número total de votos recibidos por la lista, y N representa cada uno de los números enteros de 1 hasta el número de cargos electos de la circunscripción objeto de escrutinio.

Supongamos unas elecciones a las que se presentan cinco partidos, entre los que deben repartirse siete escaños .

	Partido A	Partido B	Partido C	Partido D	Partido E
Votos	340.000	280.000	160.000	60.000	15.000

Debemos dibujar una tabla de 7 filas (escaños) por 5 columnas (partidos). En la primera fila escribimos el número total de votos de cada partido (divisor 1). Como el cociente más alto pertenece al partido A (340.000/1) se lleva un escaño. Se escribe debajo de su columna el siguiente cociente (340.000/2=170000) y los demás valores se bajan igual.

Ahora el cociente más alto pertenece al partido B (280.000/1). Se escribe debajo de su columna el siguiente cociente (280.000/2=140.000) y los demás valores se bajan igual.

La tabla completa del proceso la podéis ver aquí:

	Partido A	Partido B	Partido C	Partido D	Partido E
Votos	340.000	280.000	160.000	60.000	15.000
Escaño 1	(340.000/1 =) 340.000	(280.000/1 =) 280.000	(160.000/1 =) 160.000	(60.000/1 =) 60.000	(15.000/1 =) 15.000
Escaño 2	(340.000/2 =) 170.000	(280.000/1 =) 280.000	(160.000/1 =) 160.000	(60.000/1 =) 60.000	(15.000/1 =) 15.000
Escaño 3	(340.000/2 =) 170.000	(280.000/2 =) 140.000	(160.000/1 =) 160.000	(60.000/1 =) 60.000	(15.000/1 =) 15.000
Escaño 4	(340.000/3 =) 113.333	(280.000/2 =) 140.000	(160.000/1 =) 160.000	(60.000/1 =) 60.000	(15.000/1 =) 15.000
Escaño 5	(340.000/3 =) 113.333	(280.000/2 =) 140.000	(160.000/2 =) 80.000	(60.000/1 =) 60.000	(15.000/1 =) 15.000
Escaño 6	(340.000/3 =) 113.333	(280.000/3 =) 93.333	(160.000/2 =) 80.000	(60.000/1 =) 60.000	(15.000/1 =) 15.000
Escaño 7	(340.000/4 =) 85.000	(280.000/3 =) 93.333	(160.000/2 =) 80.000	(60.000/1 =) 60.000	(15.000/1 =) 15.000
Total de cargos electos	3	3	1	0	0
% votos	40%	33%	19%	7%	2%
% escaños	43%	43%	14%	0%	0%

En las leyes electorales se fijan un porcentaje mínimo de votos, tal que si los partidos no superan el umbral quedan excluidos en el ámbito de la circunscripción (provincia, municipio...). A este porcentaje se le suele denominar porcentaje de exclusión y no es parte del sistema D'Hondt. En las Elecciones Generales de ayer, el porcentaje era de un 3% mientras que en las Elecciones Municipales es de un 5%.

Reparto de escaños

¿Por qué hay 350 escaños en el Congreso de los Diputados? La asignación de número de escaños que corresponden a cada provincia en las elecciones generales al congreso está regulado por el Capítulo III del Título II de la Ley Orgánica 5/1985, de 19 de junio, del Régimen Electoral General. Esta misma ley es la que determina el número de senadores de cada provincia.

En España hay cincuenta provincias y dos Ciudades Autónomas (Ceuta y Melilla). A cada provincia le corresponden dos escaños fijos y uno a cada Ciudad Autónoma, con lo que fijos ya hay repartidos 102 escaños. Los 248 restantes se asignan según la población. A mayor población en una provincia, más escaños a repartir. Por ejemplo Salamanca 4 escaños, Jaén 6 , Ceuta 1 y Madrid 35.

A Ceuta, por ser Ciudad Autónoma y pocos habitantes, la Ley Electoral le otorga un simple escaño a repartir. Por ello todos los votos que reciben los partidos que no ganan en esa circunscripción no valen para nada.

En Burgos por ejemplo, en las elecciones de ayer, tres escaños han sido para el PP y 1 para el PSOE. El resto de partidos no han obtenido ningún escaño, por lo que votos a esos partidos no tendrán ninguna representación.

¿Pensáis que esta ley es justa para todos los partidos? ¿Creéis que es justo que algunos partidos no tengan representación aunque hayan obtenido un número significativo de votos (sucede en provincias que no tienen un número muy grande de escaños asignados)? ¿No sería más justo que el número de escaños dependiese de los votos totales?

Referencias: Microsiervos | Wikipedia | Mosquitero

Configurar programas inicio Windows

2011-11-19T20:07:00.001+01:00

Hoy voy a explicar un truco para que todos podamos configurar los programas que se inician en nuestro ~~querido~~ Windows. Normalmente todos nosotros vamos instalando programas y programas y llega un día en el que no sabemos ni lo que hay en nuestro ordenador. De esto nos damos cuenta cuando un día lo encendemos y cuando ha arrancado nos ha salido barba, por lo que nos enfadamos más que la vena del cuello de María Patiño.

En fin, vayamos al truco. Los pasos para controlar lo que se inicia son:

Vamos al botón Inicio y pulsamos Ejecutar.

En la ventana que nos aparece tecleamos msconfig y pulsamos Aceptar.

En la nueva ventana vamos a la pestaña Inicio y desmarcamos los programas que no queremos que se ejecuten al iniciar Windows. Nos encontraremos con muchos procesos que no sabemos ni a qué aplicaciones corresponden. Otros serán más fáciles de identificar.

Configurar programas inicio

Para finalizar hacemos click en Aceptar y después en Reiniciar o Salir sin reiniciar. Para confirmar los cambios realizados se debe reiniciar.

En la siguiente tabla os muestro algunos de estos programas y la aplicación a la cual

corresponden:

ELEMENTO DE INICIO	APLICACIÓN
Ares	Ares
msmsgs o msmsgrs	Messenger
uTorrent	uTorrent
igfxtray	Proceso para permitir configuración gráficos
igfxpers	Proceso para permitir configuración gráficos
jusched	Actualizaciones de Java
BTTray	Proceso para permitir configuración Bluetooth

Espero haberos hecho la vida más fácil.

Salu2.

Programas para redimensionar imágenes. Image Resizer Power Toy

2011-11-17T19:44:00.002+01:00

A veces necesitamos modificar el tamaño de las imágenes que tenemos a más resolución o menos, dependiendo de nuestra necesidad en cuestión .

Por ejemplo, imaginemos que hemos realizado una serie de fotos de un evento y queremos subirlas a un nuevo album de Picassa o de Facebook pero a una menor resolución de la existente porque ocupan demasiado tamaño. O bien tenemos una foto que queremos colgar en nuestra web pero está a muy baja resolución y la queremos aumentar. Para realizar todas estas tareas podemos utilizar el Gimp o Photoshop, que tienen la opción de Escalar una Imagen con diferentes métodos para obtener una mayor o menor calidad.

Escalar imagen con GIMP

Existen otros muchos programas con los que puedes realizar esto de una forma sencilla. Un programa que me ha gustado mucho para redimensionar imágenes es Image Resizer Power Toy de Microsoft. Este programa se integra con los menus del propio Windows. Si seleccionamos una o varias imagenes con el Explorador de Windows y pulsamos con el botón derecho del raton, nos aparece el menú contextual con la opción Resize Pictures.

Menú contextual Image Resizer

Si hacemos click nos aparece una ventana en la que tenemos la opcion de redimensionar las imagenes seleccionadas a varios tamaños predefinidos (Small, Medium,...) o personalizado.

Redimensionar imagene con Image Resizer Power Toy

También existen otros programas como:

VSO Image Resizer. Parecido al Image Resizer Power Toy. No se integra con los menus. Es muy sencillo y es gratuito. Sólo para Windows.

Fast Stone Photo Resizer. Gratuito y sólo para Windows.

Imaginer Photo Enlargement. Desde 29,95 $. Sólo para Windows.

Resize Me. Desde 19,95$. Sólo para Mac.

David’s Batch Processor. Gratuito bajo licencia de código abierto GPL. Para Windows, Mac y Linux.

Salu2.

Referencias: Xataka Foto

Tableizer. Tablas en Blogger.

2011-11-17T09:03:00.001+01:00

Somos muchos los blogueros que utilizamos Blogger. Todos los que lo utilizamos, hemos sufrido alguna vez el tener que insertar tablas, que no es especialmente fácil con el editor de Blogger.

La opción más extendida es ir a la pestaña de Edición de HTML y crearla mediante las etiquetas HTML <table>, <tr> y <td>, tuneandola si se quiere con estilos CSS. Un ejemplo de como se hace esto se puede ver aquí.

Otra opción que descubrí hace poco es utilizar Tableizer. En esta web existe un campo donde podemos pegar nuestras tablas procedentes de Excel y Open Calc (hojas de cálculo) y nos permite transformarlas en código HTML que podemos utilizar posteriormente en Blogger. Se pueden configurar opciones como el color del encabezado, el tamaño y el tipo de fuente de la tabla. También se puede ~~copiar~~ de alguna página en HTML una tabla, pegarla en Excel y generar el código con Tableizer.

Espero que os sirva de ayuda para vuestros posts.

Salu2.

SuperTruper, una aplicación para comparar precios

2011-11-15T18:33:00.005+01:00

El otro día estaba hablando con un compañero de trabajo sobre aplicaciones que no estuvieran hechas todavía, que fueran originales y que cubrieran alguna necesidad de nuestra sociedad.

En estos tiempos de crisis que nos toca vivir, a mí se me ocurrió una genial idea que seguro os gustará a todos. Le dije a mi colega que podíamos hacer una aplicación en la que todos los usuarios puedan ir introduciendo los precios de los diferentes productos en diferentes supermercados. En esta aplicación se podrían consultar los precios de artículos o productos en diferentes establecimientos comerciales. De esta forma, podríamos elegir donde queremos ir a hacer la compra para ahorrarnos unos eurillos. Por supuesto, la aplicación también debería permitir hacer nuestra lista de la compra para saber en qué establecimientos nos saldría más barato comprar en ese preciso momento.

Por ejemplo, imaginemos que queremos comprar una serie de productos de limpieza. Con nuestra maravillosa aplicación haríamos la lista y nos damos cuenta que en el Carrefour están más baratos porque existen una serie de ofertas en esa gama de productos. Sin dudarlo, iríamos al Carrefour a realizar nuestra compra. Después de soltarle todo el sermón, mi compañero me contestó: ~~Gañán~~, esto ya lo han hecho y se llama SuperTruper.

Esta noticia me dejó un poco desilusionado, sin embargo, la descargué del Android Market (también disponible para IPhone) para ver mi sueño reflejado en mi móvil. A continuación os hago un análisis de la misma así como algunos aspectos que en mi opinción se podrían mejorar.

Cuando ejecutas la aplicación nos aparece una pantalla en la que podemos realizar la búsqueda de los artículos.

La búsqueda se puede realizar de dos formas:

Capturando el código de barras. Pulsamos el botón Capturar código y colocamos el móvil para que procese el código de barras del artículo en cuestión. Una vez que lo reconoce te aparece una lista con el precio del artículo en diferentes supermercados.

Introduciendo el nombre del artículo. En el campo de búsqueda introducimos el nombre del artículo. Cuando hacemos esto nos aparece una lista de productos relacionados con el término que hemos introducido y tenemos que elegir uno de ellos. Haciendo esto nos saldría la misma pantalla que en el caso anterior.

Si pulsamos el botón en el que aparece una serie de rayas horizontales, a la izquierda de Listado de Precios nos aparece una gráfica de la trayectoria del precio del artículo en cuestión en los diferentes supermercados:

En la lista de precios de un artículo, si pulsamos el botón de Sugeridos, nos aparecerán productos relacionados con el que tenemos seleccionado. Por ejemplo, en la botella de medio litro de Font Vella nos aparecerá la botella de 33CL, la de 1 L, la garrafa de 6,25L…

Una vez que hemos seleccionado un artículo podremos añadirlo a nuestra lista. Podemos crear una serie de listas de la compra y darle el nombre que queramos. Para crear una lista pulsamos la pestaña de Listas. Una vez allí pulsamos el botón Menu, le damos al botón de Añadir Nueva Lista y creamos una nueva lista.

Una vez que tenemos nuestra lista creada, podremos buscar artículos y añadirlos. En mi caso, he añadido dos artículos a la lista de bebidas. Para añadir un artículo debemos pulsar el botón Añadir Lista en la pantalla del artículo seleccionado y nos aparece una lista desplegable con todas las listas que hemos creado. Una vez en la lista, podemos aumentar el número de ítems que queremos comprar. En nuestro caso, he puesto 6 unidades de un brick de leche de 1L.

Y por fin el momento que todos esperábamos. Pulsamos Calcular compra y nos hace una comparativa de donde podemos ir para que nos cueste más barato.

Para ir construyendo la aplicación entre todos, en la pestaña de TRUPER hay un botón para añadir nosotros mismos los artículos escaneando el código de barras de los artículos.

Para compartir un producto, pulsamos el botón Compartir Producto y rellenamos los datos del producto, código EAN (código de barras), la foto y el nombre del artículo.

Conclusiones

La idea de la aplicación está muy bien aunque todavía parece que está verde en la carga de datos de artículos. En mi opinión hay varios aspectos que podrían mejorar notablemente.

El primero es que el precio parecer ser que no depende de la ciudad. Está claro que el precio de los artículos no es el mismo en una ciudad como Madrid que en Murcia (te avisan de esto en la pestaña de TRUPER). Otra cosa que no me queda muy claro es que cuando queremos introducir un artículo no nos deja introducir ni precio, ni ciudad, ni supermercado. Y por último, podría indicar los artículos que están en oferta en un supermercado en concreto, por ejemplo, mediante una icono pequeño con una estrella.

Esperemos que estos aspectos puedan mejorar en una version futura.

Varios ficheros configuración Spring

2011-11-11T12:23:00.002+01:00

Cuando comencé a trabajar con Spring, normalmente utilizaba un único fichero de configuración para definir los objetos de negocio (beans), los data sources, recursos de otros frameworks (struts, quartz). Esto no está mal para pequeños proyectos pero puede ser un caos mantener el fichero de configuración de Spring en proyectos de mayor tamaño donde pueden intervenir un gran número de desarrolladores y comprender un fichero de configuración puede convertirse en un infierno.

Mantener la configuración en varios ficheros hace que:

Nuestro diseño sea modular
Favorece la reutilización entre diferentes proyectos basados en Spring
Favorece el aprendizaje de los nuevos miembros de un proyecto

Hay dos formas de configurar Spring con varios ficheros:

Utilizar máscaras. Tenemos varios ficheros que comienzan con el prefijo applicationContext-. En el fichero web.xml de nuestra aplicación web debemos añadir las siguientes líneas:

      
  contextConfigLocation/WEB-INF/spring/applicationContext-*.xml

Utilizar los nombres de los ficheros separados por comas. En el fichero web.xml de nuestra aplicación web debemos añadir las siguientes líneas:


      contextConfigLocation/WEB-INF/spring/applicationContext-beans.xml,
            /WEB-INF/spring/applicationContext-datasources.xml,
            /WEB-INF/spring/applicationContext-resources.xml

Espero que la información os sea útil para incorporarla en vuestros proyectos.

Salu2.

Una pregunta complicada

2011-11-10T13:08:00.003+01:00

Hoy leo en Microsiervos una pregunta que al parecer hace unas semanas el profesor Richard Wiseman lanzó en su blog.

Pregunta del millón

La traducción viene a ser algo como: Si elegimos una respuesta al azar, ¿cual es la probabilidad que sea correcta?

Son muchas las respuestas que se han dado a esta pregunta. A mi la que más me convence es la siguiente vista en Gaussianos aunque no sé con certeza si tiene razón o no.

El 50% de las veces elegiré la respuesta 25% que es incorrecta.

El 25% de las veces elegiré 50% que es incorrecta.
El 25% de las veces elegiré 60% que es incorrecta.
Ergo, el 100% de las veces elegiré una respuesta incorrecta.

La probabilidad de elegir una correcta es del 0%

La lanzó a todos los matemáticos y mentes pensantes, ¿cual es la solución correcta?

Salu2.

Manual Tortoise

2011-11-09T14:10:00.003+01:00

Subversion es una herramienta libre bajo licencia Apache/BSD y es desarrollado por Collabnet. Una de las características más importantes que tiene Subversion es que sus revisiones son atómicas, es decir, que todo el proyecto se guarda con un nuevo número de revisión a diferencia de CVS que creaba una nueva revisión por cada archivo.

TortoiseSVN es un cliente gratuito de código abierto para el sistema de control de versiones Subversion. Es decir, TortoiseSVN maneja ficheros y directorios a lo largo del tiempo. Los ficheros se almacenan en un repositorio central. El repositorio es prácticamente lo mismo que un servidor de ficheros ordinario, salvo que recuerda todos los cambios que se hayan hecho a sus ficheros y directorios. Esto permite que pueda recuperar versiones antiguas de sus ficheros y examinar la historia de cuándo y cómo cambiaron sus datos, y quién hizo el cambio.

Como cualquier herramienta de Gestión de la Configuración de Software (SCM), Subversion tiene capacidad de:

Controlar el estado de un producto.

Construir el producto.

Administración del tiempo de desarrollo.

Hacer que el esfuerzo sea conjunto.

La versión utilizada en el manual es la 1.6.

Funciones básicas

Una de las funciones más visibles de TortoiseSVN son los iconos sobreimpresionados que aparecen en los ficheros de su copia de trabajo. Estos te muestran de un vistazo qué ficheros han sido modificados.

Explorador mostrando iconos sobreimpresionados

Normal

Una copia de trabajo recién obtenida tiene una marca verde como sobreimpresión. Esto significa que el estado de Subversion es normal o actualizado del repositorio.

Modified

En cuanto empiece a editar un fichero, el estado cambia a modificado y el icono sobreimpresionado cambia entonces a una marca de exclamación roja. De esta forma puede ver fácilmente qué ficheros se han cambiado desde la última vez que actualizó su copia de trabajo, y que necesitan ser confirmados.

Conflicted

Si durante una actualización ocurre un conflicto, el icono cambia a un signo de exclamación amarillo.

Readonly

Si ha establecido la propiedad svn:needs-lock en un fichero, Subversion establece ese fichero como de sólo-lectura hasta que obtenga un bloqueo en él. Estos ficheros tienen esta sobreimpresión para indicarle que debe obtener un bloqueo antes de que pueda editarlo.

Locked

Si ha obtenido un bloqueo sobre un fichero, y el estado de Subversion es normal, este icono sobreimpresionado le recordará que debería liberar el bloqueo si no lo está utilizando para permitir a los demás que puedan confirmar sus cambios en el fichero.

Deleted

Este icono le muestra que algunos ficheros o carpetas dentro de la carpeta actual se han marcado para ser eliminados del control de versiones, o bien que falta un fichero que está bajo el control de versiones dentro de una carpeta.

Added

El signo más le indica que el fichero o carpeta está programado para ser añadido al control de versiones.

Ignored

La barra le indica que el fichero o carpeta está ignorado para los asuntos de control de versiones. Esta sobreimpresión es opcional.

Non-version

Este icono muestra los archivos y carpetas que no están bajo el control de versiones pero tampoco han sido ignorados. Esta sobreimpresión es opcional.

Menus contextuales

Todos los comandos de TortoiseSVN se invocan desde el menú contextual del explorador de Windows. La mayoría se ven directamente, cuando hace click con el botón derecho en un fichero o una carpeta. Los comandos disponibles dependen de si el fichero o la carpeta o su carpeta padre está bajo el control de versiones o no. También puede ver el menú de TortoiseSVN como parte del menú archivo del explorador.

Menú contextual para un directorio bajo control de versiones

Autenticación

Si el repositorio al que intenta acceder está protegido por contraseña, aparecerá un diálogo de autentificación.

Diálogo de autenticación

Para recordar el usuario y contraseña y no tener que introducirlos con cada operación realizada con TortoiseSVN debemos marcar la casilla Guardar autenticación.

Copia de trabajo

Para tener una copia de trabajo necesita obtener una URL de un repositorio. Nuestro repositorio tendrá la URL https://server:8443/svn/Repositorio. Seleccione un directorio en el explorador de Windows donde quiera poner su copia de trabajo. Haga click con el botón derecho para mostrar el menú contextual y seleccione el comando TortoiseSVN ->Obtener..., que mostrará el siguiente cuadro de diálogo:

Diálogo Obtener

Si introduce un nombre de carpeta que no aún no exista, se creará un directorio con ese nombre.

Puede elegir la profundidad que desea para la obtención, lo que le permite especificar la profundidad de la recursión en las carpetas hijas. Si sólo desea unas pocas secciones de un árbol grande, puede obtener sólo la carpeta de más alto nivel, y luego actualizar las carpetas seleccionadas de forma recursiva.

Totalmente recursivo

Obtener el árbol entero, incluyendo todas las carpetas hijas y subcarpetas.

Hijos inmediatos, incluyendo carpetas

Obtener el directorio especificado, incluyendo todos los ficheros y carpetas hijas, pero no rellena las carpetas hijas.

Sólo los ficheros hijos

Obtener la carpeta especificada, incluyendo todos los ficheros pero no obtener ninguna carpeta hija.

Sólo este ítem

Obtener sólo el directorio. No rellenarlo con ficheros ni carpetas hijas.

Confirmación de cambios

Enviar los cambios que ha hecho al repositorio se conoce como confirmar los cambios. Pero antes de confirmar tiene que estar seguro de que su copia de trabajo está actualizada. Puede o bien ejecutar TortoiseSVN->Actualizar directamente, o bien ejecutar TortoiseSVN->ComprobarModificaciones primero, para ver qué se ha cambiado localmente o en el servidor.

Cuando confirma ficheros, el diálogo de confirmación sólo le enseña los ficheros que ha seleccionado. Cuando confirma una carpeta el diálogo de confirmación seleccionará los ficheros que han cambiado de forma automática. Si se olvidó un fichero nuevo que haya creado, al confirmar la carpeta lo encontrará.

Si su copia de trabajo está actualizada y no hay conflictos, ya está preparado para confirmar sus cambios. Seleccione los ficheros y/o carpetas que desee confirmar y seleccione TortoiseSVN -> Confirmar.

Diálogo de confirmación

El diálogo de confirmación le mostrará todos los ficheros cambiados, incluso los ficheros añadidos, borrados o no versionados. Si no desea que un fichero cambiado se confirme, simplemente desmarque ese fichero. Si desea incluir un fichero no versionado, márquelo para añadirlo a la confirmación.

Haciendo doble click en cualquier fichero modificado en el diálogo de confirmación, se lanzará la herramienta externa de diferencias para mostrarle sus cambios. El menú contextual le proporciona más opciones, como se ve en la captura de pantalla. También puede arrastrar ficheros desde aquí a otra aplicación, como un editor de textos o un IDE.

Por defecto cuando confirma los cambios, cualquier bloqueo que tenga en los ficheros se libera automáticamente cuando la confirmación tiene éxito. Si desea mantener esos bloqueos, asegúrese de que la casilla Mantener bloqueos está marcada. El estado por defecto de esta casilla se toma de la opción no_unlock del fichero de configuración de Subversion.

Asegúrese de introducir un mensaje de registro que describa los cambios que está confirmando. Esto le ayudará a saber qué ocurrió y cuando según navegue por los mensajes de registro del proyecto en el futuro.

Puede reutilizar mensajes de registro que haya introducido anteriormente. Tan sólo debe pulsar en Mensajes recientes para ver una lista de los últimos mensajes que ha introducido para esta copia de trabajo. El número de mensajes almacenados se puede personalizar en el diálogo de configuración de TortoiseSVN.

Diálogo de progreso de confirmación

Actualización de cambios

Periódicamente, debería asegurarse de que los cambios que hacen los demás se incorporen en su copia de trabajo local. El proceso de incorporar los cambios desde el servidor a su copia de trabajo local se conoce como actualización. La actualización puede hacerse en ficheros sueltos, en un conjunto de ficheros, o recursivamente en jerarquías completas de directorios. Para actualizar, seleccione los ficheros y/o directorios que desee, haga click con el botón derecho y seleccione TortoiseSVN -> Actualizar en el menú contextual del explorador. Aparecerá una ventana con el progreso de la actualización según se ejecuta. Los cambios que los demás hayan hecho se fusionarán con sus ficheros, manteniendo cualquier cambio que haya hecho en los mismos ficheros. El repositorio no se ve afectado por una actualización.

Diálogo de actualización

Cuando se completa la actualización, el diálogo de progreso le muestra un resumen con el número de ítems actualizados, añadidos, eliminados, en conflicto, etc. bajo la lista de ficheros.

El comando Actualizar estándar no tiene opciones y simplemente actualiza su copia de trabajo a la revisión HEAD del repositorio, lo que es el caso de uso más común. Si desea más control sobre el proceso de actualización, debería utilizar TortoiseSVN ->Actualizar a la revisión N. Cada vez que se confirma algún campo en el repositorio se obtiene una nueva revisión del mismo. Esto le permite actualizar su copia de trabajo a una revisión específica, no sólo a la más reciente.

Si desea simplemente una copia local de una versión antigua de un fichero, es mejor utilizar el comando Menú contextual -> Guardar revisión en... desde el diálogo de registro para dicho fichero.

Estado local y remoto

A menudo es muy útil saber qué ficheros he cambiado y también qué ficheros han cambiado y confirmado los demás. Ahí es donde viene bien el comando TortoiseSVN -> Comprobar Modificaciones.... Este diálogo le muestra todos los ficheros que ha cambiado de alguna forma en su copia de trabajo, y además todos los ficheros no versionados que pueda tener.

Si pulsa en el botón Comprobar Repositorio también puede comprobar los cambios en el repositorio. De esa forma puede comprobar antes de hacer una actualización si es posible que haya un conflicto

También puede revertir cambios en ficheros individuales. Si ha borrado un fichero de forma accidental, se mostrará como Falta y puede utilizar la opción Menú Contextual -> Revertir. Los ficheros sin versionar y los ignorados se pueden enviar a la papelera de reciclaje desde aquí utilizando Menú Contextual -> Eliminar.

Comprobar modificaciones

Registro de revisiones (log)

Para cada cambio que haga y confirme, debería proporcionar un mensaje de registro de ese cambio. Así podrá averiguar después qué cambios hizo y por qué, y tendrá un registro detallado para su proceso de desarrollo.

El diálogo de Registro de revisiones recopila todos esos mensajes de registro y se los enseña. La pantalla se divide en tres paneles:

El panel superior le muestra una lista de revisiones donde se confirmaron cambios a los ficheros/carpetas. Este sumario incluye la fecha y la hora, la persona que confirmó la revisión y el inicio del mensaje de registro. Las líneas azules indican que algo se ha copiado a esta línea de desarrollo (quizás desde una rama).

El panel medio le muestra el mensaje de registro completo para la revisión seleccionada.

El panel inferior le muestra una lista de todos los ficheros y carpetas que se cambiaron. como parte de la revisión seleccionada.

Registro de revisiones o log del repositorio

Hay varios lugares desde los que puede mostrar el diálogo de Registro:

Desde el submenú contextual de TortoiseSVN (Mostrar registro).

Desde la página de propiedades.

Desde el diálogo de Progreso después de que termine una actualización. En ese caso el diálogo de Registro sólo le mostrará aquellas revisiones que cambiaron desde su última actualización.

El panel superior tiene una columna Acciones que contiene iconos que resumen qué se ha hecho en esa revisión. Hay cuatro iconos diferentes para cada acción de una revisión del repositorio sobre un fichero.

Navegador de repositorio

A veces necesitará trabajar directamente en el repositorio, sin tener una copia de trabajo. Ésa es la razón por la que existe el Navegador de Repositorios. Igual que el Explorador y los iconos sobreimpresionados le permiten ver su copia de trabajo, el navegador de repositorios le permite ver la estructura y el estado del repositorio.

Navegador de repositorio

Con el navegador de repositorios puede ejecutar comandos como copiar, mover, renombrar...directamente en el repositorio. El navegador de repositorios se parecerá al explorador de Windows, excepto que está mostrando el contenido del repositorio en una revisión concreta en vez de los ficheros de su ordenador. En el panel izquierdo puede ver un árbol de directorios, y en el panel derecho están los contenidos del directorio seleccionado.

En la parte superior de la ventana del visor de repositorios puede introducir la URL del repositorio y la revisión que desea visualizar. Al igual que el explorador de Windows, puede pulsar sobre los encabezados de las columnas en el panel derecho si desea establecer la ordenación. Y como en el explorador hay menús contextuales en ambos paneles.

Resumen funciones Tortoise SVN

COMANDO	EXPLICACIÓN
SVN Commit / SVN Confirmar	Confirma los cambios locales al repositorio
SVN Update / SVN Actualizar	Actualiza en nuestra copia local la última versión de todos los archivos modificados en el repositorio
Revert / Revertir	Deshace los cambios realizados en la máquina local y actualiza los ficheros seleccionados a la última versión del repositorio
Get lock / Obtener bloqueo	Obtiene el acceso exclusivo sobre un fichero(s) del repositorio. El resto de usuarios no podrán sobrescribir este fichero en el repositorio hasta que no hay sido desbloqueado
Get unlock/ Obtener desbloqueo	Desbloquea el acceso exclusivo sobre un fichero(s) del repositorio.
Add / Añadir	Prepara un fichero(s) para ser subido al control de versiones. Es necesario realizar la operación de commit para subir su contenido al repositorio.
Rename/ Renombrar	Renombra un fichero o carpeta en la copia de trabajo local. Es necesario realizar la operación de commit para renombrar el fichero o carpeta en el repositorio.
Delete / Borrar	Borra un fichero o carpeta en la copia de trabajo local. Es necesario realizar la operación de commit para borrar el fichero o carpeta en el repositorio.
Update to revision / Actualizar a la revisión	Actualiza en nuestra copia local a una versión seleccionada de los archivos modificados en el repositorio
Check for modifications / Comprobar modificaciones	Ventana que muestra el estado local y remoto de los archivos del repositorio
Repo-browser / Navegador de repositorios	Ventana en la que se permite interactuar directamente con los archivos del repositorio
Show log / Mostrar registro	Ventana que muestra el histórico de operaciones del repositorio
Export / Exportar	Recupera en un directorio el contenido de la carpeta seleccionada sin los ficheros del control de versiones.
Settings / Configuración	Configuración general del TortoiseSVN

Fechas en Java

2011-11-09T11:16:00.002+01:00

En este pequeño post voy a mostrar algunas trucos básicos para trabajar con fechas cuando estamos programando en Java. Espero que os sean útiles:

Si queremos crear un objeto Date con la fecha actual tenemos que ejecutar la sentencia:

Date fechaActual = new Date();

Si lo que queremos en crear un objeto Date con una fecha determinada, digamos 31/12/2012, podemos utilizar la clase SimpleDateFormat:

SimpleDateFormat formateador = new SimpleDateFormat("yyyyMMdd");
formateador.parse("2012/12/31");

También a veces tenemos que imprimir fechas en un formato determinado. Esto también se consigue mediante máscaras y la clase SimpleDateFormat. Imaginemos que tenemos un objeto Date con la fecha 31 de Diciembre de 2012. Si queremos imprimir por pantalla la fecha en el formato 31-12-2012 podemos utilizar las siguientes sentencias:

SimpleDateFormat formateador = new SimpleDateFormat("dd-MM-yyyy");
System.out.println(formateador.format(fechaObjetoDate));

Si queremos comprobar si una fecha es mayor que otra debemos utilizar el método compareTo:

if (fechaObjetoDate1.compareTo(fechaObjetoDate2) >= 0 ) {
  System.out.println("La fecha 1 es posterior a la fecha 2");
}

Si queremos encapsular la hora y la fecha actual en un mismo objeto podemos utilizar la clase Timestamp:

Timestamp horaFecha = new Timestamp(System.currentTimeMillis());

Otro objeto para trabajar con fechas puede ser el objeto Calendar. Para crear un objeto Calendar con la fecha actual utilizamos la siguiente sentencia:

Calendar calendar = Calendar.getInstance();

A veces lo que queremos es transformar un objeto Date a Calendar. Lo que tenemos que hacer en este caso es convertirlo de la siguiente forma:

Calendar calendar = Calendar.getInstance();
calendar.setTime(objetoDate);

Y en otras ocasiones lo que queremos conseguir es un objeto Date a partir de un Calendar. En este caso lo debemos convertir con las siguientes sentencias:

Calendar calendar = Calendar.getInstance();
calendar.getTime();

Para inicializar un objeto Calendar con una fecha determinada sin utilizar el objeto Date:

Calendar fecha= Calendar.getInstance();
fecha.set(2011, 9, 25); // (Año, Mes, Dia). El Mes es un número menos. Enero=0, Febrero=1...

Para calcular los días transcurridos entre dos fechas podemos utilizar el siguiente método:

public static int diasTranscurridosEntre(Date fechaDesde, Date fechaHasta) {
 long diff = fechaHasta.getTime() - fechaDesde.getTime();
 long dias = diff / (1000 * 60 * 60 * 24);
 return (int) dias;
}

Para sumar un número de meses a una fecha podemos utilizar el siguiente método:

public static Date sumarMesesAFecha(Date f, int meses) {
  Calendar c = Calendar.getInstance();
  c.setTime(f);
  c.add(Calendar.MONTH, meses);  
  return c.getTime();
 }

Para sumar un número de días a una fecha podemos utilizar el siguiente método:

public static Date sumarDiasAFecha(Date f, int dias) {
  Calendar c = Calendar.getInstance();
  c.setTime(f);
  c.add(Calendar.DATE, dias);  
  return c.getTime();
 }

Si tenéis alguna duda sobre fechas en Java o alguna otra cuestión sobre programación podéis expresarla en los comentarios del blog.

Salu2.

Mejores juegos ordenadores antiguos

2011-11-07T13:45:00.001+01:00

Desde mi primer ordenador, un Amstrad CPC 6128 de disco y fósforo verde, han sido muchos los juegos que han visto mis ojos. Juegos de Amstrad, PC, consolas (Nintendo, Sega Master System, PlayStation 2, XBOX 360...), recreativos... Algunos originales, otros divertidos. Para picarte con amigos o estar delante del ordenador en pijama durante todo el día. Personalmente, me gustan mucho más los juegos de antaño, quizá porque fue la novedad o porque soy un clásico. No lo sé. Los maravillosos gráficos de hoy en día a veces pueden ocultar a veces la originalidad de un juego. Por eso, voy a intentar hacer una lista con los juegos que más me han gustado. Los que más me impactaron y me divirtieron. Como todas las listas, son subjetivas, y os puede parecer una lista horrible o maravillosa. Sin más dilación, ahí va la lista:

Sin lugar a dudas en primer lugar está La abadía del crimen. Este juego fue creado por la empresa Opera Soft en 1987, programado por Paco Menéndez y gráficos de Juan Delcán (una maravilla para ordenadores de 8 bits). Está basado en la novela "El nombre de la rosa" de Umberto Eco. El juego comienza Fray Guillermo de Occam y Adso de Melk entrando en una abadía para resolver unos extraños crimenes que están sucediendo. En todo momento debíamos obedecer al abad si queríamos que nuestra barra de obediencia no bajase. A medida que pasaban los días tenías que ir resolviendo el misterio recogiendo objetos (llaves, pergaminos, libros) y haciendo pequeñas misiones (ir a misa, ir a las comidas). Con la ayuda del plano de la abadía y las instrucciones que venían con la revista MicroMania he intentado muchas veces resolver el juego. Cuantas veces me habré perdido el séptimo día intentando encontrar el espejo en el laberinto con la lámpara de aceite. Lo máximo que conseguí fue abrir el espejo pero al final no logré pasarme el final.

Match Day 2. El juego de fútbol por excelencia del Amstrad junto con el Emilio Butrageño. Creado por la empresa Ocean en 1987. Eran 7 jugadores por cada campo. Había una barra de potencia en la que podías controlar la fuerza de disparo y tenía visión lateral (se iba haciendo scroll a medida que ibas avanzando a uno u otro campo). Se podían dar taconazos, centros y cabezazos. Lo mejor de todo es que no había ni Messis, ni Cristiano Ronaldos, todos los jugadores eran igual de buenos o igual de malos. Con mi hermano hubo muchas partidos de tensión y victorias en el último minuto ;.

Maniac Mansion. Creado por la compañia Lucas Film en 1987. Fue una de las primeras aventuras gráficas pioneras. Desde que un meterito llega a la mansión del doctor Fred comienzan a suceder cosas muy extrañas como tentáculos que andan y plantas carnívoras. El jugador controla al protagonista Dave Miller, que debe elegir a dos amigos cada uno con unas habilidades determinadas. El objetivo era liberar a la novia de Dave secuestrada por el doctor Fred. Tenía finales alternativos dependiendo de las acciones que tomabas durante el desarrollo del juego.

Target Renegade. Es este juego se podía jugar de forma individual o dobles, aunque era más divertido jugar con este último modo. El protagonista era un chuleta con gafas con el que repartes a diestro y siniestro. Comienzas en un parking donde unos motoristas y unos pelucas con un martillo te intentan linchar. En la segunda pantalla tenías que recorrer un barrio de prostitutas donde un chulo con una pistola salía ocasionalmente pegando tiros. Si te daba te quitaba una vida entera. En la tercera ibas por un parque en el que había unos paletos con un palo que te intentaban dar de lo lindo. En la última ibas por una calle con tiendas hasta entrar en unos billares. Al final de juego había un animalote forzudo que cuando te enganchaba te hacia el abrazo del oso y te quitaba media vida.

Wonder boy. Un juego arcade muy adictivo en el que tenías que pasar por una serie de niveles para rescatar a tu novia. Y pienso, ¿no habrá un juego el que se la chica la que tenga que salvar a su novio? ¿Todos los programadores de juegos eran chicos? En fin, te enfrentabas a abejas, caracoles, serpientes, murciélagos y habitantes de tribus. Tenías que esquivar fuegos, estalactitas... Podías coger un patín para ir más rápido y la fruta te daba vida y puntos. Rompías unos huevos para coger el patín, el hacha... También te podía salir en algunos un angel guardian o un demonio. El primero te daba vida, el segundo te la quitaba. A mi el segundo nivel de las nubes me resultaba realmente complicado. Al final de todos los niveles te encontrabas con un gigante al que le tenías que dar en la cabeza hasta que volaba su cabeza.

Fernando Martin Basket Manager (conocido familiarmente como Fernando Martín). Creado por Dynamic Software en 1987. Juego de baloncesto uno contra uno en el que podías jugar contra Fernando Martín. Tenía tres niveles de dificultad y constaba de dos partes de 5 minutos cada una. Se podían hacer mates, tapones, triples y tiros de campo, robos de balón y faltas personales. Otro de los juegos que dio lugar a muchas horas con mi hermano...

Livingstone Supongo. Creado por la compañía Opera Soft. Juego muy complicado en el que el protagonista era el reportero sir H. Morton Stanley en su busca del doctor Livingstonecabroncetes que nos tiran cocos, flechas, plantas carnívoras, vagonetas locas, pirañas... Ibamos por ríos, junglas, minas, poblados indios... Teníamos tres armas, el boomerang, la daga, la bomba y también una pértiga para realizar los saltos más complicados. Debíamos combinar bien todos estos elementos para sobrevivir. A veces había que saltar con la pértiga y lanzar una daga en el aire para matar a un nativo. También debíamos fijarnos en el nivel de agua y comida, teníamos que estar más atentos que para pilotar un avión. En la primera parte había que recolectar gemas para posteriormente ofrecerselas en un templo a una sacerdotisa o diosa que nos recompensaba con una danza. En la segunda parte teníamos que encontrar al Doctor. Muy a pesar, nunca llegué al final por el maldito pájaro.

Barbarian. Juego creado en 1987 por Palace Software. Es un juego de lucha uno contra uno. Se puede jugar contra la CPU o contra una persona. La idea era pasar una serie de niveles en los que debías combatir espada contra espada para matar a tus adversarios hasta liberar a la princesa Mariana del mago Drax. Tenía una variedad de golpes con la espada muy amplia y se podían dar patadas y cabezazos. Para matar a un adversario directamente se le podía decapitar, pero en los niveles avanzados era bastante complicado porque se agachaban los jodíos. Muy muy divertido.

Head Over Heels. Creado en 197 por Ocean por el mismo autor que Match Day 2 (Jon Ritman). Controlabamos a dos personajes. Headus Mouthion (Head) y Footus Underium (Heels) son dos espías del Planeta Libertad (Planet Freedom). Son enviados a Blacktooth para liberar los planetas esclavizados de Penitentiary, Safari, Book World y Egyptus, y así poder derrotar al Emperador para prevenir que otros planetas caigan bajo su poder. Capturados y separados, los espías son trasladados a la prisión del cuartel general del Castillo de Blacktooth. Primero deberán escapar. Luego, a través del mercado, deben llegar hasta la estación Lunar (Moonbase), donde podrán usar los teletransportadores para viajar a los planetas esclavizados. Allí deberán localizar y recobrar las coronas robadas. La liberación de los planetas y la derrota del Emperador permitirá a Head y Heels volver al planeta Libertad (Planet Freedom) como héroes. A veces había tantas pantallas y tanto tiempo jugando que no sabías ni donde estabas.

Fantastic Voyage. Creado por la empresa Amsoft. En este juego manejábamos un pequeño hombrecillo que se adentraba en el cuerpo humano para salvarlo de las infecciones. ¿Nunca habéis querido hacer eso? El tema del juego ya lo vimos en la película "El Chip prodigioso". Íbamos recorriendo todas las partes del cuerpo humano hasta encontrar el foco del dolor y la infección y erradicarlo. Había una representación del cuerpo humano en un lateral del juego en la que se nos indicaba donde nos encontrábamos mediante un puntito. También teníamos una barrita que indicaba la temperatura del cuerpo. Entre infección e infección debíamos encontrar todos los fragmentos de la nave para salir del cuerpo. Muy original.

Esta ha sido mi lista con los 10 juegos que me han parecido más adictivos y originales. Me dejo muchos juegos estupendos en el tintero como Trail Blazers, Boulder Dash, Enduro Racer, 3D Grand, Freddy Hardest... Como veis la mayoría son del Amstrad o de Spectrum y sólo uno que jugué en PC, el Maniac Mansion. Espero vuestra lista. ¿Qué juegos cambiaron vuestra vida?

SFL4J y JCL. Estandares de logging

2011-11-04T11:36:00.007+01:00

Desde que comenzamos con el desarrollo de aplicaciones siempre hemos tenido la premisa de evitar las sentencias System.out para depurar nuestro código. Es una buena práctica insertar en el código de nuestras aplicaciones las sentencias apropiadas de log para depurar correctamente los fallos que se puedan producir. En determinadas ocasiones lo ideal será tener un sistema de log que persista los mensajes de logs de nuestras aplicaciones en una base de datos y se comunique con nuestras aplicaciones mediante colas JMS, pero esto es algo más complejo que trataremos en una futura ocasión.

Todos o casi todos los que hemos desarrollado aplicaciones Java hemos utilizado JCL (Java Commons Logging), una capa de abstracción que permite conectar varias implementaciones como log4j o commons loggings. La implementación de log4j se ha convertido en un estandar de facto para realizar el log de nuestras aplicaciones.

JCL permite cambiar la API que vamos a utilizar de forma dinámica en tiempo de ejecución. Esto puede provocar algún que otro problema con los classloaders. Además de este hay otros problemas que seguro que habréis sufrido en vuestros desarrollos como la necesidad de algún appender determinado que no teníamos (alguna vez he tenido que implementar algún appender que rotase por día y por tamaño...)

El sucesor natural de JCL es SLF4J. Al igual que el primero, es una capa de abstracción que permite que utilicemos varias implementaciones (logback, log4j) pero a diferencia de JCL la implementación queda ligada cuando desplegamos nuestra aplicación mediante un JAR puente.

Las mejoras principales al utilizar SLF4J son las siguientes:

Se acaban los problemas con los classloaders, al ligarse la API de implementación estáticamente y no dinámicamente como en JCL.

Trazas con parámetros más sencillas.

Independencia, puesto que puedes añadir múltiples vinculaciones añadiendo un nuevo JAR.

Hoy leo en JavaHispano una noticia sobre logback 1.0, el sucesor de log4j. En el artículo nos muestra un link con las razones de migrar a logback 1.0. Logback es una implementación de SLF4J creada por el mismo autor que log4j Ceki Gülcü. A continuación os enumero una lista de buenas razones para pasarse a logback:

Cambios en caliente desde JMX. Con la clase JMXConfigurator podemos recargar la configuración de logback desde un fichero por defecto, desde un fichero existente o una URL. Podremos modificar la lista de nuestros loggers y sus niveles de log.

Uso de variables en las rutas de ficheros. Ya no tendremos que indicar rutas absolutas para nuestros file appenders.

Filtros. Los filtros no parecen en principio algo fundamental, pero en grandes aplicaciones desplegadas en un entorno de producción nos pueden servir de mucho. Imaginemos que tenemos un terminal bancario en producción y que ocasionalmente ocurre un error. Normalmente el nivel de log en este entorno es de INFO o WARN así que detectar los errores es más complicado. Imaginemos que este error no se puede reproducir en el entorno de validación debido a las diferencias existentes entre ambos entornos. Con log4j, para detectar este problema, debemos bajar el nivel de log a DEBUG e intentar analizar los logs para comprobar que sucede, con el correspondiente impacto en el rendimiento de la aplicación. Sin embargo, con logback podemos crear un filtro para que acepte los logs de DEBUG de un usuario determinado (el encargado de detectar el problema) y siga escribiendo sólo los logs de WARNING o INFO para el resto de usuarios de producción.

RollingFileAppender ha sido mejorado. Muchas veces sólo queríamos mantener los logs de nuestra aplicación durante un año. Ahora configurando nuestro RollingFileAppender con un RollingPolicy podemos indicar mediante la propiedad maxHistory el número de días o meses que queremos mantener nuestros ficheros logs. También nos permite comprimir los ficheros de logs asincronamente para que no afecte al rendimiento con grandes volumenes de datos.

Layout mejorados. Permiten limitar el tamaño de la pila de excepciones en los logs.

Lilith es una aplicación GUI para visualizar los logs de logback tipo Apache Chainsaw. Está preparado para manejar grandes volumenes de datos. También hay un plugin de Eclipse que te permite hacerlo.

El rendimiento es mucho mayor, basándose en log4j, el código ha sido reescrito para en algunos casos ser 10 veces más rápido.

Batería de pruebas más robusta que en log4j.

Posibilidad de configurar logback en XML y también con Groovy.

Documentación muy extensa.

Una de las características nuevas de logback que más me ha gustado y que más he sufrido con log4j es la escritura segura de varios appenders en el mismo fichero. Mediante la propiedad prudent varias instancias de FileAppender corriendo en varias JVMs (por ejemplo en un entorno de cluster) realizaran una escritura segura del mismo fichero de log. La clase FileAppender y todas sus subclases (RollingFileAppender) se pueden recuperar de errores I/O y pueden seguir funcionando sin reiniciar la aplicación.

En los ficheros de configuración podemos emplear condiciones (if-then-else) para realizar pequeños cambios de configuración de logs entre los diferentes entornos que tengamos (desarrollo, test , producción) sin tener que duplicar ficheros.

Las trazas de las excepciones en los ficheros de logs contienen información de los paquetes de las clases. Esto en ocasiones nos puede resultar muy útil porque además de saber qué clases provocan el error, también nos informa de la versión a la qué pertenecen.

Por todas estas razones, creo que deberíamos migrar nuestras aplicaciones a logback. En definitiva, es una versión mejorada de nuestro querido log4j. Podemos utilizar el SFL4JMigrator, herramienta que nos ayuda a migrar nuestras aplicaciones en pocos minutos. Podéis leer un artículo de mi amigo y compañero de batallas el señor Fuente para profundizar más sobre este tema.

Referencias: logback | balteus

Creación de cliente WS con Eclipse

2011-11-03T14:27:00.002+01:00

En el post anterior habéis visto como se crea un WS con Eclipse. En este, explicaremos cómo crear un cliente Java sencillo para invocarlo a partir de su fichero WSDL.

Al igual que en el caso anterior, supondremos que tenemos instalado en nuestra máquina el Eclipse 3.3 con el plugin WST (Web Service Tools). Hay varias formas de crear un cliente de un WS.

Creación de WS a través de la URL del fichero WSDL

Lo primero que tenemos que hacer es crearnos un proyecto simple Java en Eclipse. Para ello, pulsamos File > New > Project. Una vez hecho esto pulsamos sobre Java > Java Project.

Al hacer esto nos aparece un asistente en el que rellenamos los datos de nuestro proyecto como el nombre o la versión de la JRE que queremos utilizar. Llamaremos al proyecto SumaWSClient y utilizaremos la JRE 1.5.

Pulsamos el botón Next y a nos aparece la ventana para añadir paquetes de código fuente y añadir librerías. En nuestro no tenemos que hacer nada y pulsamos directamente Finish:

Ya tenemos nuestro proyecto Java. Ahora lo que tenemos que hacer es crear las clases cliente que nos ayudarán a invocar nuestro WS.

Imaginemos que tenemos nuestro WS desplegado en la siguiente ruta local http://localhost:8080/SumaWS/services/OperacionCalculadoraWS?WSDL. Podemos saber la ruta de nuestro WS si abrimos el WSDL y nos vamos al final al elemento address.

Para crear las clases clientes del WS pulsamos con el botón derecho sobre el proyecto SumaWSClient. En la ventana emergente pulsaremos sobre la opcion New > Other. Se nos abre un asistente en la que tendremos que seleccionar la opción Web Service > Web Service Client y pulsar sobre Next.

En el campo Service definition introducimos la URL del WSDL (http://localhost:8080/SumaWS/services/OperacionCalculadoraWS?WSDL). El nivel de generación de clases cliente del WS lo dejamos como esté (en mi Eclipse es Deploy client) y pulsamos Next.

En la siguiente ventana del asistente debemos completar la ruta donde queremos que se generen nuestras clases cliente. Lo dejamos todo como está por defecto y pulsamos Finish.

Nuestro proyecto quedaría de la siguiente forma:

En el primer circulo señalado en rojo vemos que se han generado nuestras clases clientes del WS. En el segundo circulo vemos que como en el caso de creación del WS se han añadido automáticamente las librerías de Axis para la invocación correcta de nuestro WS.

Para la invocación de nuestro WS creamos una simple clase main con el siguiente código y ya tenemos nuestro cliente funcionando:

package es.jpascu.calculadora;

public class Test {

 /**
  * @param args
  */
 public static void main(String[] args) throws Exception {
  OperacionCalculadoraWSProxy proxy = new OperacionCalculadoraWSProxy();
  proxy.setEndpoint("http://localhost:8080/SumaWS/services/OperacionCalculadoraWS");
  System.out.println("Suma = " + proxy.suma(99, 99));
 }

}

Creación de WS a través del fichero WSDL

Otra forma de crearlo muy similar a la anterior es a partir del fichero WSDL físicamente en nuestro fichero. Podemos descargar el fichero WSDL a nuestro disco y guardarlo dentro de nuestro proyecto Java.

Luego hacemos click con el botón derecho sobre el WSDL y pulsamos la opción Web Services > Generate Client. Esto nos crearía las clases cliente y añadiría los JARs de AXIS como en el caso anterior.

Espero que os hayan resultado útiles ambos tutoriales. Como veis son sencillos y prácticos. Desde luego no sólo existe Axis para crear WS. Se pueden crear también con Spring-WS, JAX-RPC, XFire, JbossWS... Todas ellas con sus ventajas e inconvenientes, pero eso será en otro artículo.