Bundle bundle = Platform.getBundle("com.ilikeblues.example.readfile");
URL fileURL = bundle.getEntry("files/test.txt");
File file = null;
try {
	file = new File(FileLocator.resolve(fileURL).toURI());
} catch (URISyntaxException e1) {
	e1.printStackTrace();
} catch (IOException e1) {
	e1.printStackTrace();
}

Otra opción es utilizar la URL directamente:

URL url;
try {
        url = new URL("platform:/plugin/com.ilikeblues.rcp.plugin.filereader/files/test.txt");
	InputStream inputStream = url.openConnection().getInputStream();
	BufferedReader in = new BufferedReader(new InputStreamReader(inputStream));
	String inputLine;

	while ((inputLine = in.readLine()) != null) {
		System.out.println(inputLine);
	}

	in.close();

} catch (IOException e) {
	e.printStackTrace();
}

Con la segunda opción, además, se evita con la dependencia con la clase Platform.

Vía | http://www.vogella.de/blog

Relacionados:

1. Eclipse Test and Performance Tools Platform Review
2. Java: uso de fichero de Propiedades
3. Utilización de gprof/gcov para obtención de datos de cobertura (I)

private void processGender(Gender gender) {
   switch (gender) {
      case Male:
         // Código para el caso masculino
         break;
      case Female:
         // Código para el caso femenino
         break;
      default:
         // Esto es código inalcanzable, ya que
         // el switch lanzará una NullPointerException si gender == null
   }
}

Si utilizamos enums, más tarde o más temprano tendremos que usar una estructura de este tipo en la toma de decisiones.

Vía | http://javafact.com

Relacionados:

1. Enumeraciones en Java
2. Sobrecarga de métodos en Java
3. Orden de inicialización en Objetos Java

Properties properties = new Properties();
FileInputStream in;
try {
   in = new FileInputStream("app.properties");
   properties.load(in);
   in.close();
} catch (Exception e) {
   System.out.println(e.getMessage());
}
return properties.getProperty("appcode");

Un ejemplo del fichero de propiedades:

appcode=50
email=admin@yahoo.com

Vía | http://seguide.blogspot.com

Relacionados:

1. Sobrecarga de métodos en Java
2. Orden de inicialización en Objetos Java
3. Enumeraciones en Java

Daniel muestra el siguiente código Java:

package com.ds.test;

public class Upper {
   String upperString;

   public Upper() {
      Initializer.initialize(this);
   }
}

package com.ds.test;

public class Lower extends Upper {

   String lowerString = null;

   public Lower() {
      super();
      System.out.println("Upper:  " + upperString);
      System.out.println("Lower:  " + lowerString);
   }

   public static void main(final String[] args) {
      new Lower();
   }
}

package com.ds.test;
public class Initializer {
   static void initialize(final Upper anUpper) {
      if (anUpper instanceof Lower) {
         Lower lower = (Lower) anUpper;
         lower.lowerString = "lowerInited";
      }
      anUpper.upperString = "upperInited";
   }
}

Este código, en contra de lo que podría parecer, produce esta salida:

Upper:  upperInited
Lower:  null;

Si efectuamos un pequeño cambio al código de la clase Lower:

package com.ds.test;

public class Lower extends Upper {

   String lowerString;

   public Lower() {
      super();
      System.out.println("Upper:  " + upperString);
      System.out.println("Lower:  " + lowerString);
   }

   public static void main(final String[] args) {
      new Lower();
   }
}

Obtenemos la salida correcta:

Upper:  upperInited
Lower:  lowerInited

Esto se debe a una diferencia en el flujo de inicialización del objeto Lower. Este es el orden de ejecución:

1. main() llama al constructor de Lower.
2. La máquina virtual prepara una instancia de Lower. Esto significa que todos los campos son creados e inicializados con valores por defecto, es decir, null para referencias, false para booleanos, etc. En este paso, las asignaciones inline de los campos NO han tenido lugar todavía.
3. Se produce la llamada al super-constructor. Esto está incluido en la especificación de Java. Así que se llama al constructor de Upper, antes de cualquier otro paso.
4. El constructor de Upper realiza la llamada al método estático initialize() del objeto Initializer.
5. Este método inicializa las dos referencias de tipo String. Esto se debe al comportamiento, en cierto modo inadecuado, del “instanceof” (en este enlace podemos leer acerca de los peligros de su uso). El caso es que, después de la ejecución, ambas referencias han dejado de ser null.
6. Termina la llamada a initialize() y al constructor de Upper.
7. Aquí viene la parte interesante: la construcción del objeto Lower continúa. Si no se ha añadido la asignación inline explícita (=null) en la declaración del campo lowerString, el constructor continúa con la ejecución normal, y saca por la salida estándar el valor de las dos cadenas.

   Sin embargo, si se añade la asignación inline explícita el flujo es diferente. Los inicializadores de variables se ejecutan después del super-constructor, pero antes del resto del constructor de la clase. De manera que la variable lowerString sería reasignada a null y se produciría la salida errónea indicada más arriba.

El diseño en este caso es un poco complicado, y, desde luego, se debería evitar que la inicialización de variables de la clase Lower dependiese, en cualquier forma, de la de Upper. Sin embargo, el ejemplo es clarificador respecto a la importancia de conocer la manera en la que la máquina virtual Java inicializa las instancias de objetos.

Vía | http://java.dzone.com

Relacionados:

1. Enumeraciones en Java
2. Singleton en Java
3. Java: usar enumeración en un switch

Estos valores pueden ser de cualquier tipo, enteros, cadenas, etc., pero en Java tenemos mecanismos que nos permiten representar estos valores de varias formas, de manera que se ajusten a la necesidad de cada caso.

La manera más sencilla de especificar un enum en Java:

public enum Gender{
   Male, Female;
}

Pero es que, además de sus posibles valores, un enum puede tener constructores y métodos:

public enum Gender{
   Male("Masculino"), Female("Femenino");

   private String spanish;

   // the constructor
   Gender(String spanish){
      this.spanish = spanish;
   }

   // a method
   public String toSpanish(){
      return this.spanish;
   }
}

De manera que podríamos usar este enum de la siguiente manera:

Person p = new Person();
p.setGender(Gender.Male);

String text = "The person's gender in Spanish is: " + p.getGender().toSpanish();

Con esto un enum es similar a una colección (Collection) en Java, con las siguientes diferencias:

1. La máquina virtual inicializa todos los valores.
2. No se permite añadir o eliminar elementos en runtime.
3. Se accede a los objetos estáticamente.

En el ejemplo, Gender representa a la colección, y se puede acceder a sus elementos sin necesidad de crear una instancia.

Vía | http://javafact.com

Relacionados:

1. Java: usar enumeración en un switch
2. Singleton en Java
3. Orden de inicialización en Objetos Java

Seleccionar/deseleccionar un checkbox:

// Seleccionar un checkbox
$('input[name=acheckbox]').attr('checked', true);

// Deseleccionar un checkbox
$('input[name=acheckbox]').attr('checked', false);

Seleccionar/deseleccionar todos los checkbox:

// Seleccionar todos los checkboxes
$("input:checkbox").attr('checked', true);

// Deseleccionar todos los checkboxes
$("input:checkbox").attr('checked', false);

Comprobar si un checkbox está seleccionado:

// Devuelve true si el checkbox está seleccionado, en otro caso devuelve false.
$('input[name=acheckbox]').is(':checked')

Obtener la lista de checkboxes seleccionados (este es sólo uno de los posibles algoritmos que se pueden utilizar; valga como ejemplo):

// Extender jQuery con un método personalizado:
jQuery.fn.getCheckboxValues = function(){
    var values = [];
    var i = 0;
    this.each(function(){
        // guarda los valores en un array
        values[i++] = $(this).val();
    });
    // devuelve un array con los checkboxes seleccionados
    return values;
} 

var arr = $("input:checked").getCheckboxValues();
alert(arr); // esto muestra un pop-up con los checkboxes seleccionados

Vía | http://www.premiumbeat.com

Relacionados:

1. jQuery: mejorar rendimiento en selectores
2. Crear elementos DOM – HTML dinámicamente usando jQuery
3. jQuery: navegador con soporte WebKit

html, body, div, span, applet, object, iframe,
h1, h2, h3, h4, h5, h6, p, blockquote, pre,
a, abbr, acronym, address, big, cite, code,
del, dfn, em, font, img, ins, kbd, q, s, samp,
small, strike, strong, sub, sup, tt, var,
b, u, i, center,
dl, dt, dd, ol, ul, li,
fieldset, form, label, legend,
table, caption, tbody, tfoot, thead, tr, th, td {
margin: 0;
padding: 0;
border: 0;
outline: 0;
font-size: 100%;
vertical-align: baseline;
background: transparent;
}
body {
line-height: 1;
}
ol, ul {
list-style: none;
}
blockquote, q {
quotes: none;
}
blockquote:before, blockquote:after,
q:before, q:after {
content: '';
content: none;
}

/* remember to define focus styles! */
:focus {
outline: 0;
}

/* remember to highlight inserts somehow! */
ins {
text-decoration: none;
}
del {
text-decoration: line-through;
}

/* tables still need 'cellspacing="0"' in the markup */
table {
border-collapse: collapse;
border-spacing: 0;
}

Vía | http://www.webspeaks.in

Relacionados:

1. AJAX: Convertir HTML a objeto DOM
2. Slider con CSS3 puro y funcionalidad de Back Button
3. CSS: crear reflejos en navegadores con soporte WebKit

Yo personalmente, las he confundido muy a menudo. Así que agradezco sinceramente a Zen in the Art of IT la entrada al respecto.

Esto es, básicamente, lo que dice:

ClassNotFoundException: la clase no está en el classpath; esto puede deberse a que han sido definidos dos cargadores (class loaders) diferentes, cada uno con diferente “visibilidad” (esto es bastante común cuando se trabaja con servidores de aplicaciones, donde no tienes un control sobre los class loaders que se van a utilizar), o simplemente que la clase no está en los paquetes incluidos en el classpath.

NoClassDefFoundError: esta situación es muy diferente, y generalmente significa está presente en el classpath, pero ocurrió un error al leer la definición de la misma. A menudo esto se debe a una excepción en un bloque estático de inicialización o la instanciación de una variable estática. En ese caso, la máquina virtual lanza la excepción java.lang.ExceptionInInitializerError y “descarga” la definición de la clase, de manera que cualquier intento de acceder a ella da como resultado la excepción NoClassDefFoundError.

El siguiente código muestra estos comportamientos:

public class App {
  public static void main(String[] args) {
    try {
      App.class.getClassLoader().loadClass("NonExistent");
    } catch (Throwable e) {
      System.out.println(e.getClass().getName());
    }

    try {
      new BadStatic();
    } catch (Throwable e) {
      System.out.println(e.getClass().getName());
      System.out.println(e.getCause().getClass().getName());
    }

    try {
      new BadStatic();
    } catch (Throwable e) {
      System.out.println(e.getClass().getName());
    }

  }

}

package za.co.classNotFoundBadness;

public class BadStatic {

  static {
    if(true){
      throw new IllegalArgumentException("I am a bad static initialiser.");
    }
  }

  public BadStatic() {

  }

}

Este código da lugar a esta salida:

java.lang.ClassNotFoundException
First attempt:
java.lang.ExceptionInInitializerError
java.lang.IllegalArgumentException
Second attempt:
java.lang.NoClassDefFoundError

Vía | http://java-it-zen.blogspot.com

Relacionados:

1. AspectJ aplicado sobre una librería jar
2. Orden de inicialización en Objetos Java
3. Sobrecarga de métodos en Java

$("div#elem").hide();
$("div#elem").css("width","200");
$("div#elem").show();

Pero presenta un problema: cada vez que se especifica un selector, jQuery recorre todo el DOM en busca de los elementos correspondientes.

Tenemos dos posibles soluciones para mejorar el rendimiento. La primera es “encadenar” las llamadas:

$("div#elem").hide().css("width","200").show();

La segunda es guardar el objeto devuelto por jQuery en una variable:

var myElement = $("div#elem");
myElement.hide();
myElement.css("width","200");
myElement.show();

Esto también es aplicable al objeto “this”. Por ejemplo, para este loop:

$("div").each(function(i) {
   $(this).addClass("myClass");
   if($(this).hasClass("newClass") {
      $(this).addClass("anotherClass");
   }
});

Podríamos implementar algo como esto:

$("div").each(function(i) {
   var $this = $(this);
   $this.addClass("myClass");
   if($this.hasClass("newClass") {
      $this.addClass("anotherClass");
   }
});

Nota: la variable ha sido nombrada $this, en lugar de this, porque esta última es una palabra reservada.

Vía | http://www.thewebsqueeze.com

Relacionados:

1. AJAX + jQuery: elementos HTML dinámicos
2. jQuery: manejo de checkbox
3. jQuery: navegador con soporte WebKit

Supongamos. por ejemplo, que el usuario user1 crea un script “test.sh” que tiene como resultado una escritura sobre un fichero cuyo propietario es el mismo usuario.


#!/bin/bash
dt=`date`
echo $USER $dt >> /home/user1/log
echo "Updated the log file sucessfully."


Supongamos, además, que el usuario quiere dar permiso a otros usuarios para ejecutar este script. En este caso hay dos opciones:

1. Dar permisos de lectura/escritura sobre el fichero /home/user1/log, con el inconveniente que esto conlleva (control de otros usuarios sobre el fichero);
2. Establecer el bit SUID sobre el script:

$ chmod u+s test.sh

Con esto, si listamos los ficheros test.sh y /home/user1/log

$ ls -l test.sh log
-rwsr-xr-x  1 user1 user1 60 Jun 24 21:44 test.sh
-rw-r--r--  1 user1 user1 20 Jun 24 21:44 log

Con esto, cualquier usuario puede ejecutar el script sin tener acceso de escritura al fichero de log. Si, por ejemplo, ejecutamos con el usuario user2, podríamos tener un fichero de log como el que sigue:

user1 Fri Jun 25 08:01:16 IST 2010
user2 Fri Jun 25 08:41:11 IST 2010
user2 Fri Jun 25 08:58:14 IST 2010

Este es, por ejemplo, el mecanismo utilizado para el comando passwd. Este comando, ejecutado por un usuario, modifica el fichero /etc/passwd, que sólo puede ser modificado por el usuario root.

Ojo, porque esta es una de las funcionalidades más peligrosas en entornos UNIX.

Vía | http://unix-school.blogspot.com
Vía | http://www.mmc.igeofcu.unam.mx

Relacionados:

1. Aplicación Offline para iPhone
2. Conversión de archivos de audio en linux

Antes sólo era posible utilizando javascript (este es el método que utiliza, o al menos utilizaba, iWeb, para crear esos efectos).

El código a utilizar es:

<br>
-webkit-box-reflect: <direction> <offset> <mask-box-image><br>

dónde indicamos la dirección en la que mostramos el reflejo, la distancia respecto al objeto original y la máscara que se va a aplicar al reflejo, si es que se aplica alguna.

Ya que podemos crear gradientes usando WebKit, un buen ejemplo sería:

<br>
#reflection {<br>
   font-size:24px;<br>
   color: #f00;<br>
   -webkit-box-reflect: below -5px -webkit-gradient(linear, left top, left bottom, from(transparent), to(rgba(100, 100, 100, 0.4)));<br>
}<br>

Y aquí el resultado:

Texto

Vía | http://webkit.org/

Vía | http://www.dzone.com/

Relacionados:

1. jQuery: navegador con soporte WebKit
2. Javascript: comprobar si navegador soporta WebKit
3. Slider con CSS3 puro y funcionalidad de Back Button

Para ello podemos utilizar el objeto jQuery.browser. Este objeto contiene los siguientes flags:

• webkit (a partir de jQuery 1.4)
• safari (obsoleto)
• opera
• msie
• mozilla

De manera que para comprobar si el navegador soporta WebKit, podemos usar este código:

if($.browser.webkit) {
// do something
}

De la misma manera se puede comprobar si el navegador es uno de los listados más arriba. Además, el objeto tiene un miembro “version” que permite añadir/filtrar código dependiendo del navegador y la versión del mismo. Ejemplo:

if($.browser.msie) {
   alert($.browser.version);
}

Ojo que, tal como indican en la web de la API de jQuery el uso de este objeto está “deprecado”. En su lugar se debería usar jQuery.support, para efectuar comprobaciones más complejas, individuales para cada funcionalidad que se desea chequear.  Con esto se puede activa/desactivar features de la web individualmente.

Sin embargo, aún teniendo en cuenta los riegos, el uso de jQuery.browser es mucho más sencillo y más rápido de implementar.

Relacionados:

1. Javascript: comprobar si navegador soporta WebKit
2. CSS: crear reflejos en navegadores con soporte WebKit
3. Javascript: comprobar si es el navegador de iPhone

En el caso del soporte para WebKit, podemos aplicar un comportamiento diferente si el navegador no soporta, por ejemplo, las transiciones, etc.

Código javascript:

//Initialize our user agent string to lower case.
var uagent = navigator.userAgent.toLowerCase();

var webkitSupport= "webkit";
//**************************
// Detects if the current browser supports WebKit.
function DetectWebKit() {
   if (uagent.search(webkitSupport) > -1)
      return true;
   else
      return false;
}

En el caso de aplicaciones generadas con Dashcode, esta comprobación puede ser suficiente.

Por ejemplo, la versión para móviles de este blog:

http://blog.ilikeblues.com/iphone

se comporta correctamente en iPhone, Android, Chrome, etc.

Relacionados:

1. Javascript: comprobar si el dispositivo es Android
2. Javascript: comprobar si es el navegador de iPhone
3. jQuery: navegador con soporte WebKit

En otro post indicaba cómo hacer la comprobación javascript para detectar si el navegador es de iPhone y redirigirlo al sitio adecuado.

He aquí el código para comprobar si el dispositivo que estamos usando es Android y redirigirlo al mismo sitio que en caso de que sea iPhone, puesto que ambos navegadores soportan la salida generada usando Dashcode:

//Initialize our user agent string to lower case.
var uagent = navigator.userAgent.toLowerCase();

var deviceAndroid = "android";
//**************************
// Detects if the current device is an Android OS-based device.
function DetectAndroid() {
   if (uagent.search(deviceAndroid) > -1)
      return true;
   else
      return false;
}

Vía | http://www.hand-interactive.com

Relacionados:

1. Javascript: comprobar si navegador soporta WebKit
2. Javascript: comprobar si es el navegador de iPhone
3. Conexión a Base de Datos Safari-JavaScript

Hicieron un par de anuncios interesantes, como son:

• la liberación del codec de vídeo VP8, y la presentacion de WebM,
• la nueva versión de GWT, integrada con roo (que, según parece, puede dar mucho juego, al estilo Ruby on Rails),
• la apertura de Wave a todos los públicos, es decir, ya no requiere invitación (yo sigo pensando que la idea es interesante y acabará imponiéndose su uso, sobre todo en entornos de empresa).

Pero lo cierto es que, exceptuando estos anuncios, la presentación fue un poco aburrida, quizás demasiado larga, con intervenciones que, a mi entender, no venían a cuento, como la de Terry McDonell y “su” revista Sports Illustrated, que, más que una demostración de lo que se puede hacer con HTML5, me pareció “una publicidad un tanto descarada”.

Quiero decir que está bien hacer una presentación “superficial” de las posibilidades del nuevo estándard, pero lo de la revista fueron casi 15 minutos dedicados en exclusiva. Como dice un compañero de curro “imagínate lo que Sports Illustrated invierte en publicidad con Google…”.

Por lo demás, debo decir que las comparaciones son odiosas: presentación en el comedor de la oficina, que todo sea dicho, contenía por sí sólo más tecnología que toda la empresa completa en la que trabajo, repleto de comida y bebida (soft, por supuesto) gratis, todo de colores, currantes con MacBooks. Y el futbolín en la recepción, claro, aunque este parecía más atrezzo que otra cosa…

Nota: la foto es del edificio por fuera, porque nos pidieron amablemente que no hiciéramos fotos de la oficina.

Relacionados:

1. Google Chrome Hackaton – Madrid
2. last Hunted – Google Chrome Extension
3. Google Wave Invitations

Tal como explican en este artículo, muchos programadores desconocen la existencia y/o el uso de estas colecciones, creadas especialmente para entornos multihilo, donde resulta fundamental evitar las condiciones de carrera.

CopyOnWriteArrayList

Es habitual encontrar escenarios en los que muchos threads acceden a un array en modo lectura y algunos en modo escritura.

Hacer una copia de un ArrayList en Java es muy costoso computacionalmente (desde el punto de vista del tiempo y de la memoria), así como utilizar un “synchronized ArrayList“.

La solución la encontramos en la clase CopyOnWriteArrayList. El Javadoc dice que “se trata de una versión thread-safe de ArrayList, en la que las operaciones de modificación (add, set, etc.) están implementadas haciendo una copia del array”.

Así pues, esta clase es ideal para escenarios como el descrito más arriba: muchos accesos de lectura y unos pocos de escritura, evitando el coste computacional de los elementos “sincronizados” (synchronized).

BlockingQueue

Esta clase implementa una cola FIFO. La diferencia respecto a Queue es que esta garantiza que cualquier intento de “sacar” un elemento de la cola vacía permanecerá bloqueado a la espera de que la cola contenga algún elemento listo para ser devuelto.

De la misma manera, si la cola está llena, cualquier intento de añadir un elemento a la misma dejará bloqueado al thread correspondiente, a la espera de que haya un hueco.

SynchronousQueue

Esta cola es similar a la interior, excepto por el tamaño: SynchronousQueue siempre tiene tamaño cero, por lo cual, cualquier intento de añadir un elemento dejará bloqueado el thread, hasta que otro haga un intento de “sacarlo”.

ConcurrentMap

La clase Map tiene un bug que podría provocar comportamientos diferentes si dos o más threads intentan modificar su contenido al mismo tiempo (incluso en un bloque “synchronized“). Es decir, se daría una condición de carrera (podéis ver aquí una descripción). Básicamente, los bloqueos se realizan tanto al principio como al final de los métodos get() (usado para comprobar si el mapa contiene un elemento) y put() (usado para añadir un elemento), con lo que un thread podría sobreescribir el contenido añadido por otro.

El problema está resuelto en la clase ConcurrentMap. Esta clase ofrece un método putIfAbsent() que realiza la comprobación y la adición del elemento (si el mapa no lo contiene) dentro de un mismo bloqueo.

Vía | DZone

Relacionados:

1. Singleton en Java
2. Orden de inicialización en Objetos Java
3. Diferencia entre ClassNotFoundException y NoClassDefFoundError

El código para crear un elemento iframe sería:

$('<iframe />');

También podemos crearlo con atributos:

$('<iframe id="myFrame" name="myFrame">');

Para terminar, podemos insertarlo en el DOM:

$('<iframe id="myFrame" name="myFrame">')
   .appendTo('body');

El contenido del iframe se fija a través de su atributo “source”:

$('<iframe />')
   .attr('src', 'http://www.google.com');

En los comentarios del mismo artículo, alguien sugiere, además, esta otra manera de hacerlo:

$('<iframe />', {
   name: 'myFrame',
   id:   'myFrame',
   ...
}).appendTo('body');

Personalmente, prefiero la segunda…

Vía | http://www.itrickz.co.cc

Relacionados:

1. AJAX + jQuery: elementos HTML dinámicos
2. Cómo realizar una petición AJAX usando jQuery
3. AJAX: Convertir HTML a objeto DOM

De manera que podemos utilizar el código:

$("#id").length

…

para determinar si existe algún elemento con el identificador “id” en el DOM.

Ejemplo de código:

if ($("#id").length) {
   $("#id").text("Hello!");
}

Vía | http://eisabainyo.net

Relacionados:

1. AJAX + jQuery: elementos HTML dinámicos
2. Cómo realizar una petición AJAX usando jQuery
3. Crear elementos DOM – HTML dinámicamente usando jQuery

Este es el código que necesitamos para hacer un GET:

$.get("profile.php", { username: "rob" },
   function(response){
      // put the HTML content of profile.php into a div with id = "profile_page"
      $("#profile_page").html(response);
   }
);

Este código realiza una petición de tipo “GET” al mismo servidor en que se encuentra la página cargada, con un único parámetro “uername”, y utiliza el HTML devuelto para construir el contenido de un elemento cuyo identificador es “profile_page”.

De la misma manera podemos hacer una petición “POST”:

$.post("login.php", { username: "rob", password: "secret" },
   function(response){
      if (response == "good"){
         alert("You have logged in successfully.");
      }else{
         alert("Invalid username/password");
      }
   }
);

En este caso, la respuesta será “good” si el login se ejecutó correctamente.

Vía | http://lovehateubuntu.blogspot.com

Relacionados:

1. AJAX + jQuery: elementos HTML dinámicos
2. Crear elementos DOM – HTML dinámicamente usando jQuery
3. AJAX: Convertir HTML a objeto DOM

Pero es que además, su solución evita el problema del “Back Button” en aplicaciones que utilizan jQuery, consistente en que mostrar una parte “oculta” usando jQuery no modifica el historial de navegación, de manera que si el usuario presiona el botón “atrás”, no se vuelve a la situación anterior, sino que el navegador pasa a otra localización.

En fin, veamos un ejemplo (aquí una demostración online, más sencilla que la de la entrada original de Neil).

Primero creamos la lista con los elementos, en este caso 3:

<div id="content">
   <ul>
      <li>
         Text 1
      </li>
      <li>
         Text 2
      </li>
      <li>
         Text 3
      </li>
   </ul>
</div>

Aplicamos las siguientes reglas CSS:

#content, ul, li {
   height: 400px;
   padding: 10px;
}

