Güevoneando en Java

Nuevo proyecto

2011-04-04T09:56:00.004+02:00

He comenzado un nuevo proyecto con unos compañeros de trabajo, en una de nuestras conversaciones de comida hablábamos de que existe una gran cantidad de recursos en la web que hablan sobre programación, sin embargo son menos los que lo hacen en castellano. Así que nos hemos puesto de acuerdo para crear un blog que se pretende ser un centro de divulgación de los diferentes aspectos que hay alrededor de la ingeniería del software. La idea es que haya artículos de diferente naturaleza, siendo algunos de ellos más prácticos y otros más teóricos, algunos más subjetivos y otros más objetivos. Cualquier colaboración o propuesta acerca de los contenidos que os interesaría ver en este blog, serán bienvenidos.

Mi intención no es abandonar este blog en favor del otro, si no más bien publicar en ambos sitios los mismos artículos, pero con la ventaja de tener dos "ventanas" al mundo.

Ahora mismo estamos buscando colaboradores, si te sientes con ganas de aportar algo interesante, hazlo saber, entra en http://www.sobreprogramacion.com y opina, pregunta o aporta lo que consideres oportuno sobre programación e ingeniería del software.

HTML5

2010-09-13T01:42:00.008+02:00

Esta es una entrada breve. Llevo tiempo intentando prepararme para la entrada inminente del HTML5, el futuro de internet (espero) que tiene cosas muy interesantes como el canvas y tags de video y audio. Una web multimedia sin complicados scripts ni plugin adicionales.

Bueno, pues hoy he descubierto http://www.html5test.com/ una web que realiza un test de compatibilidad de tu navegador con HTML5. Bueno, como no, aqui el resultado :

El orden de los navegadores es (de izquierda a derecha, primera fila primero): Chrome 6.0 (217), Firefox 3.6.9(139), Opera 10.62 ( 159) y Explorer 8.0 (27).

No se como de fiable es este test, pero me lo creo bastante. Conclusion: olvidarse por completo de explorer, no merece la pena, acabará por ceder...

Actualizado : Añado el resultado hecho con Safari 5.0.2 para Windows (207)

Curiosioso bug del copilador Java

2010-08-11T15:58:00.002+02:00

Esto lo comento como curiosidad que me ha ocurrido con cierto código. Las siguientes lineas de código se crearon usando Eclipse 3.5 y el compilador javac 1.6 (1.6.0.13 en mi caso) no me detecta error, pero usando la versión de eclipse 3.6 sí.

El código sería el siguiente :

