Mostrando las entradas con la etiqueta Guias. Mostrar todas las entradas
Mostrando las entradas con la etiqueta Guias. Mostrar todas las entradas

jueves, 7 de octubre de 2010

Elementos Sintácticos de Java

He incluído para descarga en mi sitio web una guía de la mayor parte los elementos sintácticos de Java que servirá de ayuda para quienes programan en otros lenguajes y quisieran aprender Java. El link de descarga es el siguiente:


Espero se aproveche.

Saludos!

lunes, 20 de septiembre de 2010

Editor Visual para GWT

Hace poco me enteré que google compró la empresa instantiations (link a la noticia), esta empresa era la dueña del único diseñador gráfico decente para GWT, el cual era un plugin de eclipse y además privativo (había que comprarlo para usarlo). Hace poquito me entero que google publicó estos plugins gratis para todos! (link a la noticia).
Yo estuve probando este editor visual y he llegado a varias conclusiones:

Primero que nada, el plugin es genial! Las interfaces web diseñadas visualmente, o sea arrastrando componentes y realizando todo un manejo visual, terminan en código clásico de GWT, o bien con UI Binder!! El código que se genera es bastante limpio y fácil de entender, podemos utilizar todos los controles disponibles en GWT directamente de forma visual, podemos realizar cambios en el código y éstos se reflejan en el modo visual.

Además de todo esto, permite agregar fácilmente los frameworks de extensión mas populares como GWT-EXT y XGWT.

Acá les dejo un par de screenshots:

Vista de código:
Vista WYSIWYG:
Si combinamos esto con la funcionalidad que nos daba el plugin de google, nos queda como gran conclusión de todo que eclipse es la plataforma ideal e indiscutible para hacer aplicaciones en GWT.

Saludos!

jueves, 19 de agosto de 2010

Acerca de los WebSockets

Websockets es una de las tecnologías más interesantes de HTML5, mediante esta tecnología se termina uno de los grandes problemas de las aplicaciones web la falta de estado! Un desarrollador a partir de ahora podrá crear conexiones persistentes con el servidor de aplicaciones y realizar toda clase de cosas convirtiendo a la página web en un cliente común y corriente!

Por ello el desarrollador web deberá comenzar a pensar de otra forma, perderá sentido pensar en "el tiempo de request", la sesión web con su famosa cookie, no mas arquitectura mvc (tal cual la conocemos ahora y la usamos en la web) en pocas palabras, una revolución total. Hoy podemos utilizar esta tecnología si disponemos de dos cosas:
  • Un browser compatible (como chrome o safari).
  • Un servidor compatible.
Existen varias implementaciones del protocolo websockets (aunque todavía está en desarrollo), como muchos se lo estarán esperando, si vas a probar esto en java, podrás usar mi framework "websockets4j" disponible para descarga en jar en websockets4j.googlecode.com.

Bueno, ahora sin mas preámbulos, a lo importante. Para conectarnos al servidor desde Javascript necesitamos conocer dos cosas:
  • La url de conexión.
  • El subprotocolo a utilizar. (opcional)
La url de conexión indica a que servidor nos conectaremos, y tiene la siguiente forma:
ws (o wss) ://:puerto/recurso.

Si utilizamos ws, la conexión será sobre un canal desencriptado, y si utilizamos wss la conexión será utilizando "Transport Layer Security" o TLS. (de momento mi framework de websockets no soporta wss).

El subprotocolo, es para ser utilizado por terceros, usualmente se utilizará con una librería de javascript y un servidor del mismo vendedor.

La conexión puede tener tres estados posibles: Connecting, Opened y Closed. El siguiente código muestra la interfaz de WebSocket.

interface WebSocket {
readonly attribute DOMString URL;

// ready state
const unsigned short CONNECTING = 0;
const unsigned short OPEN = 1;
const unsigned short CLOSED = 2;
readonly attribute unsigned short readyState;
readonly attribute unsigned long bufferedAmount;

// networking
attribute Function onopen;
attribute Function onmessage;
attribute Function onclose;
boolean send(in DOMString data);
void close();
};
WebSocket implements EventTarget;
Los mensajes al cliente serán recibidos por eventos, una función javascript será invocada cuando un mensaje llegue.

La trama tiene forma de caracteres unicode UTF-8 y se recibirá en forma de mensajes que pueden tener longitud variable.

Para realizar la conexión, basta con la siguiente línea Javascript:

var socket = new WebSocket("ws://some.host:10123/resource", [subprotocol]);

Una vez realizado esto, podemos setearle funciones para los cambios de estado:

socket.onopen = function() { alert("Opened!") };
socket.onmessage = function (e) { alert("Message: "+e.data); };
socket.onclose = function() { alert("Closed!") };
socket.onerror = function() { alert("Error!") };

Para enviar un mensaje, simplemente podremos utilizar la función "send" del socket.
Para cerrar la conexión, podremos utilizar la función "close" del socket.

Con esto concluyo esta guía sobre esta tecnología que va a cambiar a la web para siempre.

Saludos!

domingo, 8 de agosto de 2010

Framework de WebSockets: websockets4j

Este fin de semana he estado trabajando duro en un framework para WebSockets que sea conectable a Glassfish 3 y Tomcat 7. Aunque no es solamente conectable a eso, sino que mientras el servidor tenga permitida la creación de hilos y levantar ServerSockets, esto va a andar. El framework es open source con licencia Apache 2, bien permisiva!!.

El framework puede ser descargado de: http://websockets4j.googlecode.com y tiene como interesante que soporta la versión 75 y 76 del borrador del estándar de WebSockets, trataré de irlo actualizando a medida que los browsers vayan soportando versiones nuevas del estándar. Por ahora Google Chrome soporta la versión 75 y Safari 5 la versión 76.
Les dejo acá un videito de una aplicación de chat de ejemplo que hice para demostrar el funcionamiento del framework. Está en inglés porque pertenece al sitio de mi proyecto.
Dicen.. que se puede ver en hd.




Un dato curioso es que el framework no está hecho para funcionar con servlets incluso cuando el handshaking del protocolo es parecido a una solicitud http, bien, la especificación de servlets dice claramente que los servlets son para protocolos de solicitud y respuesta, como el HTTP, pero los websockets se comportan de forma muy distinta. Espero que le sirva a alguno, y pronto estaré trabajando en agregarle soporte para TLS.