#content, li { position: relative; width: 500px; }

#content {
   overflow: hidden;
   padding: 10px;

   float:left;
}

ul {
   list-style-type: none;
   position: absolute;
   left: 0px;
   top: 0px;
   width: 500px;
   height: 2000px;
}

Con este CSS conseguimos que, de los tres elementos li apilados en vertical, sólo se vea uno a un tiempo. Inicialmente el primero, de manera que ahora tenemos que proporcionar el mecanismo para desplazar el elemento ul las cantidades suficientes para ver los elementos 2 y 3, respectivamente.

Empezamos colocando los “anchors” al principio de la página. Serán divs sin contenido, ya que su único propósito es que sirvan como selectores CSS:

<div><div id="p1"></div>
<div><div id="p2"></div>
<div><div id="p3"></div>

Y ahora añadimos las reglas CSS, basadas en esos anchors para desplazar el elemento ul:

#p1:target ul { top: 0px; }
#p2:target ul { top: -420px; }
#p3:target ul { top: -840px; }

Listo. Cuando nuestro navegador apunte al anchor #p1 (o simplemente no apunte a ninguno), veremos el primer elemento. Cuando apunte al #p2, al segundo, y así sucesivamente.

Por último, si queremos dar sensación de fluidez al cambio de un elemento a otro, añadimos la siguiente regla CSS:

ul { -webkit-transition: top .3s linear; }

Pero ojo, esto último sólo funciona para navegadores con soporte WebKit.

Eso es todo. En este link podéis encontrar una demostración (a la que se ha añadido unos enlaces muy simples para permitir pasar de un elemento a otro sin necesidad de modificar la URL) y en este otro un zip con el código.

Via | http://www.nealgrosskopf.com

Relacionados:

1. Generar sombra usando CSS puro
2. Usar jQuery para comprobar si existe un elemento
3. Generar Sombra bajo Texto con CSS3

La nueva versión, incluye la posibilidad de configurar si la foto clicada será mostrada en una nueva pestaña o no.

Gracias a @fjcanales por la sugerencia.

[Nota: para actualizar una extensión ya instalada, abrir la pestaña de extensiones, expandir las opciones para desarrolladores (haciendo click en "Modo desarrollador") y pulsar el botón "Actualizar extensiones ahora".]

Relacionados:

1. flickrPlaces – Chrome Extension v1.5
2. last Hunted – Google Chrome Extension
3. Google Chrome Hackaton – Madrid

La nueva versión, a petición popular , incluye persistencia de la última búsqueda realizada.

De manera que, al hacer click en el icono, mostrará el mismo contenido de antes de cerrarla por última vez.

[Nota: para actualizar una extensión ya instalada, abrir la pestaña de extensiones, expandir las opciones para desarrolladores (haciendo click en "Modo desarrollador") y pulsar el botón "Actualizar extensiones ahora".]

Relacionados:

1. flickrPlaces – Chrome Extension v1.6
2. last Hunted – Google Chrome Extension
3. Google Chrome Hackaton – Madrid

Publicada la release 1.0 de “last Hunted”, extensión para Google Chrome que te permite consultar de manera rápida y sencilla los updates de la página principal, así como los de los canales.

Enlace:

http://blog.ilikeblues.com/projects/google-chrome-extensions/last-hunted/

Relacionados:

1. flickrPlaces – Chrome Extension v1.5
2. flickrPlaces – Chrome Extension v1.6
3. Google Chrome Hackaton – Madrid

El plugin se llama “live query“. Veamos un ejemplo sencillo.

Supongamos que partimos del siguiente código:

$(document).ready(function() {
   $(".content").hover(
      function() {
         $(this).stop().animate({paddingLeft: '+100px'}, 1000);
      }
     ,function() {
         $(this).stop().animate({paddingLeft: '10px'}, 1000);
      });
   });

Para aplicarlo a elementos añadidos dinámicamente tendríamos que ejecutar el código:

function callWheneverTheElementsAreLoaded() {
   $(".content").livequery(function() {
      $(this).hover(
         function() {
            $(this).stop().animate({paddingLeft: '+100px'}, 1000);
         }
        ,function() {
            $(this).stop().animate({paddingLeft: '10px'}, 1000);
         });
      },
      function() {
         // unbind the mouseover and mouseout events
         $(this)
            .unbind('mouseover')
            .unbind('mouseout');
      });
}

tras la adición de los mismos al HTML.

Nótese que la llamada a livequery admite dos parámetros:

1. función callback que queremos añadir a los elementos nuevos
2. función callback a ejecutar cuando los elementos sean eliminados

Nota: por supuesto, es necesario añadir la librería live query al html después de la librería jQuery:

<!doctype html>
<html>
<head>
<script type="text/javascript" src="scripts/jquery-1.4.2.min.js">
</script>
<script type="text/javascript" src="scripts/jquery.livequery-1.1.1/jquery.livequery.min.js">
</script>
etc...

personalizando para cada caso los paths y/o nombres de ficheros, etc.

Relacionados:

1. Cómo realizar una petición AJAX usando jQuery
2. Crear elementos DOM – HTML dinámicamente usando jQuery
3. AJAX: Convertir HTML a objeto DOM

<!doctype html>
<html>
   <head>
   </head>
   <body onload="init();">
      <script language="JavaScript">

/**
 * ilikeblues.com (C)
 */

var req = new XMLHttpRequest();

function loaded() {
      var text = req.responseText;

      var domObject = (new DOMParser()).parseFromString(text, "text/xml");
      /* do with DOM object whatever you want... */
      domObject.getElementsByTagName("loquesea");
      ...
}

function init() {
   var url = "http://loquesea.com";

   req.open("GET", url, true);

   req.onload = loaded;
   req.send(null);
}

      </script>
   </body>
</html>

Relacionados:

1. AJAX + jQuery: elementos HTML dinámicos
2. Crear elementos DOM – HTML dinámicamente usando jQuery
3. Cómo realizar una petición AJAX usando jQuery

Liberada la versión 1.0 para instalación “offline” en la pantalla de incio de iPhone/iPod Touch de AsistenteJeVWeb.

Sigue las instrucciones en el siguiente enlace:

AsistenteJeVWeb