public class BugClass { 
  int methodName (List list) { return 0; }http://www.blogger.com/img/blank.gif
  double methodName (List list) {return 0;}

Resulta que este es un error del compilador de Java que me ha llamado mucho la atención. La pagina del bug este esta : http://bugs.sun.com/view_bug.do?bug_id=6182950

Java es Multi Core

2010-07-28T12:41:00.004+02:00

Hay una pregunta muy común en los desarrollos de aplicaciones java sobre los modernos ordenadores multicore : Java no es multicore.

La respuesta es simple: No por defecto, hay que forzarlo. Yo siempre había pensado que java no soportaba los sistemas multinucleo, solo existía un proceso "java.exe" y ese estaba en un solo nucleo. Sin embargo he encontrado información al respecto (ver enlace adjunto) y como siempre, lo anoto por aqui. La clave está en la clase ExecutorService que permite controlar el numero de nucleos que quieres usar. A continuacion el ejemplo copiado de este blog y el ejemplo.

import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;

public class Main {
public static void main(String[] args) {

  ParallelTask pt1 = new ParallelTask();
  ParallelTask pt2 = new ParallelTask();
  ParallelTask pt3 = new ParallelTask();
  ParallelTask pt4 = new ParallelTask();
  ParallelTask pt5 = new ParallelTask();
  ParallelTask pt6 = new ParallelTask();
  ExecutorService es = Executors.newFixedThreadPool(2);
  es.execute(pt1);
  es.execute(pt2);
  es.execute(pt3);
  es.execute(pt4);
  es.execute(pt5);
  es.execute(pt6);

  es.shutdown();
}}

Esta ejecucion esta usando los dos nucleos mi ordenado:

Además, permite ejecutar "Callable" igual que los threads :

public static void main(String[] args) throws InterruptedException, ExecutionException {
 ExecutorService es = Executors.newFixedThreadPool(7);
 
Future f1 = es.submit(new MyCall("F1"));
Future f2 = es.submit(new MyCall("F2"));
Future f3 = es.submit(new MyCall("F3"));
Future f4 = es.submit(new MyCall("F4"));
Future f5 = es.submit(new MyCall("F5"));
Future f6 = es.submit(new MyCall("F6"));
Future f7 = es.submit(new MyCall("F7"));

  
System.err.println( " >> F1 " + f1.get());
System.err.println( " >> F2 " + f2.get());
System.err.println( " >> F3 " + f3.get());
System.err.println( " >> F4 " + f4.get());
System.err.println( " >> F5 " + f5.get());
System.err.println( " >> F6 " + f6.get());
System.err.println( " >> F7 " + f7.get());
es.shutdown();

}

private static class MyCall implements Callable<Double> {
 private String name;
 MyCall (String name) {
  this.name = name;
 }
 private double result = 0;
 @Override
 public Double call() throws Exception {
   double max = Math.random() * 200000000;
   System.out.println (" Starting : " + name + " loop : " + max);
   for (int i = 0; i < max; i++)
      result  = Math.sin(i);
   System.out.println("finishing task " + name);
   return result;
}}

Una de esas cosas que interesa saber

Cambios

2010-07-06T09:55:00.003+02:00

Hola a todos, ha habido algunos cambios importantes en mi vida, el mayor de todos que soy Padre

Como podréis suponer este cambio ha hecho que el tiempo disponible para dedicarle al blog se ha visto reducido muchos enteros, cosa que antes tampoco era abundante. Así que ya tengo otra excusa más de los retrasos en las actualizaciones en el blog. Estoy buscando huecos libres, en breve volverá la actividad. Prometido.

Otros tiempos

2010-03-28T16:05:00.001+02:00

Ha pasado mucho (pero mucho) desde la ultima vez que escribí algo en el blog, la razón principal la de siempre, falta de tiempo. En todo este tiempo he aprendido un montón de cosas nuevas, y no sólo de programacion Java, que aunque sigo programando bastante, no al mismo nivel que antes. He conocido herramientas nuevas y muy interesantes, no muy alejadas de la programación pero si bastante más cerca de donde estoy ahora, QA.

Voy a aprovechar esta entrada para enumerar las cosas que quiero ir contando en las próximas semanas, espero que os sirvan para algo.

Lo primero en lo que quiero entrar es en Hudson, esta es una herramienta que creo que deberia de usarse en todos los equipos de desarrollo. Es lo que se llama una herramienda de integración continua, esta es una aplicación web que cada cierto tiempo o a manualemente descarga el codigo completo y lanza los scripts que nosotros queramos. Podemos desde simplemente asegurarnos de que todo sigue compilando a diario a lanzar pruebas automaticas diarias o herramientas del control de la calidad del software, despliegue diario de la aplicacion web en el servidor de pruebas... imprescindible. Tengo que hablar mucho de esto.

La siguiente herramienta que he conocido hace poco pero me parece increible es Sonar. se puede integrar con hudson mediante un plugin o simplemente llamar un script. En cualquier caso, configurar un proyecto para usarlo con esta herramiente es tan simple que a veces duele no haberlo usado antes. Sonar no es mas que una "aglutinador" de otras herramientas como "findbugs", "pmd", "checkstye" y presenta los resultados en una una web simple y facil de entender. Permite detectar facilmente "bugs potenciales" o malas prácticas. Desde castings imposibles a operaciones con streams que no se cierran en el finally.

Y finalmente quiero hablar un poco de GWT y el desarrollo web de aplicaciones usando este framework de google. Todos los problemas que me estoy encontrando y muchas de las ventanas que tiene.

Bueno, nos vemos en breve (espero).

Validando contra LDAP - Active Directory

2009-09-02T16:32:00.005+02:00

Bueno, sobre esto existe mucha documentación por el mundo y la verdad que no soy un experto, en mi caso he tenido que hacer una pequeña modificación a una aplicación de uso interno para que valide el usuario que quiere acceder usando el mismo usuario y contraseña que se usa para acceder al dominio. La historia se resume en que el servidor Tomcat esta en Windows dentro de un dominio con Active Directory, donde se gestionan los usuarios y grupos.

Validar directamente sobre Active Directory al parecer requiere de ciertas llamadas al sistema operativo, una DLL vamos (o al menos eso es lo que yo he entendido recopilando información desde google). Yo encontré una librería que usa un plug-in de Hudson para validar sobre active directory, se llama "active directory" (como no) y la ha desarrollado un tal Kohsuke Kawaguchi (su blog y la entrada donde explica la integración de hudson y active directory).

La librería esta muy bien y a mi me funcionó todo a la primera, pero tenia el inconveniente de la dependencia de una DLL y que el servidor estuviese sobre windows, como estamos intentando migrar algunos sistemas a Linux no quise arriesgarme, así que en lugar de hacerlo así usé LDAP sobre el directorio, que aquí esta configurado para que funcione (no me pregunten como se configura que eso es cosa de sistemas).

Al final el código queda tan simple que he pensado que es interesante comentarlo.

DirContext ctx = null;
 Hashtable env = new Hashtable();
 env.put(Context.INITIAL_CONTEXT_FACTORY,
    "com.sun.jndi.ldap.LdapCtxFactory");
 env.put(Context.PROVIDER_URL, "ldap://domain.corp");
 env.put(Context.SECURITY_PRINCIPAL, username + "@domain.corp");
 env.put(Context.SECURITY_AUTHENTICATION, "simple");
 env.put(Context.SECURITY_CREDENTIALS, password);
 try {
   ctx = new InitialDirContext(env);
   // connected. Login success 

    return true;
 } catch (Exception ex){ 

  LOGGER.log(Level.SEVERE, "Authentication exception : " + ex.getMessage());
} finally {
  if (ctx != null) {
    try { ctx.close(); }
    catch (NamingException e) {
       LOGGER.info("Naming exception : " + e.toString());
}}}
return false;

Y ya está, por supuesto además se puede verificar a que grupo pertenece el usuario y en función de eso, dar diferentes permisos. Espero que a alguien le sirva, hay mucha información sobre esto por ahí.

Decompilando Java

2009-08-25T16:33:00.000+02:00

Afortunadamente son pocas las ocasiones en los que un código, más o menos esencial, se pierden las fuentes. Hoy en día siempre se sigue el mismo protocolo de usar un SVN u otro sistema de control de versiones para ir almacenando el código fuente. Sin embargo, por pura ley de Murphy, siempre puede darse uno de esos casos improbables. En mi caso se está usando una versión de JAR que no tiene el código en el SVN.

Cuando esto ocurre la solución más rápida pasa por los decompiladores de código java. Usando estas herramientas es posible extraer desde los ficheros binarios ".class" una versión bastante similar al código original.

Yo he encontrado algunas soluciones interesantes, las enumero aquí y así las hago públicas:

DJ Decompile. Es una aplicación comercial, bastante interesante. Tiene una versión de evaluación de algunos días/usos y para una emergencia puede servir.
JAD es una librería para decompilado de java (el sitio oficial no esta disponible. He encontrado un mirror). Yo encontré un programa llamado "FrontEnd plus"como herramienta GUI que usa esta librería internamente, aunque he encontrado más aquí : http://blogninja.com/doc/jad/jad.html#gui
Y el que mas me gusta, el plug-in para eclipse (que también es aplicación para escritorio) JD-Eclipse. Más información : http://java.decompiler.free.fr/

Finalmente he optado por esta última opción, sólo requiere tener las clases dentro del classpath de un proyecto eclipse y con un simple click puedes ver el código fuente, puede servirme para alguna que otra librería que no sé como funciona.

FileSets en Ant

2009-08-06T14:59:00.001+02:00

Bueno, como dije en mi anterior post, voy a intentar resumir las cosas nuevas con las que he tenido que trabajar estos meses. Una de ellas son las tareas "ant" personalizadas. Últimamente he tenido que modificar y crear algunos scripts ant para muchas operaciones diferentes y en mas de una ocasión me he encontrado con situaciones que el script necesita hacer operaciones "poco comunes". En mi caso, consistía en localizar el último fichero modificado en una carpeta.

No quería copiarlo, moverlo ni nada parecido, solo saber cual era. Así que tuve que hacer una tarea para ello. La funcionalidad que busco es, dada una carpeta, localizar el ultimo fichero modificado usando patrones de búsqueda por nombre (include - exclude).

Al final el código del script viene a quedar como esto :

<lastFile property="my.property">
   <fileset dir="C:/FOLDER">
     <include name="**/*.exe" />
     <exclude name="*Setup*" />
   </fileset>
</lastFile>

Aquí vemos como la tarea "lastFile" debe de buscar todos los ejecutables en la carpeta "C:\FOLDER" excepto aquellos que contengan "Setup" en su nombre y guardar en la propiedad "my.property" el nombre de este. Ahora lo que toca es ponerse manos a la obra y ver el código Java. Para ello empezamos creando una clase que será nuestra tarea:

import org.apache.tools.ant.Task;
import org.apache.tools.ant.types.FileSet;

public class LastFile
    extends Task
{
  private String property;
  private Vector <Fileset>
 filesets = new Vector<Fileset>();

  public void addFileset(FileSet fileset)  {
    filesets.add(fileset);
  }

  public void setProperty(String property) {
    this.property = property;
  }


  public String getProperty() {
    return property;
  }

  protected void validate() {
         if (property == null)
      throw new BuildException("property not set", getLocation());
    if (filesets.size() < 1)
                throw new BuildException("You must specify a fileset", getLocation());
     }
          @Override
          public void execute()
              throws BuildException
          {
              // Mi código va aquí
          }
} // End Class

Como se ve, ahora mismo la clave está en la propiedad "filesets", en la que se añaden elementos del tipo "FileSet". Este elemento nos permite saber los ficheros existentes en la carpeta indicada. Ahora la clave está en como usarlo. Así que nos vamos al corazón de la tarea, al método "execute". Primero veamos como lo hice yo.

validate(); // 1
long newest = 0;
File last = null;
for (FileSet fs : filesets)
{
    if (fs.getProject() == null)  {
        fs = (FileSet) fs.clone();
        fs.setProject(getProject());
    }
    File dir = fs.getDir();
    log("searching last file in " + dir);
    // Obtenemos una instancia del scanner del directorio
    DirectoryScanner ds = fs.getDirectoryScanner(getProject());
    // Una lista de los ficheros incluidos
    String[] includedFiles = ds.getIncludedFiles();
    for (String filename : includedFiles) {
        log("--> " + filename);
        File currentFile = new File(dir, filename);
        if (!currentFile.isDirectory())
        {
          // Para cada fichero, obtenemos la fecha y nos
          // quedamos con el último
          long lastModified = currentFile.lastModified();
          if (lastModified > newest)
          {
            newest = lastModified;
            last = currentFile;
          }
        }
    }
    if (last == null)
    {
        log("No file was found", Project.MSG_WARN);
    } else  {
        String value;
        value = last.getAbsolutePath();
        log("Find the last file " + last.getName(), Project.MSG_INFO);
        log("Setting propery '" + getProperty() + "' to value '" + value + "'");
        getProject().setProperty(getProperty(), value);
    }
}

Lo importante con lo que hay que quedarse es que una vez tengamos el FileSet, podemos obtener todos los ficheros que estan incluido (incluso los excluidos) y trabajar con ellos. Cualquier duda, en los comentarios. El código esta disponible dentro de mi SVN en http://code.google.com/p/guevonaso-codes/

El tiempo pasa

2009-08-05T09:29:00.001+02:00

Bueno, han pasado.. ¿cuanto? casi tres meses desde mi último post. Quiero pedir disculpas por el retraso pero han sido unos meses de mucho (realmente mucho) estrés, tanto en el trabajo como en casa, y no he tenido tiempo de poder actualizar nada, espero que a partir de ahora tenga una jornada mas "normal" y me de tiempo a ponerme al día en actualizar el blog con todas las cosas que he aprendido estos meses, que no han sido pocas.

En breve una actualización hablando otra vez de Java y sus cosillas.

Blog personal en civinova.org

2009-05-12T09:31:00.001+02:00

El otro día comenzó un nuevo proyecto que mi amigo Ibán está llevando con mucha ilusión. Se llama http://civinova.org y http://civinova.com. Como indica en la web :

CiviNova Es una ciudad virtual dedicada a la cultura donde los usuarios (ciudadanos) cuentan con todo lo necesario para dar a conocer su obra. Para los creadores hay gremios de escritores, pintores, músicos... Y para todos, grupos de literatura, arte, música, cine... ¿Te lo vas a perder?

civi Nova es, además, una revista, una editorial y un hosting para alojamiento y creación de webs culturales.

Es decir, civinova es una nueva red social y una revista de cultura en la que cualquiera que se considere creador y/o artista puede empezar a dar a conocer su obra sin complicaciones y ver las creaciones de otros miembros de la "ciudad".

El proyecto está aún en una fase inicial en la que se han puesto en marcha las herramientas básicas necesarias, pero se espera que la cosa vaya creciendo. Animo a todo el mundo desde mi humilde blog a que os acerquéis a echar un vistazo y si os atrevéis, a crear vuestro perfil de ciudadano. Yo por mi parte he decidido que mi blog personal sea ahora el de civinova http://www.civinova.org/pg/blog/guevonaso . No sé que pasará con http://guevonaso.blogspot.com, supongo que seguirá existiendo, pero no lo sé. En cualquier caso, desde aquí deseo toda la suerte del mundo a Ibán en su proyecto

Actualizando hola mundo struts 2

2009-05-04T18:08:00.001+02:00

Este es un post corto. He reorganizado un poco el código del proyecto de hola mundo del post anterior. Estoy intentando hacer que el proyecto se pueda desplegar usando maven, ya comentaré mis experiencias. La verdad es que está siendo un poco más frustrante de lo que pensé en un momento. Un buen enlace para ver como hacerlo en castellano: Hola mundo con google App Engine y maven. Esta traducido y resumido de otro blog que además tiene en uno de sus comentarios una referencia a esto mismo y que además está creando un "archetype" para maven para crear proyecto de google. Muy didactico seguir la secuencia completa.

Por ahora me conformo con haber podido simplifiar el ejemplo anterior para poder ampliarlo poco a poco.

Struts 2 en google-app-engine

2009-04-26T19:00:00.010+02:00

Buenas, he tenido estas últimas semanas mucho (pero mucho) trabajo y no he podido añadir nada nuevo al blog por falta de tiempo. La noticia java durante este tiempo ha sido (a parte de la compra de Sun por parte de Oracle) el hecho de que google haya dado soporte Java en su engine además de python.

La noticia es genial para todos los que queríamos hacer una aplicación web pública sin costes y sin tener que depender de PHP. El servicio puede hacerse de pago, puesto que la version gratuita tiene una serie de limitaciones de ancho de banda y consumo de CPU, pero sin publicidad incluida.

Pero yo no quería hablar de las bondades del servicio de google, si no de como poder utilizar algún framework dentro de este. Casi a la vez que salió la noticia he encotrado varios sitios hablando del tema, enumero aqui :

En este blog, comentado en javahispano, se explica como trabajar con maven y google app engine. Resumiendo un poco lo que comentan www.sonatype.com y Salientpoint.com.
En AOWS explica como configurar Struts 1.2 .
Y en los grupos de google se habla de todos los frameworks que han conseguido poner en marcha hasta ahora, desde grails a Spring.

Y mi aportación a este mundo es recoger esta informacion y explicar en cuatro pasos simples el hola mundo de Struts 2. No se hasta que punto funcionará todo, pero por probar que no quede.

Asumo que ya se ha configurado eclipse y habeis hecho el primer "Hola Mundo" usando el AppEngine SDK.

Una vez tenemos nuestra aplicación de pruebas funcionando, pasamos al siguiente paso, nos bajamos las librerias de struts. Las podemos encontrar en la página oficial o usando maven. Yo me las he descargado a mano, la versión que contiene solo los jar necesarios y la que contiene las applicaciones de ejemplo (llamada struts-2.1.6.apps.zip ).

Mi intención es simplemente ejecutar el "HelloWorld", por lo que descomprimo el helloworld.war.

El siguiente paso es tan simple como copiar las librerias en la carpeta "lib" y modificar el web.xml añadiendo el filtro de Struts, los JSPs de ejemplo y las clases de ejemplo y los XML que la aplicacion a mi proyecto creado con eclipse.

La estructura del proyecto eclipse queda algo tal y como se muestra en la imagen a continuacion.

Si tal y como tenemos el proyecto ahora mismo, la aplicación falla. Nos provocará un error provocado por las restricciones que el engine de google ha introducido en su máquina virtual y que hacen incompatible el funcionamiento por defecto del OGNL. La solución la he encontrado en uno de los enlaces anteriores que me ha llevado a esta entrada de un foro. En ella se describe que la solución es muy simple, crear un listener que nos permita configurar la gestión de seguridad de OGNL.

El codigo del listener sería:

public class InitListener implements
ServletContextListener
{
public InitListener()
{ }

public void
contextInitialized(ServletContextEvent sce)
{
OgnlRuntime.setSecurityManager(null);
}
// El resto de metodos necesarios se dejan vacios.

Incluimos el listener en el web.xml :

<web-app>
<!-— El filtro de struts 2 -->
<filter>
    <filter-name>struts2</filter-name>
    <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>struts2</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
<listener>
    <listener-class>es.guevonaso.InitListener</listener-class>
</listener>
<servlet>
    <servlet-name>guevonaso</servlet-name>
    <servlet-class>es.guevonaso.guevonasoServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>guevonaso</servlet-name>
    <url-pattern>/guevonaso</url-pattern>
</servlet-mapping>
<welcome-file-list>
    <welcome-file>index.html</welcome-file>
</welcome-file-list>
</web-app>

Una vez funcionando nos mostrará un mensaje de error de que las sesiones no están configuradas. Para eso solo debemos de modificar el fichero appengine-web.xml y añadir el parámetro "sessions-enabled":

<appengine-web-app xmlns="http://appengine.google.com/ns/1.0">
  <application>guevonaso</application>
  <version>1</version>
  <!-- Configure java.util.logging -->
  <system-properties>
      <property name="java.util.logging.config.file" value="WEB-INF/logging.properties"/>
  </system-properties>
  <sessions-enabled>true</sessions-enabled>
</appengine-web-app>

Y listo, esto nos permite tener un hola mundo empleando struts 2. Ahora es cosa de verificar hasta que punto podemos usar esta librería. Mientras tanto, el codigo de este ejemplo lo podéis encontrar donde siempre en http://code.google.com/p/guevonaso-codes/, con la salvedad de que no he subido los ficheros binarios "JAR", de la carpeta "lib". Y la aplicación de pruebas esta en : http://guevonaso.appspot.com/example

El ejemplo de un formulario
Hola mundo

Pequeño cambio

2009-03-13T15:25:00.001+01:00

Hace tiempo incluí en el blog el Pingbox de yahoo. Lo quité porque ralentizaba mucho la carga, ahora lo he vuelto a añadir, esta vez hago una "carga por petición", de forma que dándole al botón de la derecha se carga y me ahorro que se cargue a todos los visitantes.

Espero que os guste el cambio.

Informacion util de Struts 2

2009-03-12T19:08:00.001+01:00

Esta entrada es sólo lo que yo llamo un apunte de algo interesante. Aunque no lo he encontrado yo creo que merece la pena mencionarlo, es una lista de las tags para Struts 2 y como funciona.

http://mundogeek.net/archivos/2009/02/13/etiquetas-struts-2/

Struts 2 es una de esas espinitas que tengo clavadas, me parece un framework muy interesante y las pruebas que he hecho me da la sensación de que está muy conseguido, quizás en el momento en que lo use intensivamente cambie mi opinión de como es.

En cualquier caso, es un un buen enlace para tener a mano.

Esquema de Aplicación GIS para WEB

2009-03-06T14:33:00.005+01:00

Después de mucho sopesar, me parecía demasiado obvio explicar como instalar y configurar un servidor de mapas (geoserver) para que estén disponibles nuestra información geográfica, así como configurar un cliente web (OpenLayers) para su visualización.

Pero si me parecía de interés publicar un diagrama que nos permita tener un esquema visual de producto completo.
Entiéndase como producto, una aplicación GIS, que se pueda acceder desde la WEB.

Así pues, os dejo el diagrama.

Tus datos geográficos representados sobre GoogleMaps

2009-03-05T16:33:00.007+01:00

Aunque en una entrada posterior hablaré sobre las proyecciones, ahora me sirve como introducción, indicar que uno de los problemas que nos podemos encontrar es trabajar con datos que son de diferente tipo de proyección.

Para estas latitudes, es muy común trabajar con el sistema de referencia Datum ED 50/UTM 30N o si estamos más situados al oeste, como puede ser Huelva o Galicia, podríamos estar hablando de Datum ED 50/UTM 29N.

Estas proyecciones son válidas para un rango geográfico. Fuera de este rango geográfico, simplemente no son válidas para georeferenciar.
Es por esto que google utiliza otros sistemas de referencia, normalmente WGS 84 que además se corresponde con el sistema de referencia de la mayoría de los GPS por omisión.

Aquí hay un concepto que no tengo del todo claro, pero si sé que tiene que ver con el modelo matemático de la esfera terrestre utilizado.
Para que nos entendamos. Si queremos solapar nuestros datos sobre cualquier mapa de google, deberíamos de utilizar el sistema de referencias Spherical Mercator de google.

Vale, a modo de resumen, el problema es, que tengo sistemas de referencias diferentes y que tengo que "transformar" a uno en concreto para trabajar siempre sobre el mismo sistema de referencias. Si has llegado a la misma conclusión, es que estamos en la misma onda.

Bien, estamos de acuerdo en el problema, pero todavía nos queda establecer una estrategia para resolverlo.
La estrategia que yo he adoptado (que seguro que no es la única y quizás tampoco la mejor) es crear una vista de mis datos geográficos, pero transformados a este nuevo sistema de referencia (Spherical Mercator de google).

Bueno, en este caso podemos estar de acuerdo o no con la solución, pero nos ponemos manos a la obra para implementarla.

Antes de nada (tarde o temprano, nos daríamos cuenta de ello), os informo de que en nuestra base de datos que hemos creado y poblado con tanto esmero, no existe el sistema de referencia Spherical Mercator de google. Bueno, no pasa nada. Lo metemos.

Para meterlo, lanzamos la siguiente query.

INSERT into spatial_ref_sys (
   srid, auth_name, auth_srid, srtext, proj4text
  ) values (
   900913 ,'EPSG',900913,
  'GEOGCS["WGS 84", 
   DATUM["World Geodetic System 1984", 
   SPHEROID["WGS 84", 6378137.0, 298.257223563,
   AUTHORITY["EPSG","7030"]], 
   AUTHORITY["EPSG","6326"]],
   PRIMEM["Greenwich", 0.0, 
   AUTHORITY["EPSG","8901"]], 
   NIT["degree",0.017453292519943295], 
   AXIS["Longitude", EAST], 
   AXIS["Latitude", NORTH],
   AUTHORITY["EPSG","4326"]],
   PROJECTION["Mercator_1SP"],
   PARAMETER["semi_minor", 6378137.0], 
   PARAMETER["latitude_of_origin",0.0], 
   PARAMETER["central_meridian", 0.0], 
   PARAMETER["scale_factor",1.0], 
   PARAMETER["false_easting", 0.0], 
   PARAMETER["false_northing", 0.0],
   UNIT["m", 1.0],
   AXIS["x", EAST], 
   AXIS["y", NORTH],
   AUTHORITY["EPSG","900913"]] |',
   '+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 
    +x_0=0.0 +y_0=0 +k=1.0 +units=m 
    +nadgrids=@null +no_defs'
 );

