Bienvenido a la comunidad de desarrolladores G/G

Así como para aprender a conducir se necesita conducir, o para aprender a besar se necesita besar, Groovy se aprende con Groovy. En el taller de Groovy impartido por el Ing. Domingo Suarez, como parte de la sexta reunión de SpringHispano.org y JavaMexico.org se incluyó la siguiente charla, que me pareció oportuna como punto de comparación entre Groovy y Java. Se mostró mediante ejemplos la compatibilidad entre Groovy y Java: un programa para la consola escrito en Java:

HelloWorld en Java:

public class HelloWorld {
   String name;

   public void setName(String name)
   { this.name = name; }
   public String getName() { return name; }

   public String greet()
   { return "Hello "+ name; }

   public static void main(String args[]){
      HelloWorld helloWorld = new HelloWorld()
      helloWorld.setName("Groovy")
      System.err.println( helloWorld.greet() )
   }
}

Enseguida, el HelloWorld en Groovy:

public class HelloWorld {
   String name;

   public void setName(String name)
   { this.name = name; }
   public String getName() { return name; }

   public String greet()
   { return "Hello "+ name; }

   public static void main(String args[]){
      HelloWorld helloWorld = new HelloWorld()
      helloWorld.setName("Groovy")
      System.err.println( helloWorld.greet() )
   }
}

Muy bien. Entonces, ¿cuál es la diferencia? Ah, este ejercicio no mostraba la manera de trabajar con Groovy, sino que la curva de aprendizaje para un programador de Java es prácticamente de cero, es decir, si no recuerdan o no conocen cómo opera Groovy en algún punto específico, se puede escribir la porción en cuestión vía Java con el mismo resultado, pues prácticamente cualquier código en Java se puede trasladar a Groovy (son muy pocas las incompatibilidades). ¿Y cuáles son las ventajas? Se describieron poco a poco:

Groovy tiene la noción de "convención sobre configuración", en otras palabras, no da suma importancia a los detallazos como el punto y coma tras cada oración, y todo en Groovy es público a menos que se especifique lo contrario. Con estos dos puntos, se comenzó el camino del HelloWorld hacia la manera de Groovy:

Hacia el HelloWorld de la manera Groovy (1):

class HelloWorld {
   String name

   void setName(String name)
   { this.name = name }
   String getName() { return name }

   String greet()
   { return "Hello "+ name }

   static void main(String args[]){
      HelloWorld helloWorld = new HelloWorld()
      helloWorld.setName("Groovy")
      System.err.println( helloWorld.greet() )
   }
}

En este orden de ideas, Groovy llama "datos básicos" (o "boilerplate" en inglés) a la información fundamental de la organización al inicio de cualquier programa en Java: todos sabemos que para programar un JavaBean se requiere un par de get/set para cada propiedad: dejemos que Groovy lo escriba por uno. Lo mismo con Main(): siempre requiere String[] como parámetro. Dejemos que Groovy haga esa definición más corta con tipos opcionales. Enseguida, si imprimir a la consola es tan común, ¿podemos tener una versión más corta también?. Con Groovy, sí. Veamos cómo queda:

Hacia el HelloWorld de la manera Groovy (2):

class HelloWorld {
   String name

   String greet()
   { return "Hello "+ name }

   static void main( args ){
      HelloWorld helloWorld = new HelloWorld()
      helloWorld.setName("Groovy")
      println( helloWorld.greet() )
   }
}

Groovy usa la palabra clave def cuando no es indispensable indicar el tipo de variable, de manera similar a la palabra clave var en JavaScript. De esta manera Groovy deducirá el tipo correcto. A esto se le llama ordenamiento de tipos dinámicos (duck typing en inglés):

Hacia el HelloWorld de la manera Groovy (3):

class HelloWorld {
   String name

   def greet()
   { return "Hello "+ name }

   static def main( args ){
      def helloWorld = new HelloWorld()
      helloWorld.setName("Groovy")
      println( helloWorld.greet() )
   }
}

Los GStrings proporcionan interpolación de variable, como en Ruby o Python: Con anteceder ${} dentro de un String bastará:

Hacia el HelloWorld de la manera Groovy (4):

class HelloWorld {
   String name

   def greet() { return "Hello ${name}" }

   static def main( args ){
      def helloWorld = new HelloWorld()
      helloWorld.setName("Groovy")
      println( helloWorld.greet() )
   }
}