Saludos!!

viernes, 15 de enero de 2010

Google Guice, breve reseña.

Google Guice es un framework para inyección de dependencias. Cuando nos encontramos frente al desarrollo de aplicaciones grandes (o al menos potencialmente grandes) en las que distintos equipos de desarrolladores codifican distintos módulos de una misma aplicación es el caso donde se presenta como obvia la necesidad de un bajo acoplamiento entre dichos módulos. Normalmente se presenta la necesidad de realizar tests automatizados de una o mas clases, o colaboraciones y dicho código posiblemente dependa de código de otro módulo que ni siquiera se encuentre desarrollado, o que resulte extremadamente costoso en tiempo o en recursos realizar dichos test. Aquí es cuando entra en juego la inyección de dependencias. No pretendo en este post explicar la inyección de dependencias en sí, para mayor información sobre ésta ver el siguiente enlace.

Goolge Guice es un excelente framework, el cual implementa el standard JSR 330 para la inyección de dependencias. Posee entre otras las siguientes características:
  • Inyección de dependencias en constructor.
  • Inyección de dependencias utilizando setters.
  • Inyección de dependencias directamente en los atributos de la clase.
  • Intercepción de métodos con filtro por anotaciones (especialmente útil para AOP).
  • Configuración programática de los módulos de la aplicación.
  • Definición de Fabricas (proveedores) y ámbitos para las instancias inyectadas.
  • Otras.
Gracias a estas características, estre framework resulta especialmente útil, algunos de los beneficios de utilizarlo son:
  • Generalización de aspectos en las aplicaciones y su consiguiente reducción de errores.
  • Escribimos código mas mantenible.
  • Escribimos código mejor testeable.
  • Escribimos código mucho más reutilizable.
En el siguiente ejemplo demostramos el uso de Google Guice para el módulo de recordatorio de cumpleaños en el appspot de este blog.

Primero demostraré un framgento de la clase encargada de la lógica de negocio de esta pequeña aplicación:
@Singleton
public class BirthDateManager {

private EntityManager em;

@Inject
public BirthDateManager(EntityManager em) {
this.em = em;
}
...
}


Podemos observar 3 cosas:
  1. Utilizamos el annotation @Singleton para indicarle al inyector que esta clase deberá instanciarla una única vez.
  2. Definimos el constructor que recibe las dependencias de esta clase de reglas de negocio de acuerdo con el patrón inyección de dependencias.
  3. Con la annotation @Inject le indicamos al inyector que debe inyectar dependencias.
Ahora observamos la clase que define el módulo donde configuraremos el inyector:

public class BirthDateModule extends AbstractModule {

@Override
protected void configure() {
bind(EntityManager.class).toProvider(PersistenceFacade.class);
}

}


Con esta simple línea le indicamos al inyector que debe obtener la dependencia de un proveedor, en este caso una fachada de persistencia. A continuación el código interesante de dicha fachada:

public class PersistenceFacade implements Provider<EntityManager> {

@Override
public EntityManager get() {
return emf.createEntityManager();
}
...
}

Vemos que nuestra clase proveedora deberá implementar la interfaz Provider para que Guice sepa cual es el método que nos provee la dependencia.

Finalmente vemos el código que pone todo junto. Obtenemos la clase de las reglas del negocio con las dependencias ya satisfechas a través de un inyector:

        Injector in = Guice.createInjector(new BirthDateModule());
BirthDateManager bdm = in.getInstance(BirthDateManager.class);



Como se puede ver resulta bastante simple:creamos un inyector a partir del módulo y luego le pedimos la clase de reglas del negocio a dicho inyector. Toda la magia ocurre en estas 2 líneas.

Con eso concluyo esta breve demostración de Google Guice. Espero que sea de utilidad.

Saludos!

domingo, 3 de enero de 2010

Google AppEngine: Protegiendo el contenido web.

En un post anterior vimos como utilizar las cuentas de google para hacer login y logout en app engine. Ahora veremos una de las opciones para proteger contenido en nuestra aplicación, mediante la definición de reglas declarativas en el archivo web.xml. Para una referencia completa de las cosas que podemos hacer en el web.xml para app engine, ver el siguiente enlace.

AppEngine provee una forma estándar (llamando a estándar a compatible con JAAS) para proteger recursos declarativamente. Por ejemplo en la aplicación del appspot de este sitio se definió:

    <security-constraint>