CUIDADO aqui se ha puesto la sentencia con retorno de carros en las cadenas de texto, es posible que copiar y pegar no funcione directamente.

Vale, ya tenemos el sistema de referencia con el que vamos a trabajar. Ahora necesitamos hacer una vista, que contenga toda la información de mis elementos espaciales (features) en dicho sistema de referencia.

CREATE OR REPLACE VIEW [view_table_name] AS 
 SELECT [table_name].[table_field1], 
        [table_name].[table_field2], 
        st_transform(st_setsrid(
           [table_name].[geom_field], 
           23030
           ), 900913
        ) 
 AS the_geom
 FROM [table_name];

Hay que tener en cuenta que podemos poner tantos campos como necesitemos o tenga la tabla en cuestión.

Por otra parte, se asigna el alias the_geom al campo que contendrá los datos de georeferencia, que es el nombre que asigna por omisión el loader de postGis (shp2pgsql)

Con esto ya tenemos una vista con los datos en la proyección correcta para solaparla con los mapas de Google Maps.

Fuentes:

http://trac.openlayers.org/wiki/SphericalMercator

De shapes a geodatabases

2009-03-05T14:06:00.008+01:00

Bien, una vez que tenemos nuestra geodatabase preparada, nuestra siguiente tarea es poblarla de datos geográficos.