Sucesivas versiones incluirán más “features” y más lecciones gramaticales.

Esta versión funciona en navegadores que soporten HTML5 y WebKit (probado en Chrome 5 y Safari 4).

Relacionados:

1. AsistenteJeVWeb v0.1 released
2. Javascript: comprobar si navegador soporta WebKit
3. jQuery: navegador con soporte WebKit

El tema es que, es imprescindible configurar correctamente el servidor en que está colgada la aplicación para que, al cargarla en el iPhone, éste la “cachee” adecuadamente.

El “quid”: el fichero declarado como manifest debe ser interpretado por el servidor con el MIME type “text/cache-manifest”. En otro caso, por ejemplo “text/plain”, al intentar abrir la aplicación en ausencia de conexión, obtendremos un error.

Si el servidor es Apache (no conozco ninguno más, al fin y al cabo, soy desarrollador, no administrador) es relativamente sencillo. Necesitamos un fichero .htaccess en la misma carpeta en que se encuentre la aplicación, con el sigueinte contenido:

AddType text/cache-manifest .manifest

Por supuesto el fichero manifest deberá tener la extensión “.manifest”, en otro caso la directiva no sirve para nada.

Además, el servidor Apache debe estar correctamente configurado para que interprete nuestro fichero .htaccess.

Relacionados:

1. iPhone SDK: Registrar una clase como observador de un evento
2. Utilización de gprof/gcov para obtención de datos de cobertura (I)
3. Aplicación RCP en pantalla completa

En CSS3, crear la sombra para un texto es bastante sencillo. El problema es el soporte que los navegadores dan a las “features” del nuevo standard. Esta propiedad está soportada por Opera, Safari Chrome y Firefox (lo siento no tengo Windows para probar IE).

El código CSS:

text-shadow: 20px -12px 2px #6374AB;

Las propiedades indican desplazamiento en x, en y, radio de desenfoque y color de la sombra respectivamente.

Los primeros valores pueden darse en diferentes unidades, por ejemplo:

text-shadow: 0.5em 0.5em 0.2em #600;

También puede crearse más de una sombra para un texto:

text-shadow: 1.5em -1.5em 0.2em #600, 1.5em 1.5em 0.2em #060, -1.5em 1.5em 0.2em #06;

Relacionados:

1. Generar sombra usando CSS puro
2. Slider con CSS3 puro y funcionalidad de Back Button
3. CSS: crear reflejos en navegadores con soporte WebKit

.shadow {
   box-shadow: 3px 3px 4px #000;
}

El significado de los valores es más o menos fácil de adivinar: desplazamiento vertical, desplazamiento horizontal, radio de desenfoque y color.

Sin embargo, los navegadores aún no soportan por completo el nuevo estándar. Ahí va una solución:

.shadow {
   -moz-box-shadow: 3px 3px 4px #000;
   -webkit-box-shadow: 3px 3px 4px #000;
   box-shadow: 3px 3px 4px #000;
   /* For IE 8 */
   -ms-filter: "progid:DXImageTransform.Microsoft.Shadow(Strength=4, Direction=135, Color='#000000')";
   /* For IE 5.5 - 7 */
   filter: progid:DXImageTransform.Microsoft.Shadow(Strength=4, Direction=135, Color='#000000');
}

Vía | Robert’s talk

Relacionados:

1. Generar Sombra bajo Texto con CSS3
2. CSS: crear reflejos en navegadores con soporte WebKit
3. Slider con CSS3 puro y funcionalidad de Back Button

Ayer, 18 de marzo de 2010, tuvo lugar en Madrid (en la Facultad de Informática de la Universidad Complutense de Madrid), el Google Chrome Hackaton, al que muy amablemente me invitaron.

Hay que decir que la organización fue buena, excepto por un par de cosillas, como que empezaron una hora tarde y que el sitio para la “merienda” era un poco pequeño.

Los ponentes fueron Ernest Delgado y Arne Roomann-Kurrik, ingenieros de desarrollo en la empresa de Mountain View, y la verdad es que lo hicieron muy bien (insisto, excepto por los problemas de tiempo, que hicieron que tuvieran que ir un poco deprisa en algunas partes de la conferencia).

Después de las conferencias estuvieron echando una mano a los presentes en el desarrollo de extensiones, resolviendo dudas, mostrando las herramientas de debug, etc. Muy cercanos, muy al estilo de Google.

En fin,  enhorabuena a los organizadores y a los ponentes. Fue un “hackaton” ameno e instrucitvo.

Dejo algunos enlaces con la documentación:

• Hackaton in a box: http://bit.ly/ady30c
• Google Chrome Extensions (Lab): http://bit.ly/9sXFmc
• Content How To Example: http://bit.ly/bXrGCQ

Relacionados:

1. last Hunted – Google Chrome Extension
2. flickrPlaces – Chrome Extension v1.6
3. Google I/O livestream en las oficinas de Madrid

• Obtener información:

   $ sox fichero.wav

• Reproducir audio:

  $ play fichero.wav

• Grabar archivo:

  $ rec -r 8000 -c 1 fichero.wav

  → graba con un muestreo de 8 kbps y a un canal (la extensión determina el formato).

• Convertir:

  $ sox fichero.wav fichero.ogg

  → convierte el fichero del formato “wav” a “ogg”

• Acelerar:

  $ sox fichero.wav acelerado.wav speed 2.0

• Recortar:

  $ sox fichero.wav recortado.wav trim 60 10

  → devuelve los 10 segundos posteriores al primer minuto.

• Escuchar podcast:

  $ play http://dondesea.com/ficheros/audio/podcast.mp3

La instalación de Ubuntu es muy sencilla:

$ sudo apt-get install sox libsox-fmt-all

Para otras plataformas: http://sox.sourceforge.net

La reproducción, grabado y/o conversión desde/hacia mp3 requiere de la librería lame.

Via | http://bitelia.com

Relacionados:

1. SUID: permisos para otros usuarios

Para un proyecto con múltiples carpetas que contienen este tipo de ficheros lo más sencillo es:

$ svn propset svn:ignore -F $HOME/ignore_file . -R

donde -R indica que se haga de manera recursiva desde “.” (el directorio actual) y -F indica que se tomen las reglas de exclusión del fichero inficado.

El contenido del fichero ignore_file podría ser, por ejemplo:

*.o
*.so
*.exe

Con esto quedaráin excluidos los ficheros objeto, las librerías compartidas y los ejecutables (suponiendo que todos tengan nombres acabados en .exe).

Para ello es necesario que indiquen correctamente la dirección de email al escribir el comentario (no es necesario publicarlo en el texto).

Cerraré los comentarios cuando ya no queden invitaciones.

Do not forget to fulfill the email field in the comment form.

Comments on the post will be closed where there are no invitations left to be sent.

Relacionados:

1. Google I/O livestream en las oficinas de Madrid
2. Google Chrome Hackaton – Madrid
3. last Hunted – Google Chrome Extension

En mi último viaje a Japón compré un Kohjinsha SC3 que monta este chipset. Así que he generado un pequeño paquete que permite compilar e instalar el driver en Ubuntu 9.10 (Karmic Koala).

Podéis descargar los fuentes aquí:

driver_staging_vt6656.tgz

Al descomprimirlo generará una carpeta llamada “driver”. Basta con hacer (dentro de la carpeta generada):

$ sudo make install

para que se añada el driver al arranque de Ubuntu. Si ejecutamos:

$ modprobe vntwusb

el driver se cargará y podremos conectar a la red usando nuestra tarjeta wifi con chipset VT6656.

Por último decir que, tal como indican en el thread relacionado con el bug, sólo funciona la encriptación WPA2. No funcionan ni WPA ni la mixta (WPA+WPA2).

Que lo disfrutéis.

Relacionados:

1. Aplicación Offline para iPhone
2. Configuración proxy en Ubuntu

function iPhoneCheck() {
var agent = navigator.userAgent.toLowerCase();
var iphone = (agent.indexOf('iphone')!=-1);
if (iphone) {
return true;
} else {
return false;
}
}

Vía: http://blog.unijimpe.net/detectar-browser-iphone/