<web-resource-collection>
<url-pattern>/seguro/*</url-pattern>
</web-resource-collection>
<auth-constraint>
<role-name>*</role-name>
</auth-constraint>
</security-constraint>

Diciendo que lo que hay dentro de la carpeta "/seguro/" puede ser sólamente accedido por el rol "*".
AppEngine nos provee 2 roles distintos para nuestra aplicación:
  • El rol de cuenta de google: "*"
  • El rol de administrador: "admin"
El primero se aplica a cualquier persona logueada con su cuenta de google, y el segundo sólo a aquellas cuentas de google que definimos en la configuración de la aplicación como "admin".

Esta definición resulta suficiente para proteger cualquier contenido en nuestra aplicación, sin embargo cuando trabajamos con GWT, las consideraciones son un poco distintas, ya que debemos por un lado proveer una lógica que oculte o deshabilite opciones que no son accesibles y, debido a que se trata de código en el cliente, debemos proteger las llamadas remotas.

El escenario ideal para proteger las llamadas remotas es el de los servlets con programación orientada a aspectos o AOP y posiblemente anotaciones para asegurar métodos en forma declarativa. En un post futuro investigaremos estas posibilidades y utilizaremos filtros, algo realmente poderoso, para armar la seguridad de la forma menos trabajosa.

Saludos!

Google AppEngine: Acceso a las cuentas de google.

Una de las facilidades que nos provee Google AppEngine es la de acceder a las cuentas de google. He estado experimentando un poco con esto y puedo remarcar los siguientes puntos:
  • El acceso a la info del usuario logueado se realiza a través del mecanismo estándar de JAAS.
  • Pueden protegerse urls del sitio mediante el mecanismo estándar de la web tier, esto es definiéndolas en el archivo web.xml.
  • El mecanismo de login y logout es no estándar.
En este post demostraré el uso que le he dado a esta funcionalidad en el appspot del sitio. En próximos post demostraré alternativas para proteger urls del sitio.

El ejemplo es la implementación un servicio RPC de GWT. Primero echemosle una mirada a los import.
import com.google.gwt.user.server.rpc.RemoteServiceServlet;
import appspot.client.CommonService;
import com.google.appengine.api.users.UserService;
import com.google.appengine.api.users.UserServiceFactory;
import javax.servlet.http.HttpServletRequest;
Lo primero que vemos entonces son los import comunes de GWT para los servicios RPC, también vemos importada la interfaz necesaria para que la magia funcione "CommonService" (ese nombre lo elegí yo). Luego vemos las clases de google para acceder a sus cuentas, la "UserService" y "UserServiceFactory", de los nombres mismos ya se puede inferir el uso.

Lo próximo que veremos es la implementación de la clase de servicio, en la cual accedemos a las api.


public class CommonServiceImpl extends RemoteServiceServlet
implements CommonService {

@Override
public String getUserMail() {

UserService us = UserServiceFactory.getUserService();
if (!us.isUserLoggedIn()) {
return null;
}

HttpServletRequest req = getThreadLocalRequest();
String name = req.getUserPrincipal().getName();
return name;
}

@Override
public String getLoginUrl(String baseUrl) {
UserService us = UserServiceFactory.getUserService();
return us.createLoginURL(baseUrl);
}

@Override
public String getLogoutUrl(String baseUrl) {
UserService us = UserServiceFactory.getUserService();
return us.createLogoutURL(baseUrl);
}
}

Vemos que nuestro servicio tiene 3 métodos:
  • Obtener el usuario logueado.
  • Generar una URL que nos llevará a una pantalla de login.
  • Generar una URL que nos deslogueará del servicio.
En el primer método utilizamos el userService para preguntar si el usuario se encuentra logueado. Esta es una manera no estándar, pero realmente simpática y prolija.
Luego utilizamos una forma estándar para obtener el "User Principal", el cual traducido del lenguaje JAAS, es el usuario logueado.

Los métodos de generar urls son prácticamente iguales, en uno pedimos de una manera no estándar que nos entreguen una url de la página de login diciendo también la url a la cual queremos ir despues de estar logueados. Esto es realmente una ventaja comparado con la forma estándar en la cual definimos en web.xml un formulario de login al cual llegamos tratando de alcanzar una url no permitida, ya que la lógica de navegación para el login debe ser inferida y no puede leerse del propio código. Con eso le damos fin a nuestra demostración. Espero que haya sido de utilidad.

Saludos!

jueves, 31 de diciembre de 2009

UI Binding Con GWT 2.0

Una de las características nuevas de GWT es la posibilidad de crear interfaces de usuario definidas en un archivo XML, y luego vincular dicha definición con una clase, la cual incluirá el comportamiento de dicha interfaz, todo esto se realiza gracias al nuevo UiBinder.
En el siguiente ejemplo muestro como hacer una simple calculadora de enteros, definiendo la interfaz de usuario en un archivo xml y el comportamiento en una clase. Luego de todo eso podremos utilizar nuestra pantalla como si fuera un simple Widget de GWT.

El ejemplo funcionando se encuentra disponible bajo el enlace "Calculadora" del appspot de este blog.

Para empezar mostraré la pantalla definida en el xml. El archivo es "WebCalc.ui.xml"

<?xml version="1.0" encoding="UTF-8"?>
<ui:UiBinder xmlns:ui='urn:ui:com.google.gwt.uibinder' xmlns:g='urn:import:com.google.gwt.user.client.ui'>
<g:DockPanel>
<g:Dock direction="SOUTH">
<g:HorizontalPanel>
<g:Button text="Suma" ui:field="botonSumar" />
<g:Button text="Resta" ui:field="botonRestar" />
<g:Button text="Multuplicación" ui:field="botonMultiplicar" />
<g:Button text="División" ui:field="botonDividir" />
</g:HorizontalPanel>
</g:Dock>
<g:Dock direction="CENTER">
<g:HTMLPanel>
<p>Operador 1: <input type="text" ui:field="operador1" /></p>
<p>Operador 2: <input type="text" ui:field="operador2" /></p>
<p>Resultado: <span ui:field="resultado"/></p>
</g:HTMLPanel>
</g:Dock>
</g:DockPanel>
</ui:UiBinder>

Podemos ver que es bastante sencillo, primero definimos declarativamente un DockPanel, para la botonoera utilizamos un HorizontalPanel, el cual contiene 4 botones, vinculados por el atributo "ui:field" con ciertos métodos de la clase controladora que veremos más adelante.
Para la entrada, y en el centro del dock panel, utilizamos un panel html con tags html estándar (lo cual resalta el poder del UiBinder). Dandole el formato que a nosotros nos plazca y aún así pudiendo vincular elementos en la clase, de la misma forma que lo hicimos con los botones.

En este ejemplo no se muestra pero es posible también incluir estilos personalizados que se aplican sólo para el xml que estamos definiendo; otra muestra del gran poder de esta herramienta.

A continuación mostramos la clase que define el comportamiento de nuestra calculadora, el archivo "WebCalc.java".

public class WebCalc extends Composite {

interface Pantalla extends UiBinder<Widget, WebCalc> { }
private static Pantalla pantalla = GWT.create(Pantalla.class);

@UiField
InputElement operador1;
@UiField
InputElement operador2;
@UiField
SpanElement resultado;

public WebCalc() {
initWidget(pantalla.createAndBindUi(this));
}

@UiHandler("botonSumar")
public void sumar(ClickEvent evt) {
int op1 = leerOperador(operador1);
int op2 = leerOperador(operador2);
resultado.setInnerText("" + (op1 + op2));
}

@UiHandler("botonRestar")
public void restar(ClickEvent evt) {
int op1 = leerOperador(operador1);
int op2 = leerOperador(operador2);
resultado.setInnerText("" + (op1 - op2));
}

@UiHandler("botonMultiplicar")
public void multiplicar(ClickEvent evt) {
int op1 = leerOperador(operador1);
int op2 = leerOperador(operador2);
resultado.setInnerText("" + (op1 * op2));
}

@UiHandler("botonDividir")
public void dividir(ClickEvent evt) {
int op1 = leerOperador(operador1);
int op2 = leerOperador(operador2);
resultado.setInnerText("" + (op1 / op2));
}

private int leerOperador(InputElement tb) {

if (tb == null) {
Window.alert("No es posible leer un valor");
return 0;
}
try {
return Integer.parseInt(tb.getValue());

} catch (NumberFormatException ex) {
Window.alert("No es posible convertir a entero: " + tb.getValue());
}
return 0;
}
}

Como podemos ver es bastante simple:
Para realizar el vínculo con el archivo declaramos la interfaz interna, a la cual podemos ponerle el nombre que mas nos convenga, utilizando como sus parámetros de generics el tipo de componente resultante que deseamos y el tipo de componente que tiene el "dueño" de la interfaz generada.
Posteriormente creamos el componente utilizando el mecanismo de "Deferred Binding" que nos provee GWT.

En el constructor de nuestro manejador le indicamos a nuestro componente recien creado que se vincule con la instancia actual de la clase mediante el llamado al método "createAndBindUi".

Finalmente utilizamos los annotations @UiField y @UiHandler para vincular componentes y las acciones de los botones.
Los botones pueden vincularse con cualquier método que devuelva void, y reciba un ClickEvent.

Bueno, espero haber podido ilustrar un poco el uso de esta gran herramienta que nos provee GWT. Si se desea ampliar la lectura, recomiendo leer el siguiente tutorial.

Saludos!

lunes, 28 de diciembre de 2009

Google App Engine

Recientemente me han activado mi cuenta de Google App Engine para complementar un poco con ejemplos en funcionamiento las cosas que voy publicando acá en este blog.

Para quienes no sepan lo que es, trataré de definirlo de la siguiente forma: Es un servicio de google, gratuito al principio (podemos pagar si necesitamos subir las prestaciones) donde podemos hostear nuestras aplicaciones web, sin publicidades, y con prestaciones como utilización de mails y bases de datos (entre muchas otras).

App engine permite cargar aplicaciones web hechas en python y en java. Es realmente simple de habilitar, necesitamos una cuenta de google (como todos los servicios de google) y un celular, ya que habilitamos el servicio a través de sms. En mi caso, mi proveedor de servicio no estaba soportado por google app engine, sin embargo llené un formulario y 1 semana después me lo habilitaron.

Para desarrollar en Netbeans con app engine, necesitamos instalar el plugin mediante esta guia, y además descargar el SDK para java de google app engine.



Con el plugin para netbeans podemos probar las aplicaciones, debugearlas, cargarlas dentro de google y además manejo gráfico de todas las configuraciones para app engine.

La dirección de app engine para este blog es http://juancavallotti.appspot.com e iré incluyendo ejemplos de cosas que desarrolle para este blog.

Espero que les sea de utilidad.

Saludos!

miércoles, 16 de diciembre de 2009

Videos KDE 4.4

Dejo acá unos videos que demuestran algunas de las características nuevas de Kde 4.4, realmente va a estar muuuuuy bueno.

Saludos!

sábado, 5 de diciembre de 2009

Pruebas de Unidad: JUnit 4 y Netbeans IDE

Muchas veces en la incansable labor de desarrollo de software, nos vemos en la necesidad de probar lo que hemos hecho. La forma que primero se nos viene a la cabeza es correr la aplicación, cargar los datos, y ver que todo ande bien.
Eventualmente no tendremos la posibilidad de ejecutar la aplicación completa, o la ejecución de ésta es algo que consume mucho tiempo y es muy laborioso, sin contar que a veces dependemos de necesitar listo el trabajo de otras personas para probar nuestro código. Ahí es donde cobra sentido la automatización de las pruebas de unidad.

La herramienta propuesta por Netbeans IDE y que ciertamente es la más utilizada en el ambiente es jUnit. En este post presentaré las nociones básicas de uso de la versión 4 de jUnit, basado en Annotations.

Utilizar esta herramienta es realmente sencillo, utilizaré la siguiente clase (realmente trivial) como sujeto de pruebas:

public class Matematica {
public int dividir(int a, int b) {
return a / b;
}
}

Para comenzar, creo dentro de mi proyecto de netbeans, en test packages, mi clase que será la Suite de pruebas (o conjunto de pruebas seleccionadas). Cada prueba se realiza dentro de un método y este deberá estar anotado con @Test.

Nuestra primera clase de prueba es esta:

import org.junit.Test;
import org.junit.Assert;

public class PruebaMate {

@Test
public void pruebaCero() {
int valor = new Matematica().dividir(4, 2);
Assert.assertEquals(2, valor);
}

}

A esta clase le iremos agregando cosas a medida que vayamos avanzando.
Para comenzar la prueba en netbeans, click derecho a la clase de prueba dentro del explorador de proyectos y le damos la opción "Run".

Presentando la siguiente salida:

Testsuite: PruebaMate
Tests run: 1, Failures: 0, Errors: 0, Time elapsed: 0,089 sec

test:
BUILD SUCCESSFUL (total time: 1 second)

Esto nos dice que la prueba se ejecutó, y no sólo eso sino que se realizó correctamente y el tiempo que tardó.

Ahora agregaremos el siguiente método para probar como se comporta con la división por 0:

@Test
public void pruebaUno() {
new Matematica().dividir(4, 0);
}

Y al correrlo obtenemos la siguiente salida:

Testsuite: PruebaMate
Tests run: 2, Failures: 0, Errors: 1, Time elapsed: 0,061 sec

Testcase: pruebaUno(PruebaMate): Caused an ERROR
/ by zero
java.lang.ArithmeticException: / by zero
at Matematica.dividir(Matematica.java:3)
at PruebaMate.pruebaUno(PruebaMate.java:14)


Test PruebaMate FAILED
test:
BUILD SUCCESSFUL (total time: 0 seconds)

Ahora vemos que en realidad la segunda prueba no debió haber fallado ya que en java la división por cero causa esa ArithmeticException. Para decirle a jUnit que realmente esa excepción no es mala sino que debería considerarse como resultado exitoso de la prueba, lo hacemos a través de el annotation @Test, el método quedará de la siguiente forma:

@Test(expected=ArithmeticException.class)
public void pruebaUno() {
new Matematica().dividir(4, 0);
}

Y al ejecutar la prueba vemos lo siguiente:

Testsuite: PruebaMate
Tests run: 2, Failures: 0, Errors: 0, Time elapsed: 0,049 sec

test:
BUILD SUCCESSFUL (total time: 0 seconds)

Nota: En caso que nuestra excepción necesitara ser declarada, agregamos la cláusula throws a nuestro método de prueba.

Ahora posiblemente antes de cada prueba necesitemos realizar un setup del entorno para que se adapte al entorno de producción, esto lo realizaremos con métodos anotados con @After y @Before, por ejemplo realizaremos la instanciación de la clase matemática antes de cada prueba y sugeriremos la recolección de basura después. La clase de pruebas modificada se ve de la siguiente forma:

import org.junit.After;
import org.junit.Test;
import org.junit.Assert;
import org.junit.Before;

public class PruebaMate {

@Test
public void pruebaCero() {
int valor = m.dividir(4, 2);
Assert.assertEquals(2, valor);
}

@Test(expected=ArithmeticException.class)
public void pruebaUno() {
m.dividir(4, 0);
}

private Matematica m;

@Before
public void iniciar() {
System.out.println("Inicio la prueba");
m = new Matematica();
}

@After
public void terminar() {
System.out.println("Termino la prueba");
m = null;
System.gc();
}
}


Y al ejecutar la prueba vemos el resultado:


Testsuite: PruebaMate
Inicio la prueba
Termino la prueba
Inicio la prueba
Termino la prueba
Tests run: 2, Failures: 0, Errors: 0, Time elapsed: 0,1 sec

------------- Standard Output ---------------
Inicio la prueba
Termino la prueba
Inicio la prueba
Termino la prueba
------------- ---------------- ---------------
test:
BUILD SUCCESSFUL (total time: 0 seconds)


Ahora, instanciar la misma clase una y otra vez por cada prueba no es barato, como se puede observar en los tiempos de ejecución. Si queremos realizar algo antes de todo y luego algo después de todo utilizamos los annotations @AfterClass y @BeforeClass, modificamos la clase de pruebas de la siguiente forma:

private static Matematica m;

@BeforeClass
public static void iniciar() {
System.out.println("Inicio la prueba");
m = new Matematica();
}

@AfterClass
public static void terminar() {
System.out.println("Termino la prueba");
m = null;
System.gc();
}

Cambiando a static ya que las anotaciones requieren que los métodos sean static. Y los resultados de la ejecución son los siguientes:

Testsuite: PruebaMate
Inicio la prueba
Termino la prueba
Tests run: 2, Failures: 0, Errors: 0, Time elapsed: 0,073 sec

------------- Standard Output ---------------
Inicio la prueba
Termino la prueba
------------- ---------------- ---------------
test:
BUILD SUCCESSFUL (total time: 0 seconds)


Con lo que terminamos este tutorial introductorio para realizar pruebas de unidad, las cuales nos ahorran mucho tiempo de introducción de datos y a medida que pasa el tiempo y las pruebas se acumulan nos sirven para verificar que los cambios introducidos en el mantenimiento de las aplicaciones, no tengan efectos adversos sobre la funcionalidad existente.

Espero que les sirva. Saludos!

viernes, 13 de noviembre de 2009

Modem 3g Claro en Linux

Hace un tiempo experimenté con sorpresa que al enchufar el modem claro 3g huawei en mi notebook con ArchLinux, networkmanager me lo reconoció sin problemas.
Al tratar de conectarme me solicitó los siguientes datos:
  • Nro de teléfono: *99#
  • usuario: ctigprs
  • clave: ctigprs
  • APN: internet.ctimovil.com.ar
Bien, con esto logré conectarme pero internet no andaba ni para atrás ni para adelante.

Al mirar mi archivo /etc/resolv.conf vi lo siguiente:

nameserver 4.3.2.1
nameserver 4.3.2.1

#(también podría haber sido 1.2.3.4, no lo recuerdo.)

Esto evidentemente está mal por lo cual luego de un poco de investigación descubrí que los dns eran los siguientes:

#/etc/resolv.conf

nameserver 170.51.255.100
nameserver 170.51.255.167

Bien, en un principio pensé que eso resolvería mi problema de conexión pero no. Al escribir el comando 'route' noté que el dhcp tampoco me entregó bien la puerta de enlace. Inspeccionando un poco vi también que si bien tenía una dirección ip (proporcionada por la negociación ppp), la máscara de red era 255.255.255.255. Teniendo esa máscara resulta obvio que no podría conectarme a ninguna pc en esa red que no sea la mía. Inspeccionando la configuración que entregaba el mismo módem en windows vi que la puerta de enlace en efecto era la misma ip que nos entregó la necociación ppp.

Por lo cual, con el comando route, y suponiendo que mi ip es: 186.122.192.127


# route add default gw 186.122.192.127

Una vez corregido esto, pude navegar perfectamente con el modemcito.

Les dejo acá un snapshot de como se vería la configuración parael modem en knetworkmanager.



Saludos!

miércoles, 28 de octubre de 2009

Procesamiento de Texto Eficiente

Muchas personas cuando realizan procesamiento de textos tienden a dar formato a medida que van escribiendo, terminan la idea, establecen fuentes, tamaños y colores a los elementos del documento. Ésta idea si bien es intuitiva, genera luego muchas "desprolijidades" en el documento, algunas perceptibles y otras no, ésto trae otras consecuencias como por ejemplo las siguientes:

  • Se vuelve muy difícil la actualización eficiente y veloz del formato del documento.
  • Cambiar partes del texto a menudo requiere lidiar con las "mañas" del formato.
  • Resulta complejo utilizar herramientas útiles como la generación automática de índices.
¿Cuál podría ser la solución a este problema?

La solución propuesta por la mayoría de los procesadores de texto es simple: Separar el formato de la estructura del documento.

La idea principal es volver a la primaria e identificar los elementos característicos de un texto tales como:
  • Títulos en diferentes niveles.
  • Párrafos.
  • Epígrafes
  • Citas
  • Notas al Pie
  • Etc
Incluso se podría ser mas granular como por ejemplo oraciones o partes remarcadas de una oración.

Ahora bien, este enfoque permite que muchas personas editen partes de un documento sin tener que preocuparse por el formato, cosa que en general cuando se trata de la edición de grandes documentos sucede muy a menudo. La técnica es simple. se define un estándar estructural, el cual es más facil de definir y aplicar que la común definición de un fromato estándar y al finalizar el documento se aplica el formato editando los estilos.

A continuación muestro cómo se realiza esto dentro de OpenOffice:


Dejo remarcado en la imágen el combo con el que podemos indicarle al procesador de texto que tipo de elemento tenemos seleccionado.
Generalmente éstos elementos ya traen un formato predeterminado aunque a mi parecer es bien feo.

Una vez que decidimos comenzar con el formateo de nuestro documento desplegamos el diálogo que también se puede ver en la imágen y con click derecho podremos acceder a las propiedades de su formato.

Principios similares se aplican en sitios web con las hojas de estilo en cascada (CSS) aunque estas últimas son mucho mas extensas en cuestión de definición de formato.

Espero que les sirva para sacar documentos mas prolijos y utilizando siempre formatos abiertos.

Saludos!

jueves, 8 de octubre de 2009

Lanzadera Lancelot

Una de las cosas lindas que tiene KDE4 es que todo son componentes "enchufables" al escritorio, por lo cual podemos cambiar todo por componentes que se ajusten mejor a nuestras necesidades digamos, todo lo que está en los paneles y en los tableros plasma.

Hoy le tocó el turno al menú K, una buena alternativa con sabor a plasmoid es la que en castellano se llama "Lanzadera Lancelot" Esto es un reemplazo muy bueno para nuestro menú, nos muestra distintos apectos importantes sobre nuestro sistema como lo son las aplicaciones, nuestros dispositivos de almacenamiento, opciones para edición de documentos y hasta incluso nuestra gestión de información personal.

Como se puede ver, uno de los atractivos visuales de la lanzadera es que, a diferencia del menú K, el cual no es transparente por default (y si se puede poner transparente yo personalmente no sé como) , la lanzadera utiliza las transparencias.
Tiene además una interfaz que deslizando el cursor hacia ciertos lugares nos ahorra hacer click en el item.

Como podemos ver nos permite acceder fácilmente a lugres de acceso frecuente. Otra de las características de la lanzadera es que es muy configurable.

En fin, esa es mi breve reseña de esta utilidad de kde.

Saludos!

miércoles, 30 de septiembre de 2009

Hibernate Annotations - Guia Rápida

En este post planeo explicar un poco sobre cómo utilizar hibernate annotations para proyectos Java SE. Antes que nada aclaro que se puede usar hibernate a través de la jpa, pero personalmente tengo razones para pensar que la JPA está todavía un poco chica como para Hibernate.

Para una guia de mapeo les recomiendo bajar la documentación de Hibernate-Annotations

Para los que no sepan de que estoy hablando lo pongo con palabras simples, hibernate es una librería que se encarga de "conectar" el mundo de la programación orientada a objetos con el mundo de las bases de datos relacionales. Algunos conocen esto como ORM o para los mortales, mapeo objeto-relacional.

No voy a dar mucha introducción al tema, debido a que puede ser un poco largo y espero que quien me esté leyendo lo haga porque comprende el tema y quiera ir directo al grano.

Para empezar hibernate utiliza un archivo xml de configuración

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="hibernate.dialect">org.hibernate.dialect.PostgreSQLDialect</property>
<property name="hibernate.connection.driver_class">org.postgresql.Driver</property>
<property name="hibernate.connection.url">jdbc:postgresql://localhost:5432/prueba</property>
<property name="hibernate.connection.username">prueba</property>
<property name="hibernate.connection.password">prueba</property>
<property name="hibernate.hbm2ddl.auto">update</property>
<property name="hibernate.show_sql">true</property>
<mapping package="pruebahibernate.entidades"/>
</session-factory>
</hibernate-configuration>


Este archivo debe llamarse hibernate.cfg.xml y va ubicado en la raíz de nuestra estructura de paquetes.

Como nota recordar poner el driver jdbc de nuestra base de datos relacional entre las librerías (así como las de hibernate annotations, y core). En mi caso utilizo PostgreSQL con una base de datos "prueba" con usuario y clave también prueba.

Todas mis clases de entidad se encuentran en el paquete pruebahibernate.entidades y además de eso tengo habilitada la actualización automática y generación de las tablas en la base de datos.

¿Como se usa?

Necesitamos un objeto Session Factory, esto es lo principal para generar Sesiones de hibernate y con ellas hacer cosas locas con nuestra base de datos. La siguiente línea levanta las configuraciones de nuestro xml, las aplica y crea un session factory con ellas. (Las podemos toquetear por código antes de crear el session factory.
Notar que la diferencia con hibernate standard es que se usa el objeto AnnotationConfiguration en vez del Configuration.


SessionFactory sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();

...
Session sesion = sessionFactory.openSession();
Transaction t = sesion.beginTransaction();
....
List l = sesion.createQuery("FROM Persona").list(); //Generar un listado de personas por ejemplo.
....
t.commit();
....

Y eso es todo, con muy pocas líneas y un par de annotations, tenemos un sistema robusto y transaccional para trabajar con bases de datos.

Ahora muestro como está mapeada mi entidad persona:

@Entity
public class Persona implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO, generator="system-uuid")
    @GenericGenerator(name="system-uuid", strategy="uuid")
    @Column(length=36)
    private String id;

    private String nombre;
    private String apellido;
    private int dni;
    private int edad;

    ....... // aca van los getters y setters
}



Como se verá el mapeo por annotations es mucho mas simple y compacto que con xml.Por ahí pueden parecer muchas annotations para un solo id pero es simplemente para especificarle que me genere automáticamente los UUID, es una maña mia nomas el único annotation requerido es el @Id

Espero que les haya servido, cualquier cosa postear preguntas.

Saludos!

lunes, 28 de septiembre de 2009

Windows XP en HP 530

Bueno, ahora les voy a comentar mi experiencia ultra triste de instalar Windows XP en mi notebook HP 530.

Aunque muchos no lo crean, instalar Windows XP a veces es problemático, y yo lamentablemente lo tengo que hacer porque a veces desarrollo aplicaciones para clientes que quieren que corran bien bajo Windows y no me gusta entregarles productos sin probar en el entorno de produccion.

En fin, los materiales:
  • Un cd de Windows XP.
  • Una Notebook HP 530.
  • Los drivers descargados desde el sitio de hp.
  • Y ultimo pero lo más importante, una bolsa de hielo, o 2 comprimidos de "Gel Pack" (si, los que usan los deportistas).

Como muchos saben Windows Xp necesita una disketera para instalar sobre un disco sata (re nuevo), entonces a falta de disketera le desactivé el sata nativo desde el bios de la notebook.

Muchos me preguntaran, ¿Por que el gel pack? Es simple, el Windows Xp es tan genial que no tiene administración de energía en su instalador, entonces, sube un poco la temperatura de la notebook mientras se está instalando y la bios decide que es mejor apagarla para que no se rompa, entonces, bueno, a ponerle hielo abajo!


Bueno, he ahí la solución del problema de que la notebook se apague sola al instalar Windows Xp, yo lo tomo como un signo de rebeldía, pero simplemente es que tiene que descansar en hielo.

Yo estuve googleando mucho tiempo hasta que me di cuenta de esto, asíque lo dejo plasmado acá por si alguien tiene el mismo problema que yo.

Saludos!

Instalando Glassfish en Archlinux

Hace relativamente poco he empezado mi vida como desarrollador JavaEE, como servidor de desarrollo utilizo GlassFish simplemente porque es de sun y es el que viene con Netbeans, el cual también utilizo.
En mi pc habitual de desarrollo de JavaEE me he encontrado que correr el IDE y el servidor en el mismo lugar es contraproducente para la velocidad de desarrollo, digamos, todo se tarda muchísimo, por lo cual he instalado Glassfish en una pc aparte y acá comento mi experiencia.

Primero que nada, quiero decir que glassfish no viene en los repos asíque hay que instalarlo usando yaourt.
#yaourt -S glassfish
Hay que correrlo como root porque sino el script de instalación falla y nos quedamos con el servidor a medias.

Luego de instalarlo se puede arrancar. Los dominios de glassfish se colocan en el directorio domains de la instalación (yaourt lo pone en /opt/glassfish), estoy usando el dominio por defecto ya que trae todos los servicios en los puertos estándar asíque prácticamente sale corriendo "out of the box".
Algo que extrañé es un script en /etc/rc.d para controlarlo, igual nada me impide hacerlo y lo hice.

Glassfish tiene un workaround para que funcionen las conexiones al servicio jndi y es que el nombre de host debe resolver a la ip externa de la pc, por lo cual hay que manipular el archivo /etc/hosts para que quede similar a esto:
127.0.0.1 localhost.localdomain localhost
192.168.1.8 juan-desktop
Para Controlarlo se utiliza el binario asadmin que se encuentra en el directorio bin, entonces por ejemplo mi dominio se llama domain1 (el que viene por defecto, y estas son las opciones para controlarlo):

asadmin start-domain domain1 # Arrancar el domain1 y si dado el caso, servidor también
asadmin stop-domain domain1 # Parar el dominio1 en el servidor y dado el caso, el servidor tb.

Si le añandimos la opción --debug, podemos arrancar el servidor en modo debug (lo cual sirve para los ides, entoces acá les presento mi script de shell para controlar a glassfish.

#!/bin/bash


case "$1" in

start)
/opt/glassfish/bin/asadmin start-domain domain1
;;
stop)
/opt/glassfish/bin/asadmin stop-domain domain1
;;
debug)
/opt/glassfish/bin/asadmin start-domain --debug domain1
;;

debug-restart)
$0 stop
sleep 5
$0 debug
;;
restart)
$0 stop
sleep 5
$0 start
;;
*)
echo "usage $0 {start, stop, debug, restart, debug-restart}"
;;
esac


Los sleep se los pongo simplemente para darle un descanso a la pc entre parada y arrancada.

Conexión con Netbeans

La conexión con netbeans es ultra facil, uno se dirige a la pestaña de servicios, en el item de servidores, le da click derecho y le pone agregar nuevo servidor, aparecerá un asistente y hay que colocar los siguientes datos, aclarando que 4848 es el puerto de adminsitración por http de mi glassfish standalone.




Espero que les sirva, saludos!

lunes, 14 de septiembre de 2009

Java versus C#, ¿por qué aprender y cual?

El objetivo de este post es explicar un poco mi discutible visión sobre estos lenguajes de bytecodes de propósito general, anticipando que soy una persona partidaria de java y argumentando un poco por qué elijo Java.

En primera instancia voy a explicar por qué comparo java con c# y no con otros lenguajes de bytecodes como Ruby o Python.

Nota para el que está leyendo: Lo que sigue hasta el próximo título importante no hace al agrumento del tema asíque se puede saltear sin perderse nada.

Principalmente Ruby y Python quedan fuera de alcance son de tipos dinámicos; (y tirando un pequeño agite) personalmente elijo Python simplemente porque ya el nombre Ruby me suena a marica, y por lo poco que he visto de como se escribe, lo veo muy poco masculino a mi gusto.

Antes de seguir con Java y C# voy a explicar a qué me refiero por código masculino. No es una comparación sexista sino que si colocaramos una escala graduada con masculino de un extremo y femenino en el otro extremo y aclarando que mientras más uno se tiene que ensuciar las manos más se acerca uno al lado "masculino" o sea a nivel MACHO se encuentra el assembler un poquito mas abajo C, java se encuentra en la mitad y Ruby se encuentra del lado femenino.

Máquina Virtual

Java tiene una máquina virtual que corre en muchas plataformas y sistemas operativos, inclusive la mayoría de los teléfonos celulares y microcontroladores. En cambio la plataforma .net sólo corre bajo Windows, ocasionalmente corre en "Mono" (implementación libre y para linux de .net) pero ésta depende de la volundad de que Microsoft quiera exigir aplicar las leyes de patentes de soft o no. Otro tema es que me he topado con casos en que las máquinas virtuales más nuevas de .net no corren aplicaciones anteriores al ser actualizadas.

Estructura de las Bibliotecas.

Las bibliotecas de Java y la arquitectura sugerida para las aplicaciones se encuentran Diseñadas siguiendo los patrones de diseño para soft orientado a objetos y las mejores prácticas de diseño que pueden aprenderse de los libros y la experiencia, de esta forma un programador formado correctamente no tiene que introducir cochinadas en su soft para lidiar con las fallas de diseño de la plataforma.

En contraste la biblioteca de la plataforma .NET se encuentra pensada para ser intuitiva sólo para alguien que no tiene la mas mínima idea de programación, lo cual le genera dependencia hacia la plataforma, imposibilita el entendimiento de lo que se está haciendo y quien comienza con ésto sólo puede trabajar en la programación utilizando esta plataforma porque posiblemente no entienda otras. Evidentemente esta forma de hacer las cosas no sólo es cochina sino que posee un alto acoplamiento, baja cohesión, y posiblemente haya que tapar demasiadas cochinadas para dejar una aplicación bien diseñada.

Bibliotecas externas disponibles

Java posee una gran comunidad por lo que podemos encontrarnos con bibliotecas que aceleran nuestro trabajo en todas las formas, colores y sabores. En contraste la comunidad de C# no es tan amplia por lo tanto no existen tantas herramientas.

Entornos de Desarrollo

Al ser Java un lenguaje libre y abierto, podemos encontrarnos con IDEs multi plataforma y de gran utilidad como Netbeans o Eclipse, (y muchos muchos otros) de gran poder y sin costo de compra de licencias. Gracias a mono, C# ha ganado lugar en linux con IDEs como MonoDevelop, pero principalmente quien desarrolle en Windows tendrá su copia pirateada de Visual Studio (el cual cuesta sus buenos dólares de licencia para el que piense uaslo en serio), o la versión poco poderosa y gratuita.

Legibilidad del Código
Para quien se encuentre acostumbrado a programar en C++, seguro que encontrará mas legible a C#, pero, C++ es en sí MUY poco legible para quien no lo conoce, por lo cual desde mi punto de vista, ésto no es más que un defecto. Para quien se encuentre acostumbrado a leer código c, Java será muy fácil de comprender. Igualmente éste punto es medio subjetivo, pero pienso que convenciones como iniciar nombres de atributo con un guion bajo (no obligatorio, pero buena práctica en C#) o denotar la herencia con ':' por decir algo, solo "ennegrece" el código.

Interfaces de Usuario

El tema de la "belleza" de las interfaces de usuario es el punto fuerte de C#, en efecto dicho lenguaje trae todo tipo de herramientas para hacer pantallas bien agradables, Java tiene nativamente a Swing (y al viejo y peludo AWT) pero Swing no satisface 100% las necesidades de una apariencia "nativa" y un Look and Feel uniforme que es lo que principalmente atrae al usuario final, sin embargo vienen frameworks externos para solucionar estos problemas.

Conclusiones
C# puede parecer para la persona poco experimentada como la opción "mas fácil" de aprender pero no acompaña a los programadores en su aprendizaje y eventualmente los guía hacia el "estanque" donde están metidos todos los programadores que se la jugaron por Microsoft y que todavía creen que a la computadora la mueve un duende mágico. Java provee flexibilidad y alta portabilidad y se adapta a una GRAN variedad de situaciones, sin contar que es un lenguaje libre.

Para el lector: si leyó hasta acá, espero haberlo convencido.

Saludos!

Un Increible editor de texto: VIM

VIM Es un editor de archivos de texto de consola basado en VI. Es increiblemente poderoso aunque puede parecer un poco tosco al principio y poco amigable.

Entre las características que mas me han impresionado se encuentra lo siguiente:

  1. Edición de multiples archivos en pestañas.
  2. Sintaxis resaltada para muchos tipos de archivos de configuración.
  3. Soporte de muchos plugins.
  4. Autocompletado de código.
  5. Code-Fold esto es, esconder código dentro de bloques de programación.
  6. Backup y recuperación de archivos que se están editando.
  7. Comodidad de realizar todo sin levantar las manos del teclado.
Realmente tiene muchas cosas, aún así tiene la ventaja/desventaja según como se lo vea que no se explicita mucho sobre cómo hacer cosas entonces el usuario nuevo realmente no puede entenderlo ni "sacarlo" intuitivamente. Es por eso que he preparado algunos tips para los que quieran aprender a usarlo.

Antes que nada, quisiera comentar que VIM viene ya para muchas plataformas, en las que se incluyen windows, linux y mac os.

Enlaces:
Página de descarga de Vim
VIM en Wikipedia
VI en wikipedia

Existe para los que lo tienen instalado un tutorial que dura 30 minutos que lo pueden hacer y con eso conocer todo lo necesario sobre el vim, para acceder al tutorial escribir el siguiente comando:
$vimtutor
Espero que les resulte de utilidad. Saludos!

lunes, 7 de septiembre de 2009

Conocer tu hardware en Linux.

Muchas veces nos encontramos ante la necesidad de conocer características de nuestro hardware. Existen distintas alternativas, por ejemplo el comando:
cat /proc/cpuinfo
Nos da informacíon sobre el microprocesador que estamos usando.
cat /proc/meminfo
Nos da información sobre el uso de la memoria.
lspci
Nos da información sobre los dispositivos conectados al bus PCI de nuestra placa madre.
lsusb
Nos da información sobre los dispositivos USB conectados.

Hoy sin embargo me he encontrado con un comando que me ha resultado de suma utilidad que es dmidecode.

De por si dmidecode sin parámetros tira información completa sobre todo lo que tenemos en la pc, pero puede filtrarse con por tipos de dispositivo. La sintaxis para usar el comando es la siguiente:
dmidecode --type [nro de tipo]
Acá dejo una tabla de los distintos tipos extraida de las propias manpages de dmidecode.

Type Information
────────────────────────────────────────
0 BIOS
1 System
2 Base Board
3 Chassis
4 Processor
5 Memory Controller
6 Memory Module
7 Cache
8 Port Connector
9 System Slots
10 On Board Devices
11 OEM Strings
12 System Configuration Options
13 BIOS Language
14 Group Associations
15 System Event Log
16 Physical Memory Array
17 Memory Device
18 32-bit Memory Error
19 Memory Array Mapped Address
20 Memory Device Mapped Address
21 Built-in Pointing Device
22 Portable Battery
23 System Reset
24 Hardware Security
25 System Power Controls
26 Voltage Probe
27 Cooling Device
28 Temperature Probe
29 Electrical Current Probe
30 Out-of-band Remote Access
31 Boot Integrity Services
32 System Boot
33 64-bit Memory Error
34 Management Device
35 Management Device Component
36 Management Device Threshold Data
37 Memory Channel
38 IPMI Device
39 Power Supply
40 Additional Information
41 Onboard Device

Espero que les sea de tanta utilidad como a mi.

Saludos!