Datos que posteriormente utilizaremos para representar sobre un mapa desde una página web, desde un cliente móvil o cualquier otro.

El estandar en información geográfica, son los ficheros shapes.

Por ende, no sería de extrañar que la información llegue a tus manos en este formato.

Dentro de nuestras habilidades como expertos en GIS es pasar esta información a nuestra base de datos.

PostGis ofrece una herramienta que realiza la conversión del fichero shape a un scripts que podemos utilizar para poblar nuestra geodatabase.

    shp2pgsql

shp2pgsql es una herramienta que nos permite obtener desde un fichero shape, un script SQL para la inserción de elementos espaciales en base de datos.

    shp2pgsql shaperoads.shp roadstable > roads.sql

Con este simple comando obtenemos los objetos espaciales del fichero shaperoads.shp, y creamos los insert into de dichos objetos a la tabla roadstable.

Dado que la aplicación estandar de facto para la creación y edición de ficheros shapes, es ArcGis, que va sobre Windows, es muy dado que nos encontremos con que la información que contienen los ficheros shapes, estén en algún encoding que no es el que esperamos. Para esto yo uso una herramienta en linux que se llama iconv.

Basta con pasar esta herramienta a los sqls generados para tenerlos preparados para lanzarlos en nuestra base de datos.

Posteriormente nos quedaría lanzar el script roads.sql para que dichos objetos espaciales estén registrados en nuestra base de datos.

    psql [base de datos] -f roads.sql 2> roads.err