Ahora bien, no es necesario usar "def" en métodos estáticos, y es opcional la palabra clave "return": el valor de retorno de un método será la última expresión evaluada. En Groovy se traduce:

Hacia el HelloWorld de la manera Groovy (5):

class HelloWorld {
   String name

   def greet() { return "Hello ${name}" }

   static main( args ){
      def helloWorld = new HelloWorld()
      helloWorld.setName("Groovy")
      println( helloWorld.greet() )
   }
}

Acto seguido, el concepto de POJOs en esteroides. Los POJOs no sólo escriben sus propios accesorios de propiedad. Los POGOs (manera Groovy) también proporcionan un constructor predeterminado con parámetros (símiles) nombrados; además, soporte para subscripts de arreglo (bean[prop]) y notación de punto (bean.prop) para acceder a propiedades:

Hacia el HelloWorld de la manera Groovy (6):

class HelloWorld {
   String name

   def greet() { return "Hello ${name}" }

   static main( args ){
      def helloWorld = new
               HelloWorld(name:"Groovy")
      helloWorld.name = "Groovy"
      helloWorld["name"] = "Groovy"
      println( helloWorld.greet() )
   }
}

Por último (para esta demostración), Groovy soporta scripts (aunque compile clases a código de byte Java), y esos scripts también se compilan a código de byte Java. Dichos scripts permite que se definan clases en cualquier lugar sobre ellos y soportan paquetes, pues también son clases Java válidos.

HelloWorld a la manera Groovy (7):

class HelloWorld {
   String name
   def greet() { return "Hello ${name}" }
}

   def helloWorld = new HelloWorld(name:"Groovy")
      println( helloWorld.greet() )

Contra esta última versión hay un abismo de diferencia con el primer ejemplo, en Java. No obstante, sigue siendo Java. Groovy sigue el "mantra": Java es Groovy, Groovy es Java", y aquí se demuestra la compatibilidad a su máxima expresión. Casi el 98% del código Java es compatible con código Groovy. Podría cambiar la extensión de *.java a *.groovy y funcionará.

A todos los miembros de comunidades y personas interesadas en Desarrollo de Software, les hacemos la cordial invitación a que asistan a la 7a. Reunión organizada por springhispano.org, grails.org.mx y javamexico.org, el día Sábado 13 de Junio del 2009 a las 10:00 a.m., en esta ocasión, tendremos el honor de presentarles dos ponencias sobresalientes en desarrollo de software.

Las ponencias son:

Hablando en SCRUM por Segio Acosta (@scasware) de Comunidad Scrum (http://comunidadscrum.wordpress.com/)
Seguridad en Aplicaciones Java por Enrique Zamudio de Java México

Como es bien sabido por los asistentes, las reuniones son gratuitas y lo único que tienen que invertir es tiempo de querer compartir ideas y pasar un rato agradable con la gente que conozcan en el evento. Hacemos extensiva la invitación a sus conocidos y amigos que quieran involucrarse con el mundo Java y Spring.

Pueden encontrar información adicional en Coetus, además, que les pedimos de antemano se registren para poder darse de alta en el evento y si ya están registrados solo unanse al evento.

La liga: http://www.coetus.info/coetus/events/detail/10

Como nota adicional, queremos agradecer a quienes han asistido a reuniones anteriores por su asistencia y apoyo, en especial a Erick Camacho(@ecamacho), Isaac Ruiz(@rugi), Marco Antonio(@markitox) y Andrés Valdez(@avaldini), por el soporte que nos han brindado para la realización de las reuniones con el fin de que la comunidad crezca.

ATTE
Springhispano.org, grails.org.mx y javamexico.org
Los esperamos...

A todos los miembros de comunidades y personas interesadas en Desarrollo de Software, les hacemos la cordial invitación a que asistan a la 8a. Reunión organizada por springhispano.org, grails.org.mx y javamexico.org, el día Sábado 22 de Agosto del 2009 a las 10:00 a.m.

La agenda del día es la siguiente:

1.  "El MVC redefinido con Grails (Controllers y GSP)" por Jose Juan Reyes (@neodevelop) Charla en la cual hablara sobre como Grails implementa el MVC, asi como las librerias de Tags
2. Mesa redonda (OpenSpace) de administración de proyectos En esta mesa, Gustavo Muñoz, Javier Castañon, hablaran y daran la pauta para que los asistentes participen con sus experiencias en los diversos proyectos en los cuales se han visto involucrados. Tema muy interesante para debate.
   

El lugar de la reunión es en:

Ave. San Lorenzo 1009 Piso 4. Col. del Valle, México, D.F.

El registro es importante que se realice en Coetus, ya que es requerido saber la cantidad de asistentes a la reunión.

http://www.coetus.info/coetus/events/detail/11

Como nota adicional, queremos agradecer a quienes han asistido a reuniones anteriores por su asistencia y apoyo, en especial a Erick Camacho(@ecamacho), Isaac Ruiz(@rugi), Marco Antonio(@markitox),Rodolfo Velasco(@rvelascor) y Andrés Valdez(@avaldini), por el soporte que nos han brindado para la realización de las reuniones con el fin de que la comunidad crezca.

ATTE
Springhispano.org, grails.org.mx
Los esperamos...

Hacemos la cordial invitación a todos los desarrolladores interesados, miembros de la comunidad, redes sociales y publico que le apasione el desarrollo de software a la 10a. Reunión de la comunidad que se llevará a cabo el día 31 de octubre a las 10:00 A.M., en donde presentaremos el siguiente Taller:

Hands-on Spring 3: The next generation

Impartido por Sergi Almar(@sergialmar) - http://sergialmar.wordpress.com

Descripción:
El taller pretende descubrir las nuevas funcionalidades de Spring 3
dando un previo repaso a lo tenemos hasta ahora con Spring 2.5. Se van
a cubrir aspectos como el nuevo Spring EL, el soporte para REST,configuración al estilo JavaConfig... Todo ello implementando una aplicación real que va a poner en práctica todo lo nuevo!

Acerca del ponente:
Sergi Almar es un ingeniero senior de software apasionado por Java /
JEE. Durante los últimos 4 años, ha estado trabajando en sistemas
desarrollados con Spring. Actualmente, invierte su tiempo impartiendo
cursos oficiales de Spring principalmente en España y latino América
como instructor certificado de SpringSource y desarrollando sus
diferentes proyectos personales.

Requerimientos para aprovechar al máximo el taller:

Los asistentes deberán llevar su propio equipo(laptop) con Java y SpringSource Tool Suite instalado.

Recordandoles que la entrada es totalmente gratuita y que habrá algunas sorpresas para los asistentes...

El lugar de la reunión es en:

Ave. San Lorenzo 1009 Piso 4. Col. del Valle, México, D.F.

El registro es importante que se realice en Coetus, ya que es requerido saber la cantidad de asistentes a la reunión.

La liga del registro es:

http://www.coetus.info/coetus/event/show/13

De antemano agradecemos su asistencia y participación...

ATTE

Staff de SH.org, grails.org.mx y JavaMexico

SynergyJ.com la empresa detrás de las comunidades de Springhispano.org y grails.org.mx, invitan a los desarrolladores interesados a los siguientes cursos:

1. Java Básico
2. Persistencia en Java con Hibernate
3. Desarrollo ägil con Groovy & Grails

De antemano muchas gracias

ATTE

Staff de SynergyJ.com

Amigos¡ los invitamos a la siguiente reunión de @SpringHispano y @grailsmx, en esta ocasión tenemos 2 temas muy interesantes

1. 10:00 am Introducción al lenguaje de programación Scala y sus principales características por Julio Gomez (@thegeekinside) reconocido ingeniero con amplia experiencia en el sector y entusiasta de nuevas tecnologías y participante de varias comunidades de desarrolladores
2. 12:00 am Modularización efectiva: Domando a la Hydra por Agustin Ramos (@MachinesAreUs) Profesional de desarrollo de software con 8 años de experiencia en la industria. Es miembro de la IEEE y ACM. Sus intereses se centran en servicios internet altamente escalables, sistemas transaccionales masivamente distribuídos, servicios móviles, geoposicionales y líneas de productos. Impulsor de las tecnologías abiertas, el código limpio y la metáfora del artesano como una descripción más adecuada de nuestra profesión
3. 14:00 pm Comida, netwoking y rifa de regalos ofrecemos una comida a los asistentes para platicar y conocernos mejor, de igual manera se aprovechara este tiempo para hacer la rifa de una licencia de IntelliJ Idea y entrega de cupones de descuento para comprar libros en Orelly, Manning y Apress