Relacionados:

1. Javascript: comprobar si navegador soporta WebKit
2. Javascript: comprobar si el dispositivo es Android
3. jQuery: navegador con soporte WebKit

try {
   if (!window.openDatabase) {
      alert('not supported');
   } else {
      var shortName = 'mydatabase';
      var version = '1.0';
      var displayName = 'My Important Database';
      var maxSize = 65536; // in bytes
      var mydb = openDatabase(shortName, version, displayName, maxSize);

      // You should have a database instance in mydb.
   }
} catch(e) {
   // Error handling code goes here.
   if (e == 2) {
      // Version number mismatch.
      alert("Invalid database version.");
   } else {
      alert("Unknown error "+e+".");
   }
   return;
}

alert("Database is: "+mydb);

Con esto, sin más que implementar las transacciones necesarias, podemos hacer persistente la información cargada durante la sesión para su uso posterior.

Estas bases de datos se pueden utilizar para la implementación de aplicaciones Offline mediante Safari.

Para eliminar estas bases de datos creadas por aplicaciones web, basta con ir a la sección “Safari” de los ajustes del iPhone.

Vía: Safari Client-Side Storage and Offline Applications Programming Guide

Relacionados:

1. Javascript: comprobar si navegador soporta WebKit
2. Utilización de gprof/gcov para obtención de datos de cobertura (I)
3. AsistenteJeVWeb v1.0 released

La clase que contiene este código:

1. Recibirá notificaciones de disparo del evento “dataChangeEvent”.
2. Debe implementar el método “onDataChagneEvent”.

Cuando algún otro objeto dispare el evento, las instancias de esta clase recibirán la notificación y ejecutarán el método especificado.

Relacionados:

1. Aplicación Offline para iPhone
2. C++: excepción en construtor o destructor

A efectos prácticos, supongamos un único fichero jar llamado “underTest.jar” (los resultados son extensibles) y la clase que contiene el método “main” es “MainClass”, dentro del paquete “mainpack”:

public class MainClass {
public MainClass() {
}

/**
* @param args
*/
public static void main(String[] args) {
System.out.println("Ejecutando el main...");
}

}

Así, el comando para ejecutar la aplicación sería:

java -classpath underTest.jar mainpack.MainClass

El resultado de la ejecución sería:

Ejecutando el main...

En este caso, podemos utilizar AspectJ para insertar puntos de ruptura, logear información de ejecución, de performance, etc.

Vamos con la prueba de concepto.

En primer lugar, vamos a crear una librería (jar) con los “aspectos” a utilizar. En este caso, algo muy simple: una clase que traza la entrada y la salida del método “main” de nuestra aplicación.

El código sería:

public aspect ProfilingAspect {

pointcut mainMethod() : execution(static * *.main(..));

before() : mainMethod()
{
System.out.println("Entrando al main...");
}

after() : mainMethod()
{
System.out.println("Saliendo del main...");
}

}

Podemos usar eclipse para crear un proyecto de tipo AspectJ, compilarlo y generar un fichero jar con soporte para AspectJ (echar un vistazo a las Cheat Sheets de eclipse con el plugin AJDT).

Supongamos que el fichero jar creado con el “aspecto” anterior es mainAspect.jar.

El siguiente paso sería modificar el comando utilizado para ejecutar la aplicación:

java
-classpath $ASPECTJ_HOME/aspectjweaver.jar:$ASPECTJ_HOME/aspectjrt.jar:.
-Djava.system.class.loader=org.aspectj.weaver.loadtime.WeavingURLClassLoader
-Daj.class.path=mainAspect.jar:underTest.jar
-Daj.aspect.path=mainAspect.jar
mainpack.MainClass

Donde $ASPECTJ_HOME apunta al directorio de instalación de las librerías de AspectJ (aspectjweaver.jar y aspectjrt.jar) en la máquina. Con esto el resultado de la ejecución sería:

Entrando al main...
Ejecutando el main...
Saliendo del main...

Relacionados:

1. Utilización de gprof/gcov para obtención de datos de cobertura (I)
2. Orden de inicialización en Objetos Java
3. Sobrecarga de métodos en Java

class NetworkService {
    private final ServerSocket serverSocket;
    private final ExecutorService pool;

    public NetworkService(int port, int poolSize) throws IOException {
      serverSocket = new ServerSocket(port);
      pool = Executors.newFixedThreadPool(poolSize);
    }

    public void serve() {
      try {
        for (;;) {
          pool.execute(new Handler(serverSocket.accept()));
        }
      } catch (IOException ex) {
        pool.shutdown();
      }
    }
  }

  class Handler implements Runnable {
    private final Socket socket;
    Handler(Socket socket) { this.socket = socket; }
    public void run() {
      // read and service request
    }
 }

Relacionados:

1. Sobrecarga de métodos en Java
2. Java: usar enumeración en un switch
3. Orden de inicialización en Objetos Java

En general, no se debería lanzar una excepción durante la ejecución de un constructor sin hacer un catch de la misma y llevar a acabo una “limpieza” de los recursos utilizados por la clase. Una solución sencilla podría ser utilizar el constructor por defecto para crear los miembros “seguros” de la clase y después llamar a un método de inicialización para los “no seguros”, incluyendo el exception handling en éste.

Veamos un ejemplo sencillo. Supongamos que tenemos el siguiente código:

class Employee {
   ...
   Image * m_pImage;
   AudioClip * m_pAudio;
};

Employee(..., string image, string audio) : ..., m_pImage(NULL), m_pAudio(NULL)
{
   ...
   m_pImage = new Image(image);
   m_pAudio = new AudioClip(audio); // throw point
}

Si el código “new AudioClip(audio)” lanza una excepción, el flujo de control sale del constructor y se produce un memory leak. El destructor sólo sería llamado si el objeto hubiera sido completamente construido, pero no ha sido así.

Entonces, la manera correcta de implementar ese constructor sería:

Employee(..., string image, string audio) : ..., m_pImage(NULL), m_pAudio(NULL)
{
   ...
   try {
      m_pImage = new Image(image);
      m_pAudio = new AudioClip(audio);
   }
   catch(...)
   {
      delete m_pImage;
      delete m_pAudio;
      throw;
   }
}

De manera que, si se levanta una excepción, los recursos reservados son liberados y se vuelve a despachar la excepción para que notificar al objeto que intentaba construir esta clase.

Esta solución es buena, funciona bien, excepto en el caso de que tengamos punteros constantes como miembros de la clase:

class Employee {
   ...
   Image * const m_pImage;
   AudioClip * const m_pAudio;
};

Estos miembros deben ser incializados por el incializador de miembros propio de la clase, donde no podemos poner bloques try… catch.

En este caso, podríamos utilizar la clase auto_ptr<> (o similar) como wrapper para los punteros, de manera que se conviertan en objetos locales a nuestra clase:

class Employee {
   ...
   auto_ptr<image> m_pImage;
   auto_ptr<audioClip> m_pAudio;
};

Como ya se ha dicho, si ocurre una excepción durante la ejecución del constructor, se ejecutan los destructores de todos los miembros locales a la clase. Es decir, se llamaría al destructor de auto_ptr<>, el cual libera, de la manera adecuada, todos los recursos reservados.