Como resultado tendremos los objetos espaciales insertados en nuestra base de datos y un fichero donde guardaremos los posibles errores en la subida del fichero.

Esto es todo lo que necesitamos para pasar nuestros ficheros shapes a una geodatabase.

Un poco de GIS

2009-03-05T12:36:00.005+01:00

Bueno, tengo la tarea de documentar mi trabajo sobre GIS, y veo justo y productivo compartir mis conocimientos con todos los lectores de este fantástico Blog.
Para empezar explicaré como crear una base de datos geo-espacial con software libre.
La base de datos utilizada es postgreSql, con postGis para el soporte espacial.
A modo de introducción.

PostGis, no es más que un conjunto de funciones y herramientas que permiten realizar operaciones espaciales con los datos almacenados en una base de datos postgreSql.
El primer paso para crear una base de datos geo-espacial, es instalarse el motor de la base de datos y su extensión espacial (postGis).
Desde linux es tan sencillo como:

     sudo apt-get install postgresql-8.3 postgresql-8.3-postgis

Nota: Estos paquetes están incluidos en los repositorios de ubuntu 8.10 (Intrepid Ibex) Una vez instalado el motor de base de datos, debemos configurar el control de acceso, para eso tenemos los siguientes ficheros:

 /etc/postgresql/8.3/main/postgresql.conf
 /etc/postgresql/8.3/main/pg_hba.conf

