Edwin Farfan Colan

Integración continua

2010-02-17T14:17:00.000-08:00

Consiste en hacer integraciones automáticas de un proyecto lo más a menudo posible para así poder detectar fallos cuanto antes. Entendemos por integración la compilación y ejecución de tests de todo un proyecto. (Martin Fowler)

La Integración Continua está asociado con las metodologías de programación extrema (XP) y desarrollo ágil.

Ventajas
- Reducción del tiempo de integración.
- Detección de errores lo más pronto posible.
- Pruebas inmediatas tras un cambio en el código.
- Disponibilidad del código para test, demos, etc.

Desventajas
- Sobrecarga por el mantenimiento del sistema.
- Necesidad potencial de un servidor dedicado a build.
- El impacto inmediato al subir código erróneo provoca que los desarrolladores no hagan tantos commits como sería conveniente como copia de seguridad

QUE NECESITAMOS???

Software
- Control de Versiones (SVN)
- Herramienta para generar Build y automizacion de tareas (Maven - Hudson)
- Repositorio local (Nexus)
- Estadisticas y/o reportes de Analisis de Codigo (Sonar)

Hardware
- Servidor dedicado a IC
- Espacio en el disco

SUBVERSION
Es un sistema de control de versiones, cuyo proposito es administrar el acceso a un conjunto de ficheros, y mantener un historial de cambios realizados, es útil para guardar cualquier documento que cambie con frecuencia, como, el código fuente de un programa.

Caracteristicas:
- Actualiza ficheros modificados
- Historial de cambios.
- Registra cambios en la estructura de directorios (permite mover y renombrar sin perder el historial).
- Commits atómicos, se realizan todos o ninguno.

MAVEN
Es una herramienta de software para la gestión y construcción de proyectos Java.
Utiliza un Project Object Model (POM) para describir el proyecto de software a construir, sus dependencias de otros módulos y componentes externo, y el orden de construcción de los elementos.

NEXUS
Nexus es un administrador visual de repositorios para Maven.
Nexus actúa como una caché de objetos entre su organización y el repositorio de Maven público. Esto significa que los artefactos (jars) y sus dependencias, sólo tienen que descargar una vez, y despues se descargan de su repositorio local.Para Jars propietarios y/o propios, se puede hacer un repositorio especial (thirdparty).

HUDSON
Herramienta open source que nos ayuda a monotorizar la ejecución de tareas repetitivas como el compilar un proyecto cada cierto tiempo. Además se enfoca en la construcción y prueba de proyectos de software contínuamente y en monitorizar la ejecución de tareas ejecutadas externamente.
Se integra facilmente con Maven y tiene un sin numero de plugin que se pueden utilizar.

SONAR
Permite la verificacion de la calidad del codigo java, en otras palabras, calcula y muestra en formato web metricas de nuestros proyecto.
Herramientas como PMD, CheckStyle, FindBugs, Cobertura, etc, etc; ya vienen embebidas en Sonar.

Comenzamos con Nuestra Integracion Continua
En este caso esta instalado sobre un servidor linux (redhat)

Instalar java
$ chmod +x jdk-6xxx.bin (para rpms ... chmod a+x jdk-6xxx-rpm.bin)
$ ./jdk-6xxx.bin

Subversion
Lo primero que tenemos que hacer es instalar el Subversion nos bajamos los siguientes archivos rpm’s de la página oficial.
rpm -i CollabNetSubversion-client-1.6.6-1.i386.rpm
rpm -i CollabNetSubversion-server-1.6.6-1.i386.rpm

detenemos el subversion para configurarlo.
$ sudo /etc/rc.d/init.d/collabnet_subversion stop

agregar la variable de entorno para subversion
PATH=/opt/CollabNet_Subversion/bin:$PATH

ejecutar el siguiente script:
$ sudo Configure-CollabNet-Subversion

Este script te configura todo para Subversion, (usuarios, repositorios, usuarios. etc)

Es muy probable que tu servidor tenga Proxy, para solucionar esto podrias utilizar https, mediante el Openssl que ya viene instalado en el colabNet
Para que subversion acepte SSL

