Selenium IDE
A la hora de testear aplicaciones web, sin importar la tecnología que usemos, es deseable tener un buen aliado. Selenium, Windmill, HttpUnit son frameworks que permiten realizar un testeo vertical de la aplicacion web simulando ser un cliente HTTP. HttpUnit es mi favorito pero los tests se codifican en Java usando una API especifica por lo que no es apto para todos los entornos.
Selenium es un framework permite desarrollar testeos de forma declarativa y ejecutarlos tantas veces como se nos antoje. Selenium IDE simplifica la tarea de creación de los tests mediante una interfaz bastante intuitiva que se integra como plugin en Firefox.
Referencias en Java II: referencias débiles
En un post anterior escribí sobre los distintos tipos de referencias a objetos que se pueden usar en Java. Hoy propongo echar mano a un poco de código y ver como se utilizan las referencias débiles, ó weak references.
El secreto de todo esto de las referencias se encuentra en el package java.lang.ref que consta de un par de clases:
+ Reference
+WeakReference
+PhantomReference
+SoftReference
+ ReferenceQueue
WeakReference es la clase que nos ocupa hoy y sirve para instrumentar a las famosas referencias débiles que mencione tiempo atras. Mirando todo mas pragmaticamente la diferencia entre estas weakreferences y las referencias fuertes radica en el momento de la creacion y el posterior acceso al objeto al que esta apunta. El siguiente codigo muestra el caso tipico entre dos objetos que se referencian mutuamente. La vista representa una pantalla de programa y Modelo algun objeto de dominio de negocio. Ambos objetos necesitan referencias al otro para implementar el patron observer que permita la comunicación correcta de estos dos componentes.
class Vista {
Modelo modelo;
public void imprimirModelo() {
System.out.println(modelo.value);
}
public void setModelo(Modelo m) {
modelo = m;
}
}
class Modelo {
int value;
WeakReference<Vista> vista; //referencia debil a la vista
public boolean existsVista() {
return this.vista.get()!=null;
}
public void actualizarVista() {
Vista miVista = this.vista.get(); //miVista es referencia fuerte a vista
//le avisa a la vista q cambio el modelo y debe actualizarse
//miVista.update();
}
public WeakReference<Vista> getVista() {
return vista;
}
public void setVista(Vista v) { //setter con weakreferences
vista = new WeakReference<Vista>(v);
}
}
La clase vista no tiene ningun comportamiento extraño, no podemos decir lo mismo de la clase Modelo. En ella vemos que la declaracion de una referencia debil se hace mediante la clase WeakReference indicando con generics la clase a la que va a apuntar esta referencia, en nuestro caso Vista.
Los accesors a este atributo son un tanto particulares, el setter recibe una referencia fuerte a Vista y que es envuelta con el constructor de WeakReference y finalmente asignada al atributo. El getter, sin embargo, devuelve un objeto de clase WeakReference. Con este objeto podemos obtener una referencia fuerte al objeto vista utilizando el metodo get().
El metodo existsVista() simplemente devuelve verdadero o falso indicandonos si existe el objeto al que apunta la referencia vista o si ya fue eliminado por el gc.
Un caso tipico de uso de estas clases, a saber:
public class Main {
public static void main(String[] args) {
Modelo m = new Modelo(); //creamos el modelo
Vista v = new Vista(); //creamos la vista
v.setModelo(m); //se aparean la vista y el modelo
m.setVista(v); //hay que recordar que setVista envuelve
//el parametro con una WeakReference
m.value = 77;
v.imprimirModelo();
//Imprime 77... como podria esperarse
v = null; //no queremos usar más la vista.
System.gc(); //pasa el basurero
System.out.println(m.existsVista());
}
}
Imprime false porque la referencia fuerte que apuntaba a la vista ya no lo hace. La unica referencia a ese objeto que queda es el atributo del modelo, que por ser una referencia debil el gc la ignora.
Recomiendo pasar estos pedazos de códigos por el amigo debugger e ir siguiendo el movimiento de las referencias y como desaparecen los objetos por arte de magia. En otro momento seguimos con las referencias fantasmas y blandas.
Puzzle!
¿Qué imprime este programa y por qué?
public class Puzzle {
public static void main(String args[]) {
int x = 0x3;
// AYUDITA: public class declara// una nueva clase. main es el metodo
// principal o entry point //del programa y String[] almacena un array
// de String que son // cadenas de caracteres que se guardan usando
// unicode que es un conjunto //de caracteres donde la letra a se escribe
// con \u0061 la letra b // con \u0062 y linefeed se representa con
// \u000A x++; // se usa para postincrementar una variable x//
// ++x;// se utiliza para preincrementar una variable x x+=2 incrementa
// en 2 a x; // los literales que empiezan con 0x se tratan como
// hexadecimales en java.
System.out.println(x+1-1);
}
}
La mejor respuesta se lleva un premio 
Bueno despues de mucho deliberar (?) decreto que el justo ganador del puzzle es Sherekan! quien se hace acreedora del siguiente premio:
2 (dos) libros “El Lenguaje de Programación Java SL-275″ compuesto por una Guía de Estudiante y Guía Práctica. Publicados por Sun Microsystems. Fuerte el aplauso!
Fluent Interfaces
¿No es extraño que los setters no devuelvan nada? En estos tiempos que corren me parece que nos estamos perdiendo algo, estamos desperdiciando algo tan valioso como el retorno de un metodo. Por lo menos así lo cree Eric Evans y Martin Fowler quienes nos proponen algo llamado Fluent Interfaces.
Si creamos un objeto de clase Perro lo mas sensato es inicializar su estado de alguna forma, podemos inicializarlo mediante el constructor o bien con los setters de sus propiedades.
Perro perro = new Perro();
perro.setNombre("Otto");
perro.setRaza("BassetHound");
perro.setFechaDeNacimiento("20/07/2003");
Fluent Interfaces nos propone esto:
perro.setNombre("Otto").setRaza("BassetHound").setFechaDeNacimiento("20/07/2003");
En un contexto cargado con muchos objetos del mismo tipo la sentencia anterior se vuelve más clara que sus predecesoras y con algo tan trivial como hacer que los setters en lugar de devolver void devuelvan una referencia al objeto actual.
public Perro setNombre(String nombre) {
this.nombre = nombre;
return this;
}
public Perro setRaza(String raza) {
this.raza = raza;
return this;
}
//and so on...
Poisson d’Avril
Soy un usuario entusiasta de NetBeans. Como también he sido usuario de JDeveloper no puedo asegurar que NetBeans sea el mejor IDE dando vueltas pero estoy seguro de que es mejor que Eclipse en muchos aspectos. Su exito se debe en gran parte a que gente visionaria como Roumen Strobl está detras del proyecto. Directamente desde Roumen’s Weblog: El futuro de NetBeans.
NetBeans 7.0 plans uncovered – NetBeans to become an online IDE
I shouldn’t be blogging about this, because we were saving the big announcement for this year’s Java One, but the information has already leaked: I’ve seen several NetBeans developers blogging about it – so there’s no point in hiding it anymore. The next major release of NetBeans which is planned for 2009 will be a complete rewrite – NetBeans is going to be provided as an online service and it’s source code will be rewritten in a new programming language. But before I tell you which language it is, read the reasoning first.
Java is a great language but unfortunately it is not flexible enough for the new online web 2.0 world with widgets, mashups, RSS and semantic web – it can’t handle the dynamic nature of new web 2.0 applications. Developers no longer want to download and install desktop applications – they are ALWAYS online and all their popular applications are integrated into the ONLY application they need – the web browser. Thus it makes perfect sense to provide an IDE in the web browser. To accomplish this task, there’s only one language which works really well inside of the web browser – and can be used both on the server and on the client. Yes, NetBeans 7.0 will be rewritten in JavaScript! (Although we still plan to run the JavaScript engine on top of the JVM using the built-in Rhino engine).
NetBeans has always been about innovation. We believe that by using JavaScript, NetBeans can be more dynamic than ever. Parts of the IDE will run on the server and parts in the web browser – and Sun will provide NetBeans as an online service. For the price that you are used to: FREE. Of course Sun will still provide top-notch commercial support of the online product and we’ll be rolling out different service plans shortly after the 7.0 release. We are still discussing whether to continue providing the sources of NetBeans (look how well have all the Google applications been accepted in the open source community without actually providing any source code). We’re looking for feedback from the community – does the community actually care about source code of NetBeans or is the FREE price tag that everyone cares about?
We are also investigating the possibilities of running ads in the online version of NetBeans. By that we could make significant money on NetBeans – we could do even more NetBeans days globally with much better finger food. What the heck, we could even transport beer directly from Czech republic so that developers could taste some real beer during NetBeans days!
I’ve never been more excited about the future of NetBeans – we all know that the future is online in the web browser and NetBeans is extremely well positioned to take the online IDE market by storm!
Desde este humilde rincón propongo eliminar el festejo del día de los santos inocentes y adoptar el pez de abril como día para realizar bromas.