Estoy seguro que no os faltarán recursos para configurar vuestro control de acceso.

Creamos la base de datos

Una vez configurado el control de acceso, creamos una BBDD, por ejemplo con pgadmin3.
Para crearla con psql teneis documentación suficiente aquí.
Me vais a perdonar que no entre en mucho de talle en estos pasos pero son más propios de una base de datos postgreSql normal que una base de datos geo-espacial.
Hasta ahora hemos conseguido crear una base de datos normal, con postgreSql. Lo que nos queda es añadirle las capacidades espaciales. Para ello, vamos a seguir los siguientes pasos.

Añadimos Capacidades procedurales

Añadimos capacidades procedurales a nuestra base de datos (PL/pgSQL) ya que son requeridas por postGis.

 # createlang plpgsql [yourdatabase]

Añadimos objetos y funciones espaciales a nuestra base de datos

El script para añadir estas funcionalidades (y el siguiente) los encontraremos en /usr/share/postgresql-8.3-postgis.
Ejecutamos el siguiente comando.

 # psql -d [yourdatabase] -f lwpostgis.sql

Añadimos las referencias espaciales a nuestra base de datos

Esto no es necesario pero es altamente recomendable, si queremos trabajar con diferentes proyecciones. De esto, si me da tiempo, hablaremos en otro post.

 # psql -d [yourdatabase] -f spatial_ref_sys.sql

NOTA: Es posible que tengáis que especificar el usuario o la máquina[ y puerto] a la que os queréis conectar. Un "man psql" os dará la información que necesitáis y más. Con esto, tendríamos instalada y preparada nuestra geo-database para hacer las pruebas pertinentes.
Fuentes: postGis

Quien me llama

2009-03-02T14:00:00.002+01:00

En el proyecto actual me he encontrado con un problema que me tenia bloqueado, había un método de una clase concreta usado para configurar la aplicación que no sabía desde que clase se llamaba. Al ser un producto que tiene infinitas dependencias (por redondear hacia abajo) y no siempre con el código disponible adivinar en que punto se llamaba me estaba costando más de un dolor de cabeza. Al final mi solución es lanzar una RuntimeException y confiar que en los logs dejase el StackTrace (que lo hizo) con lo que pude sacar lo que quería.

A raíz de esto me surgió la duda, ¿Puedo saber en tiempo de ejecución desde donde me llaman?. Sé que existen clases que usan esta posibilidad, el ejemplo más claro lo tengo de Log4J, en el que usando un patrón "%C" por ejemplo me dice desde que clase se ha invocado el método "debug" (si no sabéis de que hablo, echadle un vistazo a log4j, es muy fácil de usar.... luego vuelve).

Me entró la curiosidad de saber como hacía eso Log4J y me bajé el código fuente, estuve echándole un vistazo y me encontré con la clave, la clase que consigue esta información se llama "org.apache.log4j.spi.LocationInfo" y es tan simple que me da casi vergüenza. La cosa se resumen en crear un objeto Throwable (una excepción vamos) y no lanzarlo, la información sobre los métodos que han llamado al método actual queda registrado en el StackTrace.

En mi SVN he subido una clase llamada "WhoCallMe", con su respectivo test, que no es más que una versión reducida de LocationInfo de log4j para uso personal. El código se reduce a lo siguiente:

 // Creamos el Throwable
 Throwable t = new Throwable();
 // Creamos donde almacenar la información
 StringWriter sw = new StringWriter();
 PrintWriter pw = new PrintWriter(sw);
 String allInfo;
 // Recuperamos la información
 t.printStackTrace(pw);
 allInfo = sw.toString();
 sw.getBuffer().setLength(0);
.... 
 // En all info tenemos el stackTrace

Con una simple operación de "limpieza" podemos sacar de donde se llama el método sin demasiado esfuerzo. Por lo visto esta es una operación "costosa", por lo que no la recomiendo para uso masivo.

Actualización: Me han pedido que explique un ejemplo de uso, el ejemplo lo podemos encontrar en mi SVN, en la parte de test. Voy a comentarlo un poco por aquí.

El código anterior quedaría dentro de una clase a la que voy a llamar WhoCallMe, que tendría un método "getFullInfo()" que devolvería la lista completa de llamadas hasta el método actual. Seria algo como esto:

public class WhoCallMe {
  private String fullInfo;  
  // Constructor
  public WhoCallMe (Class clazz, String method) {
     // aquí irá 
     // más o menos el código anterior...
     this.fullInfo = sw.toString().
  }
  // Método
  public String getFullInfo() {
     return this.fullInfo;
  }
}

Ahora supongamos un método cualquiera, en mi código, que es llamado en algún momento y quiero saber por que clase (lo que comento al principio, no tengo el código fuente que usa mi clase, por ejemplo, pero me usa mal y quiero informar al responsable). Llamaré a mi clase "CualquierClase" y para saber quien me usa haría lo siguiente :

public class CualquierClase {
 public void unMetodo() {
   // Lo primero que hago es instanciar 
   // WhoCallMe, indicando quien soy yo
   // es decir, a partir de quien quiero
   // saber la invocación.
   WhoCallMe who = new WhoCallMe (CualquierClase.class,"unMetodo");
   // y ahora puedo escribir un log o por
   // consola la traza
   System.out.println (who.getFullInfo()) 
   // aquí el resto del código de mi método.
   int a = 1 + 1;
 }}

Con esto lo que consigo es un resultado como este :

at es.un.paquete.CualquierClase.unMetodo(10)
at es.otro.paquete.OtraClase.otroMetodo(xx)
at ...

Es decir que he "adivinado", sin lanzar una excepción, que a mi método lo llama una clase llamada "OtraClase" en su método "otroMetodo" en la linea "xx".

Un poco de JUnit