$ openssl genrsa -des3 -out server.key 1024
$ openssl req -new -key server.key -out server.csr
Enter pass phrase for server.key:
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
-----
Country Name (2 letter code) [GB]:PE
State or Province Name (full name) [Berkshire]:Lima
Locality Name (eg, city) [Newbury]:Lima
Organization Name (eg, company) [My Company Ltd]:Asociacion Privada
Organizational Unit Name (eg, section) []:Sistemas
Common Name (eg, your name or your server's hostname) []:localhost
Email Address []:yourmail@mail.com

$ openssl req -new -key server.key -x509 -out server.crt
$ cp server.key server.key.save
$ openssl rsa -in server.key.save -out server.key

En el archvo de configuración collabnet_subversion_httpd.conf:
<location repos="">
....
<ifdefine ssl="">
SSLRequireSSL
</ifdefine>
....
</location>

Maven
Se descomprime el archivo de instalación y se crea una variable de entorno:
export MAVEN_HOME=/directorio/donde/estadescompimido/maven
export PATH=$PATH:$MAVEN_HOME/bin
$mvn --version

Por ultimo, si todo esta bien, tenemos que copiar y pegar nuestro setting.xml en
$HOME/.m2/setting.xml

Configuracion del tomcat
Para instalar tomcat, simplemente se descomprime el archivo en una ruta valida.
unzip apache-tomcat-6.0.20.zip
configurar el puerto del tomcat:
<connector port="8082"></connector>

Despues de configurar el Tomcat, inscribimos unas variables de entorno en el $home/.bashrc.
MAVEN_OPTS="-Xmx512m -XX:MaxPermSize=256m"

CATALINA_OPTS="-Xms1024m-Xmx1024m -Dorg.apache.jasper.runtime.BodyContentImpl.LIMIT_BUFFER=true -XX:MaxPermSize=256m"

Cambiando la Base de datos para Sonar:
Debemos de tener instalado una base de datos, en este caso al Mysql
$mysql -u root -p
(aqui pones el password)
mysql$ CREATE DATABASE sonar CHARACTER SET utf8 COLLATE utf8_general_ci;
mysql$ grant all privileges on sonar.* to 'sonar'@'localhost' identified by 'sonar';
mysql$ flush privileges

Instalación de Sonar
La instalación es bastante sencilla.Download y unzip en el directorio donde se va a guardar Sonar, lo descargamos de su pagina web, desempaquetar el zip:
$ unzip sonar-1.11.zip
Generamos el war:
InstalSonarDir/war$ ./build-war.sh ---> con esta sentencia generamos el war.
Solo basta colocar el war que generarmos en el webapp de tomcat y listo.
Http://localhost:8082/sonar

Instalación de Hudson
Descargar en esta dirección. Instalar Hudson, solamente basta con copiar y pegar en el webapp del tomcat.

Ahora solo falta levantar el tomcat.
$tomcat/bin/ ./startup.sh

y listo... ya tengo instalado nuestra integracion continua..

Repasando algunas caracteristicas de Groovy

2009-07-23T20:53:00.000-07:00

En este articulo veremos y explicaremos algunas de las caracteristicas de Groovy para aprender mas sobre este lenguaje dinámico, esperemos que les guste y espero muchas preguntas y/o comentarios.

Antes de comenzar este pequeño articulo debo de hacer una advertencia, y es que este artículo asume que ya instalaste Groovy y por lo menos sabes que es Groovy, si es todavia no lo haz instalado o no sabes que es Groovy, en la internet hay muy buenas guias que te pueden servir de ayuda.
Por otro lado tambien decirles que para ejecutar cada ejmplo de Groovy he utilizado la CONSOLA DE GROOVY(esto se logra escribiendo en la consola $groovyConsole), desde alli puedes ejecutar cada uno de los ejemplos que les muestro... diviertanse.

Objetivo.- como dije al principio, es el dar a conocer algunas caracteristicas de Groovy, se verán algunas diferencias y sobre todo como Groovy ahorra muchas líneas de código al programar y por ende nos hace la vida mas fácil. En conclusión mi objetivo es que se enamoren de este lenguaje.

Comenzaré por decir que en Groovy hay una serie funcionalidades que son opcionales, que detallo a continuación:

- En groovy el punto y coma (';'), al final de cada sentencia es opcional, .
- Los paréntesis '()', tambien son opcionales: ejm:
printl "hola" || tambien puede ser asi: println("hola")

- En un archivo .groovy se importa automaticamente los siguientes paquetes, asi es que no hay necesitad de importarlos explicitamente.
- groovy.lang.*
- groovy.util.*
- java.lang.*
- java.util.*
- java.net.*
- java.io.*
- java.math.BigDecimal
- java.math.BigInteger
- En groovy no es obligario el manejo de Excepciones Ejm:
[sourcecode language='java']
import groovy.sql.Sql
class GroovySqlExample1{
static void main(String[] args) {
def sql = Sql.newInstance("jdbc:mysql://localhost:3306/myBD", "root","root", "com.mysql.jdbc.Driver")
}
}
[/sourcecode]
- El retorno al final de cada método y/o bucle ya no son necesarios, en groovy la ultima sentencia que se ejecuta (en el caso de un closure) es lo que retorna. ejm:
[sourcecode language='java']
def retornotrue= {
x,y ->
x*y
}
def z= retornotrue(4,8)
[/sourcecode]
En este caso el closure recibe dos parametros (devuelve el producto de x*y) el resultado de ejecutar este codigo nos dará 32.

- Como habrán notado en el anterior ejemplo, estoy obviando el tipo de declaracion de las variables, lo cual sí esta permitido en Groovy, es por lo tanto un lenguaje opcionalmente tipado.

- También he usado la palabra 'def', pues esta palabra no es mas que una variable dinamica usada bastante en los lenguajes dinámicos como lo es Groovy.
por ejemplo:
[sourcecode language='java']
def varStr = "cadena"
def varInt = 345
println varInt.getClass()
println varStr.getClass()
[/sourcecode]
La ejecución de este código nos dará el sgte resultado:
class java.lang.Integer
class java.lang.String

De este modo comprobamos lo que estamos diciendo, la variable 'def' se comporta de una manera dinamica, adecuandose al tipo de variable que tiene al frente de ella.
Definiremos lo que es tambien un Closures, que en terminos prácticos digamos que es un método y se han fijado son muy parecidas a las clases anominas que existen en Java, para describirlo mejor es una porcion de código encerrado entre llaves, se pueden asignar a variables como si fuera un objeto más y por supuesto pueden recibir parametros y lo que retorna es la última sentencia que se ejecuta. Todo esto aporta agilidad y eficiencia a la hora de escribir un codigo.
Por Ejm:
[sourcecode language='java']
def lenguajes=['Java','Scala','Python','Groovy']

def imprime = lenguajes.find{
if(it.equals('Groovy')){
println "Estoy en Groovy"
return
}
println("estoy en otro lenguajes")
}
[/sourcecode]
En este caso estoy definiendo una lista de Strings, que despues las mando a través del closure 'imprime', llamo al metodo 'find()'(el cual hace una busqueda usando hibernate) y si es que encuentro una palabra que coincida con 'Groovy' que imprima "Estoy en Groovy", en caso contrario "Estoy en otro lenguaje".

Veamos un ejemplo de como haces un archivo xml en Groovy
[sourcecode language='java']
def sw = new StringWriter()
def xml = new groovy.xml.MarkupBuilder(sw)
xml.langs(type:"current"){
language("Java")
language("Groovy")
language("JavaScript")
}

def writer = new File("lenguajes.xml")
writer.write(sw.toString())
[/sourcecode]
el resultado seria un archivo .xml que se llamará lenguajes.xml, y mostrará lo siguiente:
[sourcecode language='java']

Java
Groovy
JavaScript

[/sourcecode]
También se puede hacer un .groovy con codigo java puro (como ya lo mostré en un blog anterior), pero no tendría sentido ya que no podriamos aprovechar las bondades que nos brinda groovy.

Como se habrán dado cuenta, en groovy se simplifica las lineas a codificar y por supuesto disminuye el riesgo de errores.

Este articulo continuará.

Groovy... una mirada superficial

2009-07-03T16:45:00.000-07:00

Para que entiendan Grails primero tienen que entender Groovy ya que Grails esta basado en groovy, en este articulo doy un ejemplo trivial pero importante dado a los nuevos conceptos que nos da este lenguaje dinámico.
Groovy es un lenguaje moderno de programación que se ejecuta en la plataforma Java (JVM). Que ofrece una muy buena integración con el código Java existente al tiempo que intr oduce nuevas características como closures y metaprogramming.

En palabras de Jorge Ferro Groovy es un lenguaje orientado a objetos que genera código ejecutable (byte code)
para la máquina virtual de Java. Toma “prestado” las ideas de otros lenguajes como Smalltalk, Ruby y Python y mantiene una sintaxis familiar a la de Java, cosa muy conveniente para los “Javeros”

Sin mas preambulos vallamos a un ejemplo clásico que supongo que ya lo habran visto, el "hola mundo", para este ejemplo se asume que ya tienes instalado Groovy, que simplemente se reduce a bajar el .zip, y crear tu variable de entorno. Lo pruebas poniendo en la linea de comando "groovy -version". aqui hay un articulo sobre el tema

[sourcecode language='java']
public class HolaMundo{
public static void main(String[] args){
System.out.println("Hola Mundo");
}
}
[/sourcecode]

y ahora por supuesto, el mismo ejemplo pero en Groovy, que en su forma mas sencilla es esto:

Abres la shell de groovy (groovysh) y escribes:
[sourcecode language='java']
println "Hola Mundo"
[/sourcecode]

Para un programador que recien se inicia en el mundo de los lenguajes de programacion, esto le puede parecer muy sencillo de comprender, pero para un desarrollador experimentado hay algo más... inmediatamente despues de haber visto el codigo (Groovy) estoy seguro de que tienen muchas preguntas.

Por favor, ahora si vayamos al ejemplo anterior (HolaMundo.java). Pues en este ejemplo se consolida varios conceptos básicos de java, por ejemplo; todos sabemos que lo primero que debemos hacer en java es crear un archivo con el nombre de la clase, asi pues para el ejemplo seria: HolaMundo.java. Despues, este ejemplo no correria si es que no no se tiene el 'public static void main', el uso de los punto y comas al final de cada sentencia, y asi podemos seguir repasando otros conceptos, y que despues de todas esas enseñanzas vengan de buenas a primeras y que me digan.... println "Hola Mundo"... pues lógico que tengo que levantar la mano y decir "que paso con lo anterior".

Esto es groovy, muchos ya lo conocen y con este ejemplo trivial he querido demostrar lo que Groovy puede hacer por nosotros (los programadores), disminuye drámaticamente las lineas de codigo a escribir, tiene la ventaja de los lenguajes dinamicos, y ademas conserva una sintaxis parecida a la que estamos acostumbrados en java.

Groovy es Java y Java es Groovy y no lo estoy diciendo en forma figurada, Para demostrarlo que mejor que un ejemplo:

Tenemos una clase Alumno.java
[sourcecode language='java']
public class Alumno{
private String nombre;
private Integer codigo;

public String getNombre(){
return nombre;
}
public void setNombre(String nombre){
this.nombre= nombre;
}
public Integer getCodigo(){
return codigo;
}
public void setCodigo(Integer codigo){
this.codigo=codigo;
}
}

[/sourcecode]
y ahora lo vamos hacer en Groovy

[sourcecode language='java']
class AlumnoGroovy{
String nombre
Integer codigo
}
[/sourcecode]

Hay que remarcar que en Groovy todas las clases son publicas (a menos que se especifique lo contrario) y todas las propiedades de la clases son privadas, y los metodos de las propiedades son publicos y el compilador groovy proporciona el conjunto de getter y setter de forma automatica.
Compilamos nuestros archivos

[sourcecode language='java']
$javac Alumno.java
// y en el caso de groovy
$groovyc AlumnoGroovy.groovy.
[/sourcecode]

Veremos los resultados utilizando el comando javap que se encargara de desensamblar un fichero class.

$javap -p Alumno

[sourcecode language='java']
Compiled from "Alumno.java"
public class Alumno extends java.lang.Object{
private java.lang.String nombre;
private java.lang.Integer codigo;
public Alumno();
public java.lang.String getNombre();
public void setNombre(java.lang.String);
public java.lang.Integer getCodigo();
public void setCodigo(java.lang.Integer);
}
[/sourcecode]

$javap -p AlumnoGroovy

[sourcecode language='java']
Compiled from "AlumnoGroovy.Groovy"
public class AlumnoGroovy extends java.lang.Object implements groovy.lang.GroovyObject{
public static final java.lang.Class $ownClass;
private java.lang.String nombre;
private java.lang.Integer codigo;
private static org.codehaus.groovy.reflection.ClassInfo $staticClassInfo;
private transient groovy.lang.MetaClass metaClass;
public static java.lang.Long __timeStamp;
public static java.lang.Long __timeStamp__239_neverHappen1246636547916;
private static java.lang.Class $class$java$lang$Class;
private static java.lang.Class $class$groovy$lang$MetaClass;
private static java.lang.Class $class$AlumnoGroovy;
private static java.lang.ref.SoftReference $callSiteArray;
public AlumnoGroovy();
protected groovy.lang.MetaClass $getStaticMetaClass();
public groovy.lang.MetaClass getMetaClass();
public void setMetaClass(groovy.lang.MetaClass);
public java.lang.Object invokeMethod(java.lang.String, java.lang.Object);
public java.lang.Object getProperty(java.lang.String);
public void setProperty(java.lang.String, java.lang.Object);
static {};
public java.lang.String getNombre();
public void setNombre(java.lang.String);
public java.lang.Integer getCodigo();
public void setCodigo(java.lang.Integer);
public void super$1$wait();
public java.lang.String super$1$toString();
public void super$1$wait(long);
public void super$1$wait(long, int);
public void super$1$notify();
public void super$1$notifyAll();
public java.lang.Class super$1$getClass();
public boolean super$1$equals(java.lang.Object);
public java.lang.Object super$1$clone();
public int super$1$hashCode();
public void super$1$finalize();
private static java.lang.Class $get$$class$java$lang$Class();
private static java.lang.Class $get$$class$groovy$lang$MetaClass();
private static java.lang.Class $get$$class$AlumnoGroovy();
static java.lang.Class class$(java.lang.String);
private static org.codehaus.groovy.runtime.callsite.CallSiteArray $createCallSiteArray();
private static org.codehaus.groovy.runtime.callsite.CallSite[] $getCallSiteArray();
}
[/sourcecode]

Como ven el archivo groovy tiene todo lo que tiene la clase java, esto quiere decir que una vez que tienes compilada la clase groovy, otras clases java pueden utlizarlas como si hubiera sido escrito en codigo java. Pero no voy a quedar con una especulacion y a continuación probaremos que esto es cierto.

Creamos una clase que servirá para probar lo dicho anteriormente:

[sourcecode language='java']
public class CrearAlumnoJava{
public static void main(String agrs[]){
/**Con Java**/
Alumno al= new Alumno();
al.setNombre("Edwin Farfan");
al.setCodigo(1234);
System.out.println("Alumno Creado con Java: "+ al.getNombre());

/**Con Groovy**/
AlumnoGroovy ag=new AlumnoGroovy();
ag.setNombre("Jose Diaz");
ag.setCodigo(5678);
// en el .groovy no hay definido un set pero sin embargo se puede llamarlo.
System.out.println("Alumno Creado con Groovy: "+ ag.getNombre());
}
}

[/sourcecode]

Ejecutamos la clases CrearAlumnoJava con el sgte codigo:
java -classpath $GROOVY_HOME/embeddable/groovy-all-1.6.3.jar:. CrearAlumnoJava

y el resultado será el sgte:
Alumno Creado con Java: Edwin Farfan
Alumno Creado con Groovy: Jose Diaz

Listo ya hemos probado que Groovy se puede ejecutar en una clase java comun y corriente.
Ahora vamos hacer lo mismo pero con Groovy.

[sourcecode language='java']
class CrearAlumnoGroovy{

public static void main(String []agrs){
/*con Java*/
def al=new Alumno(nombre:"Edwin", codigo:1234)
println "Nombre del Alumno Java: " + al.nombre

/*con Groovy*/
def ag=new AlumnoGroovy(nombre:"joedayz", codigo:5678)
println "Nombre del Alumno Groovy: "+ag.nombre
}
}
[/sourcecode]

Fijense como llamo a la Clase Alumno en el propio archivo groovy, esto demuestra que se puede llamar un .java llama desde un .groovy, tambien hay que resaltar algo nuevo la variabe 'def', que no es más que una variable dinámica (la van a ver bastante), aqui en este ejemplo no hay necesidad del ";", si queremos podemos decir por ejemplo "ag.getNombre()" en lugar de "ag.nombre", esto no variaría en lo absoluto el resultado.

Compilamos el archivo de groovy:
$ groovyc CrearAlumnoGroovy.groovy

y lo ejecuto:
$ groovy CrearAlumnoGroovy

mostrará el sgte resultado:
Nombre del Alumno Java: Edwin
Nombre del Alumno Groovy: joedayz

Con esto hemos demostrado la integracion de Groovy con Java es perfecta, con pequeños ejemplos hemos rozado la superficie de Groovy, espero que esto les sirva para que se adentren mas sobre el tema.

Espero que haya comentarios y preguntas sobre el tema.

Saludos .
Ahhh se me olvidaba aqui les dejo el Codigo Fuente

Desarrollando con Grails

2009-06-18T08:01:00.000-07:00

Despues de un buen tiempo le doy un poco de espacio a este blog en la web.

El objetivo de este post publicar un poco mi experiencia que tengo sobre grails aqui en este post, y espero que sirva de ayuda.

Descubri Groovy a finales del año 2006 tenia el libro "Groovy in Action", pero lo descuide por estar evocado a mi trabajo, todo el 2007 no pude ni siquiera verlo, en ese entonces llegaban noticias como Netbeans aposto por JRuby y no por Groovy o cosas asi, que parecia que el norte estaba a Ruby.

Despues en el 2008 estuve viendo un poco sobre phyton, lo cual me dejo muy satisfecho, es que era tan facil programar sobre todo los que recien empiezan en el mundo de la programacion, dicen que es bueno para juegos... por mi parte tengo que decir que no llegue a ese nivel, porque estaba metido en investigar otras herramientas (creo que en ese tiempo estuve viendo extjs e ibatis).

Casi a finales de 2008 comence a ver Grails, framework para el desarrollo web basado en Groovy, en esa epoca ya estaba trabajando con Spring, Hibernate y JSF, lo cual me fue de gran ayuda para comprender más rapido Grails.

Poco a poco comence hacer mis demos en grails, entendiendo conceptos y/o DSL como Scafolding, GORM (dicho sea de paso es espectacular), utilizando plugin que hacen todavia mas facil la tarea de solucionar problemas comunes y/o complejos.

Si quieres trabajar en Grails tienes que tener en cuenta que por ejemplo la version 1.1.* ya no soporta jdk 1.4, utiliza como minimo java5. Si es que quieres utlizar jdk 1.4 de todas maneras entonces tendrás que utilizar la version 1.0.

Soporta la gran mayoria de Base de Datos, por defecto viene embebida la HSQL, dificilmente la usaras en ambiente de producción, tambien viene un Jetty embebido; asi que desde el primer momento no necesitas ni BD ni un servidor web para correr tus demos.

Es altamente recomendable que hayas utilizado (o que sepas conceptos basicos de) Hibernate y Spring ya que grails se ha basado en estos dos frameworks y si es que no tienes conocimientos de estos framework, va hacer mas costosa la curva de aprendizaje.

Un punto importante es Groovy en el cual grails esta basado; este lenguaje te abrira la mente,te olvidaras de los ";" al final de cada sentencia, te introduciras en el mundo de los "closures", etc, etc. Groovy es un lenguaje dinamico para la JVM, por ende ya tiene solucionado problemas que Java ha solucionado, la Escalabilidad, Concurrencia, Garbage colector, Excepciones, Herencia, etc, etc; ya viene con todo eso y ademas con las bondades de un lenguaje dinamico que por ejemplo: ya no tendrás que parar tu servidor web para corregir un pedazo de codigo en tu controller.

Finalmente recomendarte (no esta demas) que antes de que inicies un proyecto para grails (y para todos tus proyectos), es muy importante que cuentes con un analisis de diseño de la aplicación.

Otra cosa que me olvidaba,es que utilizaras bastante la consola para ejecutar script Grails, porque todavia no hay un buen soporte de Grails en IDEs tales como por ejemplo Eclipse, en Netbeans he oido que tiene un mejor soporte pero para ser francos no lo he probado; lo que si he probado es el Intellij IDEA, que es un excelente ide y tiene (creo yo) el mejor soporte para Grails pero es con licencia osea hay que comprarlo.

Espero que haya sido de ayuda, si es que eres un fanatico de java por supuesto que te va ha interesar entrar en el nuevo mundo de lenguajes dinamicos que te va abrir la mente; desde luego tienes algunas otras alternativas a groovy, como por ejemplo Ruby, Phyton, Scala; pero eso ya seria otro tema.

Saludos

Haciendo un login en grails

2009-06-01T17:47:00.000-07:00

En esta ocación vamos a ver como hacer un login para nuestra aplicación web, verán lo facil que es, esto se puede hacer en unos pocos minutos.

Ya tenemos creada nuestra aplicacion llamanda BookStore, nos situamos en el directorio raiz de nuestra aplicación y instalaremos acegi, es un plugin que maneja la seguridad en una aplicacion grails. Si es que desean mas información aqui esta la pagina web del plugin acegi.

Ponemos lo sgte por consola:
[sourcecode language='java']
grails install-plugin acegi
[/sourcecode]

Seguidamente vamos a crear nuestras clases dominio que vamos a necesitar para nuestro login.
[sourcecode language='java']
grails create-auth-domains Usuario Rol Requestmap
[/sourcecode]

Entonces queremos crear Usuarios y manejar roles por Usuario... ponemos en consola lo sgte:
[sourcecode language='java']
grails generate-manager
[/sourcecode]

Este comando proporciona al usuario la posibilidad de registrarse y crear su nombre de usuario y contraseña.
[sourcecode language='java']
# grails generate-registration
[/sourcecode]

Bien ya esta... tenemos a nuestra aplicacion con login, roles y usuarios.
Fijense que simple que es, solo con cuatro script tenemos todo esto y con el soporte que nos da acegi (de springframework).

Pero no quiero quedarme alli, vamos a crear un controller para que prueben el login.

[sourcecode language='java']
grails create-controller Seguridad
[/sourcecode]

Lo modificamos para que simplemente muestre un mensaje:
[sourcecode language='java']
class SecureController {
def index = {
render 'Bienvenido a un sitio restringido'
}
}
[/sourcecode]

Recuerden que todavia no hemos creado ningun usuario o rol asi es que corramos nuestra aplicacion y comprobamos que todo esta en orden

[sourcecode language='java']
grails run-app
[/sourcecode]

http://localhost:8080/Bookstore

Para este post he optado por trabajar con anotaciones, asi es que le diremos a grails que queremos trabajar con anotaciones, y modificaremos el sgte archivo:
BookStore/grails-app/conf/SecurityConfig.groovy:
[sourcecode language='java']
security {

// see DefaultSecurityConfig.groovy for all settable/overridable properties
active = true
loginUserDomainClass = "Usuario" authorityDomainClass = "Rol"
useRequestMapDomainClass = false
useControllerAnnotations = true
}
[/sourcecode]

ya que estamos trabajando con anotaciones, borraremos las clases dominio, el controller y la vista de Requestmap:
BookStore/grails-app/domain/Requestmap.groovy
BookStore/grails-app/controllers/RequestmapController.groovy
BookStore/grails-app/views/requestmap/*)

Ahora vamos a crear un Rol, y luego creamos un usuario.

supongamos que creamos un Rol "ROLE_ADMIN"
y un usuario "Administrador"

Ahora añadiremos nuestro controller Seguridad la anotacion para que solamente pueda el rol Administrador:
[sourcecode language='java']
import org.codehaus.groovy.grails.plugins.springsecurity.Secured
class SecureController {
@Secured(['ROLE_ADMIN'])
def index = {
render 'Bienvenido a un sitio restringido'
}
}
[/sourcecode]

Bien ahora haremos que nuestro controller "Seguridad" sea la pagina de inicio, para ello vamos a modificar el sgte archivo: grails-app/conf/UrlMappings.groovy

[sourcecode language='java']
class UrlMappings {
static mappings = {
"/$controller/$action?/$id?"{
constraints {
// apply constraints here
}
}
"/"(controller:"seguridad")
"500"(view:'/error')
}
}
[/sourcecode]

Eso es todo...

PD: Pongo a disposición el codigo fuente de este ejemplo
SecurityApp

Conferencia de grails en SpringLive2009

2009-05-22T16:03:00.000-07:00

El sabado 16 se celebró el SpringLive que organizó la empresa que actualmente estoy laborando (joedayz) y en la cual soy miembro del equipo de desarrolladores. El evento contó con la participación de destacados profesionales de nuestra carrera, y de distintas empresas, los cuales estuvieron a la altura del evento.

En el grupo de google de ITP_JAVA y en Springperu pueden encontrar mas detalles sobre este evento, los diferentes demos y codigo fuentes de las demos.

Por mi parte, ya les dije que soy parte de joedayz y soy el encargado de la investigación e integración con nuestro framework en grails, hice una pequeña demo en grails, no fue la gran cosa pero el objetivo era dar a conocer las bondades que nos ofrece desarrollar con grails, ya que casi nadie sabia lo que es grails (al menos en la conferencia nadie sabia sobre este framework).

La aplicacion que hice se trataba de un mantenimiento de libros con autor, incluyendo una busqueda para libros y exportacion a excel y a pdf... ahhh y ademas explicamos como configurar la Base de datos en nuestro proyecto. Todo esto en menos de 30 minutos, claro explicando cada punto que estaba dando y por supuesto, respondiendo preguntas del público presente.

Les dejo con la explicacion del proyectito que hice:

El primer paso logicamente es descargarme Grails, configurar la variable de entorno para grails (Grails_Home) y tambien de java (Java_Home).

Verificamos si es que todo esta conforme con el siguiente script: grails help, si todo esta conforme, te deberia mostrar la version de grails que estas utilizando y una lista de scripts que puedes usar.

Bueno procedamos a la creación de nuestro proyecto
[sourcecode language='java']
grails create-app BookStore
[/sourcecode]
Con este Script creamos una estructura básica para nuestro proyecto.
Entramos al directorio de nuestra aplicacion: cd Bookstore

Resumire las carpetas que se han creado:
* grails-app: Carpeta donde tendremos que modificar para su funcionamiento(controllers, vistas, clases de dominio, taglibs, configuraciones,etc.)
* lib: Librerías para nuestro proyecto
* plugins: Plugins instalados
* scripts: Scripts Gant
* src: Clases java o groovy adicionales.
* test: Para pruebas unitarias o de integracion para nuestro proyecto
* web-app: css, imágenes, html, etc.

Crearemos una clase dominio que se llamara Book
[sourcecode language='java']
grails create-domain-class Book
[/sourcecode]

Una clase dominio vendría hacer el corazon de nuestra aplicación, una de las caracteristicas mas importantes que tienen las clases dominio es que automáticamente son mapeadas en un tabla fisica de nuestra Base de datos, y son persitentes (despues vamos a configurar la BD).

Abrimos nuestra clase dominio, que se encuentra en BookStore/grails-app/domain/Book.groovy


Break: (explicar dos puntos)
- Recordemos que grails esta basado en Groovy, es por ello que lleva una extension .groovy.
- Podemos abrir nuestras clases groovy con cualquier editor de texto, o si prefieren pueden utilizar cualquiera de los Plugin  que estan disponibles para los IDEs.

Modificamos nuestra clase dominio Book poniendo solamente esto:
String titulo
String autor

Ahora Crearemos nuestro Controller para nuestra Clase domino Book.
[sourcecode language='java']
grails create-controller Book
[/sourcecode]

A continuacion veremos un concepto muy conocido en lenguajes dinamicos:
Scaffolding, básicamente es la generación de código automático para una aplicación CRUD.

Abrimos nuestro controller BookController (BookStore/grails-app/controller), y ponemos

BookController.groovy
[sourcecode language='java']
def scaffold = Book
[/sourcecode]

y eso es todo lo que tenemos que hacer para tener nuestra aplicacion CRUD para Book.

Ahora escribimos en consola el sgte script, para correr nuestra aplicación:
[sourcecode language='java']
grails run-app
[/sourcecode]

listo, lo podemos ver en http://localhost:8080/Bookstore

Si es que tienen un tomcat instalado y esta utilizando el puerto 8080, les va a salir un error, esto se soluciona de la sgte manera:
[sourcecode language='java']
grails -Dserver.port=9090 run-app
[/sourcecode]
y nuestra aplicacion correra en el 9090.
http://localhost:8090/Bookstore

Bien, si todo va bien debereria mostrarte la aplicacion CRUD.


En Grails viene por defecto embebido un contenedor de servlet Jetty y una BD en memoria HSQL.

Ahora modificaremos los datos de nuestra BD, y eso lo vamos hacer en el archivo DataSource

BookStore\grails-app\conf\DataSource.groovy
en nuestro caso vamos a cambiarla a Mysql:

[sourcecode language='java']
dataSource {
pooled = true
driverClassName = "com.mysql.jdbc.Driver"
dialect = org.hibernate.dialect.MySQLInnoDBDialect
username = "root"
password = "root"
}
// en la parte de environments modificamos la
// parte development

development {
dataSource {
dbCreate = "update"
url = "jdbc:mysql//localhost:3306/MyDataBase"
username = "root"
password = "root"

}
}
[/sourcecode]

Modificamos nuestra clase domino Book
[sourcecode language='java']
String titulo
Date fecha
String editorial
Autor autor
//constrainsts es para poner validaciones
static constraints = {
titulo(nullable:false, blank:false, size:1..80)
fecha()
editorial(nullable:false, blank:false, size:1..60)
autor(nullable:false, blank:false, size:1..60)
}

[/sourcecode]

Creamos una clase dominio Autor:
ponemos en consola
[sourcecode language='java']
grails create-domain-class Autor
[/sourcecode]

y abrimos la clase y modificamos su contenido
[sourcecode language='java']
String nombre
String apellido
static constraints = {
nombre(nullable:false, blank:false, size:1..80)
apellido(nullable:false, blank:false, size:1..80)
}

[/sourcecode]

Ok.. todo bien!!!
Bien ahora nos toca aprender otro script generate-all, este script nos va generar toda nuestra vista y controladores para una clase dominio especifica.
Entonces escribimos en consola el sgte script
[sourcecode language='java']
grails generate-all Book
[/sourcecode]
Nos preguntará si es que queremos sobreescribir el controller que ya anteriormente hemos creado... le decimos que si ('y').

Igualmente hacemos lo mismo para la clase dominio Autor.
[sourcecode language='java']
grails generate-all Autor
[/sourcecode]

y corremos nuestra aplicacion
[sourcecode language='java']
grails run-app
[/sourcecode]

ya esta.... tenemos dos CRUD con validaciones y persistentes.

Ahora vamos hacer algo nuevo.
instalaremos un plugin para dar una nueva funcionalidad a mi aplicación. En este caso sera un plugin para busquedas.
[sourcecode language='java']
grails install-plugin searchable
[/sourcecode]

añadiremso a nuestra clase de dominio Book, la sgte variable:
[sourcecode language='java']
String titulo.....
//Variable para la busquedas.
static searchable = true

static constraints = {....
[/sourcecode]

y generamos la vista y controller para Book
[sourcecode language='java']
grails generate-all Book
[/sourcecode]

corremos nuestra aplicacion, y obtendremos este resultado.

update 25-05-09

Bueno, ahora lo que vamos hacer es exportar nuestra lista a un excel y a un pdf.
Comenzaremos primero con la instalación del plugin export:
[sourcecode language='java']
grails install-plugin export
[/sourcecode]
Despues de la instalación añadiremos a nuestro archivo Config.groovy
[sourcecode language='java']
grails.mime.types = [ html: ['text/html','application/xhtml+xml'],
xml: ['text/xml', 'application/xml'],
text: 'text/plain',
js: 'text/javascript',
rss: 'application/rss+xml',
atom: 'application/atom+xml',
css: 'text/css',
csv: 'text/csv',
pdf: 'application/pdf',
excel: 'application/vnd.ms-excel',
all: '*/*',
json: ['application/json','text/json'],
form: 'application/x-www-form-urlencoded',
multipartForm: 'multipart/form-data'
]