[Fuente: http://progtutorials.tripod.com]

Relacionados:

1. Diferencia entre ClassNotFoundException y NoClassDefFoundError

Basta con añadir algunas directivas de inclusión de ficheros y la lista de ficheros de código:

include $(GNUSTEP_MAKEFILES)/common.make

APP_NAME = edictParser
edictParser_APPLICATION_ICON = icon.png
edictParser_RESOURCE_FILES = icon.png
edictParser_OBJC_FILES = main.m

include $(GNUSTEP_MAKEFILES)/application.make

Para el caso de querer utilizar código C++, sustituimos la línea:

edictParser_OBJC_FILES = main.m

por:

edictParser_OBJCC_FILES = main.mm

Y un pequeño truco para no tener que modificar el makefile cada vez que añadimos un fichero de código:

edictParser_OBJCC_FILES = $(shell ls -c1 *.mm)

[Nótese que la extensión para los ficheros Objective-C++ es mm.]

Relacionados:

1. Utilización de gprof/gcov para obtención de datos de cobertura (I)
2. Llamadas a funciones estáticas externas en C

UPDATE [nombre_tabla] SET [nombre_campo] =
REPLACE([nombre_campo],'[cadena_actual]','[cadena_nueva]');

Por ejemplo:

UPDATE articulo SET cuerpo =
REPLACE(cuerpo,'à','á');

Por ejemplo, si vamos a utilizar expresiones regulares con caracteres no-ASCII (como la ñ o los caracteres acentuados).

Para establecer el locale, podemos utilizar el código:

const char* locstr = setlocale(LC_ALL, "es_ES.UTF8");

if (locstr == NULL) {
   printf("SETLOCALE ERROR!\n");
}

[Consultar API para setlocale.]

Si como ejemplo, buscamos la expresión regular “ñ” dentro de la cadena “este año es muy frío”, obtendremos un resultado diferente, dependiendo del locale definido:

1. Si se ha definido el locale “es”:

   start offset: 6
   end offset:  8
   

2. Si el locale es, por ejemplo, “us”:

   start offset: 6
   end offset:  7
   

Ya conocemos los problemas que presenta C/C++ para tratar caracteres unicode. Pero, al menos, podemos hacer búsquedas y sustituciones de una manera más fiable si el locale definido es el adecuado.

Relacionados:

1. Expresiones regulares C
2. Aplicación Offline para iPhone

regex_t regex;
const int MAXMATCHES = 1;

regmatch_t matches[MAXMATCHES];

const char* str = "Look inside this string...";
const char* patt = "side";

size_t size = MAXMATCHES;

int cflags = REG_EXTENDED|REG_ICASE;
int eflags = cflags;

int result = 0;
int rescomp = regcomp(&regex, patt, cflags);
if (rescomp == 0) {
   result = regexec((const regex_t*)&regex, str, size, matches, eflags);
}
if (result == REG_NOMATCH) {
   printf("NOT MATCHED!");
} else {

   for (int i = 0;i < MAXMATCHES;i++) {
      regoff_t startOff = matches[i].rm_so;
      regoff_t endOff   = matches[i].rm_eo;

      if (startOff != -1) {
         printf("start offset:  %i", startOff);
         printf("end offset:   "%i, endOff);
      }
   }
}

Este código imprimirá en el terminal la siguiente salida:

start offset: 7
end offset:  11

Es decir, delimita el trozo de cadena que “machea” la expresión regular.

[En este enlace se puede consultar cómo construir expresiones regulares POSIX.]

Relacionados:

1. Establecer el “locale” para una aplicación C/C++
2. Llamadas a funciones estáticas externas en C

La solución es utilizar el comando wget:

$ wget -r --user=nombre-usuario --password=pass ftp://nombre-dominio:puerto/path

Por ejemplo:

$ wget -r --user=ilikeblues --password=cutrepass ftp://midominio.com/micarpeta

Relacionados:

1. SUID: permisos para otros usuarios

Existen dos formas comunes de implementar una clase singleton en Java, que son: utilizar una instancia “public static final” o bien utilizar el método de “static factory” (podéis ver ejemplos en la wikipedia).

Sin embargo, existe un tercer método. Probablemente, este es el mejor, si se usa una versión de Java superior a la 1.5.

Se puede utilizar un “enum” . De esta manera, se obtinene la funcionalidad del Singleton de una manera muy sencilla, además de que no se necesita implementar la serialización, ya viene “de fábrica”:

package electro;

public enum YourSingleton {
   INSTANCE;

   public void doStuff(String stuff) {
      System.out.println("Doing " + stuff);
   }
}

Así, podemos utilizarla completamente seguros de que es singleton:

YourSingleton.INSTANCE.doStuff("some stuff");

Relacionados:

1. Enumeraciones en Java
2. Sobrecarga de métodos en Java
3. Orden de inicialización en Objetos Java

Los navegadores suelen ser fáciles de configurar. Sin embargo,¿cómo hacer para que, por ejemplo, apt-get funcione correctamente?

Es bastante sencillo: sólo hay que añadir estas líneas al final del fichero /etc/profile:

http_proxy=http://{nombre_de_usuario}:{contraseña}@{proxy_server}:{puerto_proxy}/
export http_proxy

Por ejemplo:

http_proxy=http://pepito:grillo@proxy.midominio.com:8080/
export http_proxy

Reboot y listo. apt-get, y el resto de aplicaciones que hacen conexiones de tipo http a internet, funcionando correctamente.

Relacionados:

1. VT6656 Driver para Ubuntu Karmic Koala

Espero que lo disfrutéis…

http://www.bgoncalves.com/notes/2008/04/20/30-free-online-books/

Relacionados:

1. No, idiota, eso no es “gratis”

El código:

fullScreenAction = new Action("Full Screen") {
   {
      setId("fullscreen");
      setActionDefinitionId("mypluginid" + "fullscreen");
   } //$NON-NLS-1$

   public void run() {
      // grab an IWorkbenchWindow and fullscreen it
      window.getShell().setFullScreen(true);
   }
};

Es muy simple. Para más información, tenéis este post.

[Este post es una traduccion de este otro, publicado en dzone.]

Relacionados:

1. Singleton en Java
2. Sobrecarga de métodos en Java
3. AspectJ aplicado sobre una librería jar

Si una función se ha declarado estática para restringir el acceso a la misma, para no incluirla en el API del módulo, ¿por qué “bypassear” la funcionalidad y acceder a ella?

En mi caso, la respuesta es sencilla: pruebas unitarias. ¿Cómo hacer pruebas unitarias de estas rutinas?

La respuesta es, creando punteros a estas rutinas, accesibles desde otros módulos. Y puesto que cualquier solución implica cambios en los módulos a probar, en el ejemplo a continuación trataré de ser lo menos “intrusivo” posible.

Supongamos el módulo stfunc.c:

#include <stdio.h>
static int funcprintf(const char* str) {
   return printf(str);
}

Para probar esta rutina, tenemos esta otra, en otro fichero diferente (main.c):

int main() {
   int a = funcprintf("Loquesea");
   return a;
}

Si intentamos compilar, obtenemos el error “undefined reference to `funcprintf’”.

Así pues, vamos a crear un puntero a esta rutina para permitir el acceso a la misma desde el módulo de prueba. Creamos un fichero llamado ptrdefs.h:

#ifndef _PTRDEFS_H
#define _PTRDEFS_H
int (*fpointer)(const char*) = &funcprintf;
#endif

Y modificamos los ficheros anteriores de esta manera:
Fichero stfunc.c:

#include <stdio.h>

static int funcprintf(const char* str) {
   return printf(str);
}

#ifdef UNIT_TESTING
#include
<ptrdefs.h>
#endif

Fichero main.c:

int main() {
   int a = fpointer("Loquesea");

   return a;
}

Con esto, basta añadir la opción -DUNIT_TESTING para tener acceso a la rutina.

Por tro lado, el fichero ptrdefs.h sólo estará disponible para los tests unitarios. Esto evita el acceso indeseado.

[Código completo del ejemplo: static.tgz]

Relacionados:

1. Expresiones regulares C
2. Utilización de gprof/gcov para obtención de datos de cobertura (I)
3. Utilización de gprof/gcov: cobertura de ramas (y II)

Para empezar, una breve reseña acerca de la sobrecarga de métodos. Decimos que un método ha sido “sobrecargado” cuando han sido creados múltiples métodos con el mismo nombre, pero especificando distintos argumentos (en número o tipo).

Como ejemplo veamos este trozo de código:

class Dog {
   public static void main(String[] args) {
      bark();    // prints "no param"
      bark(100); // prints "with param"
   }

   public static void bark() {
      System.out.println("no param");
   }

   public static void bark(int decibels) {
      System.out.println("with param");
   }
}

En este caso, se ejecuta un método u otro dependiendo de si se especifica un parámetro en la llamado o no.

Supongamos ahora una situación como la siguiente:

class Animal {}

class Dog extends Animal {}

class TestOverload {
   public static void main (String[] args) {
      Animal a1 = new Animal();
      Animal a2 = new Dog();
      Dog d = new Dog();
      makeSound(a1);
      makeSound(a2);
      makeSound(d);
   }

   public static void makeSound(Animal a) {
      System.out.println("Making animal sound");
   }

   public static void makeSound(Dog d) {
      System.out.println("Making dog sound");
   }
}

A priori, podríamos pensar que la salida es:

Making animal sound
Making dog sound
Making dog sound

Sin embargo, la salida es:

Making animal sound
Making animal sound
Making dog sound

La razón es que Java determina qué versión del método sobrecargado va a ser llamada en tiempo de compilación.

Así pues, aunque a referencia a2 apunta a una instancia del objeto Dog, el compilador utiliza una referencia de tipo Animal para determinar cual de los métodos será llamado.

A continuación un ejemplo de lo peligroso que puede llegar a resultar esto. Un ejemplo en que la salida del programa no permite distinguir cual de los métodos está siendo ejecutado:

class Animal {
   public void doMakeNoise() {
      System.out.println("Making animal noise");
   }
}

class Dog extends Animal {}

class TestOverload {
   public static void main (String[] args) {
      Animal a1 = new Animal();
      Animal a2 = new Dog();
      Dog d = new Dog();
      makeSound(a1);
      makeSound(a2);
      makeSound(d);
   }
   public static void makeSound(Animal a) {
      a.doMakeNoise();
   }
   public static void makeSound(Dog d) {
      d.doMakeNoise();
   }
}

La salida sería:

Making animal noise
Making animal noise
Making animal noise

Esto se debe al polimorfismo y la llamada a doMakeNoise añadida en cada uno de los métodos makeSound.

Evidentemente, esto no es un problema si la funcionalidad final es la misma (pero en este caso se necesitaría una reorganización de código).

Lo importante, en cualquier caso, es tener en mente que Java determina el método sobrecargado a ejecutar en tiempo de compilación.

Relacionados:

1. Orden de inicialización en Objetos Java
2. Singleton en Java
3. Diferencia entre ClassNotFoundException y NoClassDefFoundError

Supongamos el siguiente fichero de código main.c:

En este caso, el script de compilación y ejecución será compexec.sh:

Nótese como la herramienta gcov ha sido ejecutada con las opciones -b y -c. Según “man gcov”:

1. -b
   –branch-probabilities
   Write branch frequencies to the output file, and write branch summary info to the standard output. This option allows you to see how often each branch in your program was taken. Unconditional branches will not be shown, unless the -u option is given.
2. -c
   –branch-counts
   Write branch frequencies as the number of branches taken, rather than the percentage of branches taken.

Es decir, pedimos a la herramienta que devuelva información sobre ejecución de las “ramas lógicas”, dando como resultado el fichero main.c.gcov:

Aquí podemos ver información, aunque un tanto críptica, sobre la ejecución de dos bloques if-else. Como puede verse, cada uno de ellos presenta cuatro ramas, numeradas de “branch 0″ a “branch 3″. Veamos a continuación la explicación de estos datos:

Supongamos la condición:

if (a || b) {
   x;
} else {
   y;
}

Esta condición (o combinación de condiciones) da lugar a 4 ramas, que se corresponden con las posibles combinaciones de valores booleanos de las dos variables:

a b
—-
0 0
0 1
1 0
1 1

Podemos reescribir esta condición como:

if (a == false) {
   // Branch 0
   if (b == false) {
      // Branch 2
      y;
   } else {
      // Branch 3;
      x;
   }
} else {
   // Branch 1
   x;
}

Supongamos ahora la condición:

if (a && b) {
   x;
} else {
   y;
}

Como antes, esta condición (o combinación de condiciones) da lugar a 4 ramas, que se corresponden con las posibles combinaciones de valores booleanos de las dos variables:

a b
—-
1 1
1 0
0 1
0 0

Podemos reescribir esta condición como:

if (a == true) {
   // Branch 0
   if (b == true) {
      // Branch 2
      x;
   } else {
      // Branch 3;
      y;
   }
} else {
   // Branch 1
   y;
}

En cualquiera de los casos anteriores, la herramienta gcov (con las opciones -bc) nos devuelve el número de veces que cada una de las ramas nombradas más arriba ha sido ejecutada.

Si se omite la opción -c, los resultados son porcentajes, de manera que la suma de las ejecuciones de todas las ramas deberá ser el 100 %.

Además, se puede deducir que, en cualquiera de los casos:

1.- (nº de ejecuciones de rama 0) + (nº ejecuciones rama 1) = (nº ejecuciones
del if

2.- (nº ejec rama 2) + (nº ejec rama 3) = (nº ejec rama 1)

En conclusión, podemos deducir qué líneas de código y ramas lógicas han sido ejecutadas y añadir/modificar los test cases necesarios para alcanzar la cobertura deseada.

[Código completo y resultados.]

Relacionados:

1. Utilización de gprof/gcov para obtención de datos de cobertura (I)

Para empezar el código fuente, main.c:

A continuación, las instrucciones de compilación y ejecución, compexec.sh:

Como se puede apreciar, son tres las opciones añadidas al compilador/linkador para obtener los resultados esperados:

1. -pgEsto es lo que dice “man gcc” acerca de esta opción:

   “Generate extra code to write profile information suitable for the analysis program gprof. You must use this option when compiling the source files you want data about, and you must also use it when linking.”

   Es decir, prepara el ejecutable para generar información suscpetible de ser utilizada por gprof para obtener información de “profiling”. Tras la ejecución de la aplicación generada con esta opción, se crea el fichero gmon.out.

2. -ftest-coverage
3. -fprofile-arcsEstas dos opciones son las que indican al compilador que, durante la ejecución de la aplicación, debe generarse información de cobertura.

   [La salida "man gcc" para estas opciones es demasiado larga para incluirla aquí, pero puede verse en este enlace.]

   El ejecutable compilado/linkado con estas opciones genera los ficheros main.gcno y main.gcda, que contienen los datos utilizados por gcov para generar información “legible” de cobertura.

Así pues, una vez ejecutada la aplicación y obtenidos estos ficheros, basta con ejecutar el comando gcov:

$ gcov main.c

(tal como se ha incluido en el fichero compexec.sh) y como resultado se obtiene el fichero main.c.gcov:

El fichero de resultados muestra el número de veces que un statement ha sido ejecutado.

Las instrucciones marcadas con “#####” son aquellas no cubiertas por la ejecución de la aplicación.

[Código completo y resultados.]

Relacionados:

1. Utilización de gprof/gcov: cobertura de ramas (y II)
2. AspectJ aplicado sobre una librería jar
3. Aplicación Offline para iPhone

As soon as you go back to a previously written line of code (to read, check or even rewrite it…), you are entering the “maintenance mode”. That’s the reason why code maintainability is so important in software engineering. And, since mainly working on pseudo real-time systems (such as wireless sensor networks), performance in our tools is another important point.

So, TPTP eclipse plugin is a very useful tool for us. We integrate it in our projects from the very beginning of the development process.

From my point of view these are the strong TPTP plugin points:

1. Code Analyzer: it is fast, intuitive and highly configurable. A newbie will not spend more than five minutes to adapt it to his needs and correctly use it.
2. The “Quick Fix” functionality: in most cases, the solution proposed is pretty good.
3. The Profiling tool: though mainly interested in execution time and method coverage, I stated that this plugin covers many other useful functionalities.

On the other hand, there are some features that, of course from my point of view, should be improved.

Most of our application prototypes are being deployed as RCPs. And RCPs profiling executions are not completely working in all of our different development environments. In fact, Eclipse Europa environment and last TPTP plugin version (4.4) has been the first to give some information about that kind of applications (maybe due to unsatisfied dependencies in our previous environments).

In conclusion, some improvements in executions profiling will make this so helpful plugin be an indispensable tool for Java developers and SW engineers.

Relacionados:

1. Eclipse: Acceder a recursos de un plugin
2. Aplicación RCP en pantalla completa
3. AspectJ aplicado sobre una librería jar