2009-02-12T11:51:00.001+01:00

Ahora ando programando un poco usando JUnit y se me ha ocurrido hacer una pequeña explicación de como funciona el cacharro este y como lo uso yo.

En principio la versión que yo conozco y que estoy usando es la 3, en la nueva versión han añadido algunas mejoras (puedes usar anotaciones en lugar de herencia por ejemplo) pero como yo no lo puedo usar por compatibilidad con lo que tengo, no voy a explicarlo aquí.

Para empezar algunos enlaces:

En la Wikipedia hay cosas en español y en ingles. Con algunos enlaces interesantes.
La pagina oficial aquí.
En Javahispano un tutorial (algo antiguo)

Y buscando por la red encontraréis como mil cosas más. La idea principal de JUnit es tener un framework sobre el que poder hacer las pruebas de tu código. Leí por ahí que una mala prueba siempre es mejor que ninguna, podríamos discutir sobre el tema, pero lo cierto es que lo importante es por lo menos deberíamos de tener pruebas mínimas que se puedan repetir siempre que queramos.

Lo difícil de las pruebas siempre es tener un estado inicial y un final conocido con el que determinar que el producto funciona para todos los casos posibles. Este estado inicial y final se suelen resumir en un conjunto de datos de prueba a usar. No siempre podemos mantener estos datos iniciales para asegurarnos de que las pruebas son siempre las mismas. Lo importante en todo caso es tener siempre presente que junit es una herramienta más, algo que existe para facilitar las cosas, pero no es ni la panacea ni nada que te va a solucionar la vida.

Bueno voy empezar con algo simple. Todo el código que aquí se muestra está en el SVN de mi blog : http://code.google.com/p/guevonaso-codes/

Supongamos que tengo una clase que quiero probar que funciona, en mi caso es una clase que permite dar formato a las fechas en formato texto a clases Date (esta aquí ). Probar esto es simple usando JUnit. El primer paso es crear una clase que hereda de TestCase, la clase principal de JUnit :

public class DateTimeUitlsTest extends TestCase {
 @Override
 protected void setUp() throws Exception {
     super.setUp();
 }
 @Override
 protected void tearDown() throws Exception {
     super.tearDown();
}}

Ya tenemos nuestro primer test (si, si, en serio) ya podemos lanzarlo y veremos como todo funciona perfectamente.... obviamente si no hace nada, nada puede fallar :)

Para lanzar este primer test usaremos Eclipse (Todos los IDES que conozco tienen soporte para JUnit ). Tan simple como pulsar sobre la clase en el explorador de clases --> Botón derecho --> Run As --> JUnit Test . Deberías de tener un resultado similar al siguiente :

El método "setUp" es el primer método que se ejecuta en cada test, nos sirve para establecer una configuración inicial (preparar una base de datos, una carpeta, etc) y el método "tearDown" se ejecuta después de cada test (volver a un estado inicial). Depende de la prueba que hagamos estos métodos los sobreescribiremos o no.

Crear un test en esta clase es tan simple como crear un método que se llame "testXXXX" sin argumentos. Ejemplo :

public void testHora() {
  Date ahora = new Date();
  String hora = DateTimeUtils.hora(ahora);
  Calendar calendario = Calendar.getInstance();
  calendario.setTime(ahora);
  String[] div = hora.split(":");
  assertNotNull(div);
  assertTrue(div.length > 1);
  int hora = Integer.valueOf(calendario.get(Calendar.HOUR_OF_DAY));
  assertEquals(Integer.valueOf(div[0]),hora ));
  int minuto =  Integer.valueOf(calendario.get(Calendar.MINUTE));
  assertEquals(Integer.valueOf(div[1]),minuto);
}

Y eso es todo lo importante. Si volvemos a lanzar el test veremos como ahora el resultado muestra nuestro nuevo test. Una vez tengamos organizados los tests podemos agruparlos para lanzarlos todos juntos, la forma que ofrece JUnit son los TestSuite. No son mas que una clase que agrupa tests :

public class AllTests {
  public static Test suite() {
     TestSuite suite = new TestSuite("Test for es.guevonaso.test.dates");
     //$JUnit-BEGIN$
     suite.addTestSuite(DateTimeUitlsTest.class);
     //$JUnit-END$
     return suite;
  }
}

Lanzar ahora esta suite en lugar del test solo y lanzaremos todos nuestros tests juntos. Se pueden añadir suites a una suite, de forma que al final podremos lanzar todos los tests lanzando una sola clase.

La idea es hacer los tests una vez y tenerlos siempre, de forma que tras cualquier cambio, verificar que todo sigue funcionando es trivial. Ya depende del tiempo que le dediquemos a hacer los tests estos serán mas útiles o no.

Cualquier duda, un comentario :)

Desarrollar tareas ant

2009-02-09T15:02:00.004+01:00

Bueno, hoy voy a volver al mundo java, después de algunas semanas con otros temas. La historia de hoy va sobre ant, la herramienta para desarrollar scripts que mas se usa dentro de java. Ya he comentado en alguna ocasión mis impresiones sobre maven, el que pretende ser su "sustituto". Aunque realmente no es mas que una "estandarización" para la creación de proyectos. No voy a entrar en si el final de Ant esta cerca o lejos o si maven es mejor o peor que ant o si existen mejores soluciones para los scripts. Más allá de estas discusiones está la realidad, y es que ant es ahora mismo el "estandard" para la construcción en Java. Hay tanto hecho y tanta gente usándolo que hacer una migración a otra herramienta se hace con pies de plomo, algo parecido me he encontrado con java 1.4, aun hay proyectos en activo que se "niegan" a actualizarse (la ley básica, si funciona no lo toques).

Como recientemente he tenido que revisar algunos script en ant, aprovecho para hacer una breve pasada para hacer nuestros scripts ant más personalizados, creando nuestras propias tareas.

El proceso es relativamente simple, lo primero es la clase Java que vamos a crear. La documentación es aceptable, por lo que podéis echadle un vistazo para más información. Para muestra voy a crear una simple tarea que me dice el tamaño que tiene un fichero o carpeta y me lo va a guardar en una propiedad. Lo primero que voy a crear es la clase java que lo hace:

package es.guevonaso.ant.size;
import java.io.File;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Task;