[/sourcecode]

En nuestro archivo list.gsp de nuestra clase dominio Book (BookStore\grails-app\views\book), ponemos lo sgte:
[sourcecode language='java']

...

...
....

[/sourcecode]

y en el controller modificamos lo sgte:
[sourcecode language='java']
import org.codehaus.groovy.grails.commons.ConfigurationHolder
class BookController {
def exportService
....
def list = {
params.max = Math.min( params.max ? params.max.toInteger() : 10, 100)
if(!params.max) params.max = 10

if(params?.format &amp;amp;amp;amp;amp;amp;amp;amp;&amp;amp;amp;amp;amp;amp;amp;amp; params.format != "pdf"){
response.contentType = ConfigurationHolder.config.grails.mime.types[params.format]

response.setHeader("Content-disposition", "attachment; filename=books.${params.format}")

exportService.export("pdf", response.outputStream,Book.list(params), [:], [:]) }

if(params?.format &amp;amp;amp;amp;amp;amp;amp;amp;&amp;amp;amp;amp;amp;amp;amp;amp; params.format != "excel"){ response.contentType=ConfigurationHolder.config.grails.mime.types[params.format]
response.setHeader("Content-disposition", "attachment; filename=books.${params.format}")

exportService.export("excel", response.outputStream,Book.list(params), [:], [:]) }

[ bookInstanceList: Book.list( params ), bookInstanceTotal: Book.count() ]
}
......
[/sourcecode]

y ya esta.... tenemos la exportacion de excel y de pdf. El Plugin export soporta los sgtes formatos:
* CSV
* Excel
* ODS
* PDF
* XML

Conclusión:
Grails ha nacido para ser un framework con el que sea agradable trabajar, sin repetir código (autogeneracion de codigo),con una curva de aprendizaje relativamente baja, con instalacion de plugin que facilitan tareas, etc, un largo etc.

Allli esta el codigo completo.
BookStore

RECURSOS
www.grails.org
www.groovy.org.es
www.manual-de-grails.es --->libro en español
http://www.ibm.com/developerworks/java/library/j-grails01158/

JBDC con Spring

2009-02-07T20:31:00.000-08:00

Veran lo simple que es manejar el Jdbc con Spring.
SpringFramework tiene un modulo Jdbc, el cual se encarga de aquellos detalles engorrosos de bajo nivel que pueden provocar que la API de JDBC sea muy tediosa (procesamiento de JDBC y el manejo de errores).

En el ejemplo que voy a darles utilizaré la clase JdbcTemplate la cual es la más utilizada para ejecutar queries (consultas, updates, stores procedures), esta clase se encarga de manejar la creación y liberación de recursos(lo cual es importante porque evita muchos errores comunes), dejando que el programador se ocupe de proveer el codigo SQL y de extraer los resultados.

Manos a la obra:
[sourcecode language='java']
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;

public class SpringJDBCExampleImpl implements SpringJDBCExample{
//Declaremos una propiedadad JdbcTemplate de esta Clase.
JdbcTemplate jdbcTemplate;

//En este metodo setearemos el DataSource
public void setDataSource(DataSource dataSource) {
this.jdbcTemplate = new JdbcTemplate(dataSource);
}

//Metodo en el cual introduciremos el query
public List BuscarEmpleado(){
StringBuffer sql=new StringBuffer();
sql.append(" select codigo, nombre, superior, departamento from Empleado ");
return jdbcTemplate.queryForList(sql.toString());
}
}
[/sourcecode]
En tu clase es lo unico que tienes que hacer, pero por supuesto, para que funcione en una aplicacion web tenemos agregarles unos pequeños detalles.

El DataSource debe ser configurado como un bean en el contexto de aplicación, el DataSource es parte de la especificación JDBC y puede verse como un pool de conexiones.

[sourcecode language='xml']

oracle.jdbc.driver.OracleDriver
jdbc:oracle:thin:localhost/SpingBD
myuser
mypassword

[/sourcecode]
En este ultimo bean estoy relacionando mi interface con la clase que la implementa, en este caso mi interface se llama SpringJDBCExample y la clase que la implementa se llama SpringJDBCExampleImpl, logicamente tengo que definir en mi interface todos los metodos que quiero implementar.

Despues en este mismo bean tengo una propiedad llamada dataSource,
esta propiedad hace referencia a MyDataSource, que biene hacer la conexion a la base de datos.

Bueno, esto ha sido un pequeño vistazo a uno de los modulos que tiene SpringFramework.

¿Overflow de un StringBuffer?

2009-02-06T15:28:00.000-08:00

Los objetos de la clase String están diseñados para ser inmutables. en la documentacion de JDK verán que cada método en la clase que aparentemente modifica un String en realidad crea y retorna un objeto String completamente nuevo que contiene la modificación. El String original no se toca para nada.

Sabiendo esto tenemos como opcion la clase StringBuffer,la cual permite guardar cadenas que puedan cambiar en la ejecución del programa, ademas soporta gran cantidad de caracteres (al menos eso es lo que creía). Según lo que he averiguado, las cadenas de carácteres realmente no están limitadas, sin embargo al estar indexadas por 'int', tenemos el límite fijado en 2^32 carácteres, es decir, una cadena de mas de 4Gb en memoria.

En java 5 hay una clase mas optimizada. StringBuilder, es idéntica a StringBuffer salvo que no es síncrona (StringBuilder is not thread safe), lo que significa que puede haber problemas si es una variable a la que accedan diferentes Hilos.

Hace poco me tope con un error raro de StringBuffer, trataba de llenar un reporte de excel y ademas mostrarlo en un jsp... para ello utlize un StringBuffer para hacer la funcionalidad descrita

[sourcecode language='java']
/**Este metodo es que que se encargaría
*de imprimir la tabla en html y despues lo utilizaría para
* exportar la tabla a Excel
*/
private String getHtmlTable() {
StringBuffer tableEmpleados= new StringBuffer();
tableEmpleados.append(" Nro de empleado");
tableEmpleados.append(" Nombre de Empleado ");

List lista = new ArrayList();
lista=getEmpleados(); //Metodo que captura la lista de empleados.
for (Iterator it = lista.iterator(); it.hasNext();) {
Object[] element = (Object[]) it.next();
String coEmpleado = (String) element[0];
String nombreEmpleado =(String) element[1];
//supongamos que tengo dos campos codigo empleado y nombre de empleado.

tableEmpleados.append(" " + coEmpleado + " ");
tableEmpleados.append(" " + nombreEmpleado + " ");
tableEmpleados.append("");

return tableEmpleados;

}

}
[/sourcecode]

Con unos pocos registros, esto funcionaba de maravilla, pero la tabla tenia miles de registros, entonces sucedio el Overflow, el StringBuffer al parecer habia llegado hasta el limite. trate que aumentar la memoria del VM pero no me funciono.

Siempre me votaba este error "java.lang.OutOfMemoryError: Java heap space", relacionado al StringBuffer.

Al final solucione (en parte) el problema dividiendolo en dos partes, el mostrarlo en un jsp (utlice una tabla faces), y la exportacion de excel en otro metodo(les dejo un link que me sirvio para aumentar velocidad).

Esta es mi tabla faces, en la que muestro los empleados:

[sourcecode language='java']

//se acuerdan del metodo getEmpleados (), aqui solo hay que especificar el metodo o variable que //contiene la lista de empleado y listo

//En este caso traigo el registro tal cual esta en la BD

[/sourcecode]

Anteriormente habia dicho que el problema lo habia solucionado en parte, porque si bien tenia la tabla faces funcionando, cuando le decia que queria traer todos los datos, me mostraba el mismo error.

[sourcecode language='java']
// cuando pongo rows="0" no estoy utlilizando paginacion

//traigo todos los registros

[/sourcecode]

Asi es que todavia me quedó la duda, ¿habia un overflow de StringBuffer?.... se que derrepente estan pensando que el error ("java.lang.OutOfMemoryError: Java heap space") fue por memoria, pues como explique anteriormente aumente la memoria; puede que tambien esten pensando que mi codigo esta mal codificado (derrepente tengan razon), pero tambien tendrian que decirme porque utilizando spring jdbc para traer los registros de la tabla y llamando directamente desde la tabla faces todos los registros, me sale el mismo error.

Por ultimo quiero recalcar que este codigo esta hecho con jdk 1.4, no lo he intentado con jdk 5.

Saludos

Store procedure en spring 2.0 (integrado con Hibernate)

2009-01-07T07:22:00.000-08:00

Hay diferentes maneras en spring para hacer una llamada a un store procedure

El link que ven arriba, hace una llamada a un store procedure haciendo uso de StoredProcedure, clase de Spring que provee de soporte para los Stored Procedures.

Hay un problema con usar este método, ya que por razones de adaptabilidad de la aplicación (y para hacerlo mas fácil dicho sea de paso), me incline por el método siguiente:

public class CallProcedureHibernate extends HibernateDaoSupport implements CallProcedureDAO{
JdbcTemplate jdbcTemplate;

public void setDataSource(DataSource dataSource) {
this.jdbcTemplate = new JdbcTemplate(dataSource);
}
public void ProcessBonus(){
CallableStatementCallback cb = new CallableStatementCallback() {
public Object doInCallableStatement(CallableStatement cs)
throws SQLException, DataAccessException{
cs.execute();
return null;
}
};
jdbcTemplate.execute("{ call SP_CALCULA() }", cb);
}
}

Eso es todo lo que tienen que hacer para llamar a un procedure sin valores de entrada ni salidas.

Logicamente se tiene que tener su services, dao y sus implementaciones, en el archivo de configuracion de hibernate ponemos lo siguiente:

<bean id="CallProcedureDAO" class="app.compensations.dao.hibernate.CallProcedureHibernate">
<property name="sessionFactory" ref="sessionFactory"/>
<property name="dataSource" ref="DataSource"/>
</bean>

Aqui tenemos configurado nuestro DAO, que hace referencia a nuestra clase que llama al Store procedure, logicamente debemos de tener nuestro Beans sessionFactory y DataSource. El primero se encarga de decir al sistema donde se encuentran todos los ficheros de mapeo de Hibernate, el dialecto de Hibernate a utilizar y también va a ser la encargada de asociar los DAO dentro de las Fachadas; El segundo definiremos un datasource con los valores de conexion a la BD o con jndi, segun sea el caso.

Algo sobre mi

2008-12-30T14:15:00.000-08:00

Quiero compartir con ustedes una parte de mi vida profesional.

Llevo desarrollando aplicaciones web con java un buen tiempo (un promedio de dos años), he estado utilizando diferentes(muchas) herramientas,plugin, frameworks, jars o como mejor lo llamen,para desarrollo y/o mantenimientos de aplicaciones Web.

Desde la más basica jsp y servlet hasta struts,spring,adf,jsf,extjs,ibatis...etc,etc.
y ni que hablar de las bases de datos, haciendo mis primeros pasos en Mysql siguiendo por DB2,
Oracle y postgres, en donde mas aprendí fue en oracle, aunque DB2 no se queda atras (aqui creo que más).
He estado en un continuo aprendizaje, y espero seguir asi hasta que la muerte nos separe, y este es un punto que es para reflexionar, ya que si bien suena interesante o emocionante estar en este continuo aprendizaje, es estresante hacerlo cuando existe un tiempo reducido, donde aparte de investigar tienes que desarrollar tu aplicacion perfectamente.

Estos tres ultimos meses he estado con varias herramientas nuevas trabajando que han hecho sudar la gota gorda, sin embargo la presion y algunos ejemplos en internet (San Google), me hicieron que logre los objetivos trasados en el trabajo.

Un gran tip que me ha servido mucho es ver codigo que ya esta hecho por otros desarrolladores,
otras aplicaciones y consultar en foros y blogs que debes de tener en tus favoritos, tengo una lista de las paginas web que utilizo para ayudarme para desarrollar mis aplicaciones. Otro de los tip que me ha funcionado (de una manera mas efectiva) es preguntar a personas mas experimentadas sobre un tema puntual, ojo preguntas puntuales.

Otro tema es el ingles que es muy necesario en esta carrera, por ejemplo me estoy preparando para ser un SCJP, los libros que estan especializados en el tema estan disponibles en ingles, además el examen esta en ingles (aunque hay versiones en español- según dicen mal traducidas), con todo esto como escaparse del ingles.

Quiero lograr la certificacion de Java 5.0, para ello me he propuesto dar mi examen aproximadamente en marzo (fecha en la que aparecen el retake de sun), espero tener tiempo para postear algunos articulos sobre la certificacion.

Nos vemos....

Busqueda de codigo

2008-12-18T12:40:00.000-08:00

Quiero compartir esta es una pequeña lista de paginas web que utilizo que me permite buscar codigo open source, y asi poder ver ejemplos y reutilizarlos.

Google
Es el que mas utilizo, permite buscar por Regex (regular expresion), y otras sintaxis.

Merobase
buscador de codigo a traves de muchos criterios como podreis ver en su pagina,
incluso permite encontrar una clase que satisfaga un test unitario.

debugOn
Este portal mezcla la publicación de artículos técnicos con las redes sociales.

snipplr

recortex

siafoo (en ingles)

friendsnippets (en ingles)

Supongo que deben de haber mas de estas paginas.

Descubriendo ADF

2008-03-27T21:59:00.000-07:00

Chequeando los requerimientos de un nuevo desarrollo para la empresa que laboro, y investigando sobre como desarrollar la nueva aplicación, encontré una opción que me pareció fantástica, ADF(Application Development Framework), ya había oído de él pero tenia muy poca (nada) experiencia usándolo.
Habría entonces que sumergirse a fondo para el desarrollo, y aquí les cuento sobre mi experiencia de este maravilloso framework.
Llevo algún tiempo desarrollando aplicación en lenguaje Java y este Framework te hace sentir muy bien, frente a las herramientas que tienes a la mano, digo esto porque el JDK que está implementado en el servidor web de la empresa es la versión 1.4, (pienso que una gran mayoría de empresas debe de estar con esta implementación) y en esta versión no existen muchas posibilidades muy buenas así como ADF.
Aquí les dejo un link de un workshop esta muy bueno y se los recomiendo.
Pero los inconvenientes (quizá por mi poca experiencia con este framework),que he podido encontrar son:

Tienes que saber Struts(o algun framework orientado a MVC).
La experiencia cuenta mucho, hay veces que es casi imposible descubrir un pequeño error.
El tema visual es bastante pobre, aunque ahora en la versiones actuales han mejorado mucho.

Estaré ampliando mas esta información