public class SizeTask extends Task {
private String property;
protected File file;

public SizeTask() {
 file = null;
 property = null;}

public void setFile(String s) {
 file = new File(s);}

public void setProperty(String s) {
 property = s;}

public void execute() throws BuildException {
 if (file == null)
    throw new BuildException("File attribute must be set.");
 if (file.exists()) {
     long lSize = size(file);
     String sSize = Long.toString( lSize / 1024L);
     getProject().setNewProperty(property, sSize);
 } else {
    throw new BuildException("File cannot be found.");
 }
}
private long size(File file) {
 log l = 0;
 if (file.isDirectory()) {
    File afile[] = file.listFiles();
    for (int i = 0; i < afile.length; i++)
       l += size(afile[i]);
 } else {
    l = file.length();
 }
 return l
}

Como se ve, la clase tampoco es muy compleja, quizás se podría perfeccionar un poco, por ejemplo permitiendo indicar la magnitud a usar (KB, MB, GB) o que no fallase si se indica un fichero que no existe, etc. En cualquier caso sirve de orientación.

A modo de resumen comentar que el código que se ejecuta es el que está contenido dentro de "execute", que es el he hará las operaciones necesarias.

El siguiente paso será generar el xml para esta tarea. Yo voy a hacerlo en dos fichero diferentes, para hacerlo más ilustrativo, el primero definirá mi tarea ant, lo llamaré "custom-tasks.xml".


<project name="custom-tasks" basedir=".." >
<taskdef name="filesize"
classname="es.guevonaso.ant.size.SizeTask">
<classpath>
 <pathelement location="${basedir}/lib/guevonaso-ant.jar" />
</classpath>
</taskdef>
</project>

Y por ultimo el fichero ant que usará esta tarea.

<project name="build" default="default" basedir=".">
<import file="${basedir}/lib/custom-tasks.xml"/>
 <target name="default">
   <filesize file="${basedir}" property="sample-size"/>
   <echo>${sample-size} Kb</echo>
  </target>
</project>

El ejemplo es lo bastante básico como para que cualquiera pueda probarlo. Yo he subido este ejemplo al repositorio que tengo para el blog :

http://code.google.com/p/guevonaso-codes/

Programas utiles

2009-01-22T17:58:00.000+01:00

Esto de no programar tiene la cosa de que no tengo mucho de que contar últimamente, por lo que no sé con que actualizar el blog. Así que me he decidido por comentar un programa que me ha parecido tremendamente útil, al menos a mi que tengo que estar constantemente leyendo y escribiendo correos en el idioma de chaquespeare (según quien lo escriba, Shakespeare, se pronuncia algo así como Chesspir, pero esa es otra historia).

El programa en cuestión se llama Lingoes, el programa ocupa poquito, se puede dejar en la bandeja del sistema y con un solo click (yo lo tengo configurado con CTRL + Botón derecho del ratón ) te dice la traducción de la palabra que tiene el cursor del ratón debajo en ese momento. Y si le instalas "voces" tienes muchas posibilidades de que te diga como se pronuncia, o usar el "lector automático de windows" o como se llame esa voz metálica de windows que lee textos.

Las voces no son mas que ficheros mp3, cada uno tiene el nombre de la palabra que pronuncian ("potatoe.mp3", "tomatoe.mp3", etc... ), por lo que en algún momento si tenéis buena pronunciación podéis guardar un fichero más que no esté. Aunque si usáis el que viene en la web que se descarga por P2P (emule creo) son casi 200Mb de voces.

Se le pueden añadir muchos diccionarios, que además de traducir te da la definición de la palabra. Puede usar diccionarios online, que lo que hace es conectarse a alguna web para traducir o mostrar una definición, yo por ejemplo he instalado el traductor de google y de yahoo como diccionarios online, de forma que de un click comparo en los dos sitios la traducción de una palabreja (no se exactamente como lo he configurado, pero puedo traducir también algunas frases usando el mismo servicio).

A mi personalmente me esta viniendo de perlas, así que lo pongo por aquí por si a alguien le puede venir igual de bien.

Youtube para empezar

2009-01-09T09:29:00.002+01:00

Feliz año nuevo a todos!!

Acabó el 2008 y ya empieza un año nuevo, con nuevos propósitos y espero que sea mejor que el pasado, aunque personalmente no me puedo quejar mucho, debo de reconocer que sí que ha sido un año duro en muchos sentidos.

Así que para empezar a hacerlo un poco más liviano, he decidido por comentar una aplicación que he encotrado el año pasado que me ha venido muy bien, mas que a mi personalmente, para resolver el problema casi constante de explicar a familiares como descargar un video del youtube y ponerlo en el movil de ultima generacion tan chulo,o para descargarlo en el disco duro.

El programa se llama aTube Catcher, lo encontré en Softonic, pero la pagina oficial es http://atube-catcher.dsnetwb.com/, basta poner la url el programa te baja el video y lo convierte al formato que queramos.

La cosa de comentarlo aquí es porque, para ayudar un poco a mi familia, hice un pequeño tutorial flash de como se usa. No es gran cosa, pero puede que os interese para ver como funciona o para verlo trabajar sin necesidad de descargar e instalar el programa. Solo funciona para windows, pero quizas funcione con Wine...

El manual : http://fernando.rosado.googlepages.com/manualatubecatcher

Bueno, un saludo y repito: ¡¡¡ FELIZ AÑO 2009!!!

Resumen del año

2008-12-31T11:42:00.001+01:00

Se acaba el año y es el momento de hacer recuento de como ha ido la cosa para el blog. Sinceramente el resultado ha sido más bueno de que lo que pensé que iba a ser. Lejos de convertirme en un sitio de referencia, la falta de constancia es una de las razones, al menos se puede ver que cierta cantidad de visitas si que tengo.

Aunque al final del año las visitas han caido mucho, lo achaco a que he estado bastante relajado con el blog por la falta de tiempo (en el trabajo ha sido muy intenso estos ultimos meses). En general me salen 11.712 Visitas, que haciendo la media al año son 32 visitas al dia, que personalmente lo considero todo un éxito. Lo genial es que de esas visitas casi un 20% son "reincidentes" lo que me dice que al menos hay unas 7 personas diarias que han pasado por aqui más de una vez, lo que reduce la "accidentalidad".

No voy a hacer una descripcion detallada de todos los puntos de las gráficas y estadisticas que me da analytics, por no aburrir, pero no quiero dejar de dar las gracias a todos vosotros que pasáis por aqui o habeis pasado.Gracias, me hace mucha ilusion pensar que lo que hago le puede servir o gustar a alguien.

Feliz año nuevo a tod@s.