Bienvenido a la comunidad de desarrolladores G/G

Bienvenidos sean todos a este sitio.

Este es un esfuerzo del Staff de SpringHispano.org para colaborar con las comunidades relacionadas con las tecnologías Groovy y Grails; como hemos venido viviendo, las tecnologías de desarrollo están en constante movimiento y el día de hoy contamos con herramientas que nos facilitan el desarrollo de software y además potencializan el uso de otras tecnologías que por si solas son herramientas imprescidibles en el desarrollo de software.

Groovy es un lenguaje dinámico que se ejecuta en la JVM, sin embargo, muchos grandes(SpringSource por ejemplo) lo consideran un elemento fundamental en el futuro del desarrollo de aplicaciones, y como tal, ofrece muchisimas características que pueden ser aprovechadas por los desarrolladores para facilitar su trabajo, y precisamente para cubrir en la medida de lo posible esas ventajas y desventajas, hemos creado este sitio.

Grails es un framework (ya considerado tambien una plataforma de desarrollo) que esta basado en tecnologías sólidas como Spring, Hibernate, SiteMesh, Prototype, Jetty, HSQLDB y que suma la potencialidad de Groovy para escribir el código de la aplicación...

En realidad los conceptos citados anteriormente no son la definición de Groovy y de Grails, para ver como los creadores definen estas tecnologías debemos de consultar directamente su documentación, lo único que pretendemos es crear un panorama de lo que queremos lograr con este sitio.

Uno de los objetivos de grails.org.mx es tener un lugar donde se pueda consultar y escribir artículos referentes de Groovy y Grails en español, pues existen muchisimos sitios en Inglés y Francés, sin embargo, hay muy pocos en español.

Ahora bien, como parte de seguir cumplir con nuestro mantra y nuestros principios, este sitio esta desarrollado precisamente con G&G, la versión que estamos liberando en este momento es la 0.1 de un CMS que nombramos Codice y que esta disponible como Open Source. El compromiso será entonces ir mejorando las características de este proyecto para beneficio de los usuarios del sitio y de quienes quieran usar el proyecto ya sea para aprender o bien para publicar contenido, y por lo tanto, siempre será bienvenida la retroalimentación, sugerencias y comentarios que nos puedan hacer para mejorar la funcionalidad y le vista de este proyecto, ya sea con sus ideas o con su participación directa en el proyecto.

Muchas gracias por visitar grails.org.mx

Y que disfruten su estancia aquí...

Como este es un portal enfocado a ser lo más practico posible, también como parte del sitio, se cuenta con la inclusión y el formate de código; lo único que tiene que hacer es presionar seleccionar crear un breve texto y añadirle el estilo preformateado, una vez hecho eso presionan el botón de HTML y dentro de las etiquetas <pre></pre> incluyen su código y agregan el estilo, por ejemplo: <pre class="brush:groovy"> y aqui el código groovy </pre>, adicionalmente soporta:

1. JavaScript
2. Css
3. Groovy
4. Java
5. Texto plano
6. SQL
7. XML

Y les quedaría algo como:

class Greet {
  def name
  Greet(who) { name = who[0].toUpperCase() +
                      who[1..-1] }
  def salute() { println "Hello $name!" }
}

g = new Greet('world')  // create object
g.salute()              // Output "Hello World!"

Saludos

neodevelop

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á.

El día de hoy empezo el GR8Conf, una serie de conferencias hechas en Copenhage, Dinamarca, serán dos dias intensos de Groovy pues todas las tecnologias estarán basadas en el poder de la G, este evento esta organizado por Javagruppen(un JUG Danés) y Spring Source(super apoyo!!!), en estos dos días estarán hablandod de obvio Groovy, Grails y Griffon :D

De manera muy breve enlisto las charlas:

18 de Mayo

1. Keynote & Introduction to GR8 Technologies — Søren Berg Glasius & Guillaume Laforge
2. Grid Computing for Real-Time Computational Finance: A Case Study with Groovy and Grails — Jonathan Felch (Crédit Suisse)
3. Groovy usage patterns — Dierk König
4. What's new in Groovy 1.6? — Guillaume Laforge
5. What's new in Grails 1.1? — Graeme Rocher
6. Designing your own Domain-Specific Languages — Guillaume Laforge
7. Groovy and Grails in Eclipse - Andrew Heisenberg
8. Optional: Tivoli event
9. Optional: Dinner @ Valhal

19 de Mayo

1. Building a Twitter clone in Grails — Graeme Rocher
2. The Grails Plug-in System: Plug into productivity — Graeme Rocher
3. Groovy and Grails using IntelliJ IDEA — Vaclav Pech
4. Creating a Griffon: rich client frontend to our Twitter clone — Jim Shingler
5. Industrial Strength Groovy — Paul King 

Todos los temas bastante interesantes por parte de los expectadores, ya que los mismo creadores y los directamente involucrados estarán hablando de ellos.

Además de eso a los asistentes se les darán algunos beneficios adicionales como licencias de IntelliJ por 60 días, podrán ganarse un curso por parte de SpringSource o bien que les hagan un descuento al tomar alguno, cupones de descuento para adquirir libros referidos a las tecnologías de las que se están hablando, una edidicón especial de la GroovyMag, todos los ejemplos en una USB, acceso a todas las conferencias en video en parleys.com, folletos informativos, y pues el gran chance de estar hablando directamente con los speakers.

Si quieren seguir un poco lo que esta sucediendo en este evento pueden seguir a springhispano en el twitter en http://twitter.com/springhispano y darse una idea de los temas tan atractivos que se están tocando en este momento.

Incluso pueden ver el blog de gr8conf en http://gr8conf.org/blog/list

Groovy persigue ser tan natural como sea posible para desarrolladores de Java, apunta la descripción del lenguaje Groovy en su sitio Web (http://groovy.codehaus.org/). Mencionan que prácticamente cualquier código escrito en Java podría definirse como código Groovy sin mayores sorpresas. Para quien aprende Groovy cuando no se tiene experiencia en Java este es sólo un artículo exótico, pero para quien comienza con Groovy y tiene experiencia con Java, las particularidades en diseño resaltarán más temprano que tarde. ¿Pero cuáles son las diferencias? Este artículo intenta listar las mayores diferencias entre Groovy y Java. Si los apreciables lectores conocen alguna otra que merezca atención y no se incluya, sírvase resaltarlo y seguir haciendo comunidad.

1. ==

En Java == con tipos primitivos significa usar igualdad, mientras que para tipos object significa comprobar identidad. Empero, en Groovy == siempre significa igual, es decir, el uso que la mayoría de los desarrolladores utiliza. En Groovy == aplica igualdad tanto para tipos primitivos como para tipos object y a lo largo de tipado estático y dinámico para simplificar las cosas.

Como ejemplo, si al trabajar con Java se quisiera mantener la semántica de igualdad para objetos, por ejemplo, haciendo tipado dinámico de la siguiente manera:

def x = 2 x 2
if (x == 4) {
...
}

Se obtendrían resultados inesperados, pues aunque se quisiera resolver una igualdad basada en el valor, Java lo resolvería por identidad. Es cierto, rara vez se usan comparaciones de identidad.

Si en Groovy se quisiera comparar identidades de los objetos, el método is() se proporciona para cada objeto:

if (x.is(4)) {
... // nunca true
}

La condición de arriba nunca es true, ya que el objeto Integer en x (el cual es el resultado del cómputo de arriba), no es idéntico al objeto Integer con el valor 4 que se ha creado para la comparación.

2. Para declarar un arreglo no se puede escribir

int[] a = {1,2,3};

sino

int[] a = [1,2,3]

3. Si en Java solía escribir un loop similar a este:

for (int i=0; i < len; i++) {...}

en Groovy también puede usarlo, pero sólo se podrá usar una variable contadora. Alternativas a esto pueden ser:

for (i in 0..len-1) {...}

,

for (i in 0..

o

len.times {...}

4. in es una palabra reservada. No la use como nombre de variable.

Tenga en cuenta que:

1. Los punto y coma son opcionales. Úselos si le agrada (aunque debe usarlos para poner varias sentencias en una línea).
2. La palabra clave return es opcional.
3. Puede usar la palabra clave this dentro de métodos estáticos (lo cual refiere a esta clase).
4. Protected en Groovy tiene el mismo significado de protegido que en Java, p. ej., puede tener amigos en el mismo paquete y las clases derivadas pueden ver también a los miembros protegidos.
5. Las clases interiroes no se soportan hasta ahora. En la mayoría de los casos puede usar clausuras (closures) en su lugar.
6. La cláusula throws en una firma de método no se comprueba por el compilador de Groovy, pues no hay diferencia entre excepciones comprobadas y no comprobadas.
7. No se obtendrán errores de compilación como se obtendrían en Java al usar miembros indefinidos o pasar argumentos de tipo incorrecto. De existir errores en el código se lanzarán excepciones en tiempo de ejecución, debido a la naturaleza dinámica de Groovy.

Características contra-intuitivas no tan comunes

Los programadores de Java están acostumbrados a usar punto y coma para terminar sentencias y a no tener clausuras (closures). También hay inicializadores de instancia en definiciones de clase. Así que podría ver algo como esto:

class Prueba {
  private final Algo algo = new Algo ( ) ;
  { algo.hazAlgunaCosa ( ) ; }
}

Muchos programadores de Groovy evitan el uso del punto y coma pues es distractor y redundante (aunque otros lo utilizan todo el tiempo - es cuestión de estilo de código). Una situación que puede acarrear dificultades es escribir lo de arriba en Groovy así:

class Prueba {
  private final Algo algo = new Algo ( )
  { algo.hazAlgunaCosa ( ) }
}

¡Esto lanzará un MissingMethodException!

El problema aquí es que en este ejemplo la nueva línea no es un terminador de sentencia, así que el siguiente bloque se trata como una clausura, la cual se pasa como un argumento al constructor Algo. Extrañísimo para muchos, pero cierto. Si desea usar inicializadores de instancia de esta manera, es preciso tener un punto y coma:

class Prueba {
  private final Algo algo = new Algo ( ) ;
  { algo.hazAlgunaCosa ( ) }
}

De esta manera el siguiente bloque a la definición inicializada es claramente un inicializador de instancia.

El día de hoy he visto a través del twitter que las ponencias del GR8Conf ya están disponibles para poder descargarlas y verlas...

Yo me he puesto a ver una que me llamo mucho la atención acerca de Griffon por Jim Shingler, en la cual explica la analogía existente en el modelo MVC entre Grails y Griffon, incluso hay código de descarga...

Ya se anuncia uno de los libros que respecta al tema: Griffon in Action en el cual Danno Ferrin(http://shemnon.com/speling/), Andres Almiray(http://jroller.com/aalmiray/) y James Williams(http://jameswilliams.be/blog/entry/index) están trabajando intensamente, un libro que en lo personal estoy esperando...

Aquí la liga de las presentaciones:

http://www.slideshare.net/gr8conf/presentations

Aquí la liga del código de Jim Shingler para descargarse los Demo's de su presentación:

http://github.com/jshingler/gr8conf_2009/tree/master

Y aquí pongo un par de presentaciones de las que pueden encontrar:

Como continuación a la entrada anterior, revisaremos algunos editores de código y texto con características adicionales, prestas a ayudar a los programadores en su ágil desarrollo. Se extiende la invitación para incluir el editor de código que Usted utilice y que no esté incluido aquí, para seguir conociendo opciones. La característica considerada "necesaria" por muchos es el resaltado de texto. Las características adicionales a ésta se enunciarán independientemente.

Encabezando la lista está gedit, el editor de texto altamente personalizable para el escritorio de GNOME. Para la distribución de GNU/Linux de su elección, muy probablemente está disponible entre los repositorios predeterminados (en muchos GNOME es el entorno de escritorio predeterminado) o bien, con soporte de parte de sus comunidades. Lo mismo ocurre para el *BSD de su preferencia. ¿También MacOS? ¡Sí! También para MacOS X. El proyecto de Darwinports en http://darwinports.com/ incluye a gedit. ¿Y para Windows? GNOME Live! proporciona tutoriales, paso a paso, para compilar gedit en Windows, disponible en http://live.gnome.org/Gedit/Windows.

Entre los paquetes para personalizar gedit para Groovy/Grails/Griffon se encuentran: gedit-grails-bundle (http://github.com/aeischeid/gedit-grails-bundle/tree/master), con archivos para el resaltado y de inserción de tags rápidos junto con un script para instalarlo; gmate (http://github.com/lexrupy/gmate/tree/master), con un muy útil paquete de agregados para permitir a gedit comportarse como textmate en geenral (y ahora incluye la mayoría de las características de gedit-grails-bundle); Word Completion (http://users.tkk.fi/~otsaloma/gedit/), con ventanas emergentes de completado, actualización mientras se escribe, con sugerencias de todas las palabras en todos los documentos en todas las ventanas. Seleccione con teclas de flecha y completarlos con la tecla tabulador (sin interferir con snippets).

Sólo hay que desempacar los archivos en ~/.gnome2/gedit/plugins y, en el caso de archivos XML, los archivos .lang se ubican en /usr/share/gtksourceview-2.0/language-specs/ y los archivos -mime.xml en /usr/share/mime/packages/ debiendo, además, actualizar en este segundo caso al sistema mediante el comando "update-mime-database /usr/share/mime" (sin comillas). Por cierto, al ser achivos xml, el resaltado de de sintaxis puede aplicar a otros editores de texto, por ejemplo, Gobby para GNU/Linux (http://gobby.0x539.de/trac/), entre otros.

Una vez actualizados, sólo hay que habilitarlos en Edición > Preferencias y en Edición > Preferencias > Plugins. En GNOME Live! existen muchos agregados disponibles. En su página http://live.gnome.org/Gedit/Plugins hay muchos otros agregados, y en gedit-themes (http://github.com/felipemesquita/gedit-themes/tree/master) esquemas de color adicionales. ¡Esto es personalización!

¿Y qué hay para KDE? Ah, el Editor de Texto Avanzado para KDE (Kate por sus siglas en inglés), tiene un plugin desarrollado por g2one y disponible en su página (http://docs.codehaus.org/download/attachments/2747/groovy.xml) y completamente compatible para Kedit en KDE4. Para inslatarlo para el sistema, basta con colocarlo en /usr/share/apps/katepart/syntax o, de requerirlo sólo para su usuario, en ~/.kde4/share/apps/katepart/syntax. Fue elaborado en Arch Linux. Debería correr en CRUX, pero para otras distros debería verificar sobre las rutas de archivo.

jEdit (http://www.jedit.org/), es un editor de texto y código maduro con cientos de agregados de desarrollo. Está escrito en Java. Para instalarlo, tan rápido como instalar un runtime de Java, descargar de http://www.jedit.org/index.php?page=download y los plugins que desee de la central de agregados de jEdit en http://plugins.jedit.org/ (no se coloca enlace directo abra que aprecien cuántos agregados posee); desempaquetar o instalar el paquete seleccionado y listo. ¡Maravillas de las aplicaciones Java!.

Para MacOS existe el comercial textmate. Los agregados o bundles se ofrecen por separado. El bundle para Groovy está en http://macromates.com/svn/Bundles/trunk/Bundles/Groovy.tmbundle/ y el de Grails está en http://macromates.com/svn/Bundles/trunk/Bundles/Groovy%20Grails.tmbundle/. Para instalarlos, deben copiarse en /ruta/a/TextMate.app/Contents/SharedSupport/Bundles o mediante el menú Window, bajo el bundle editor. Para activarlos, seleccione Bundles > Bundle editor > Show bundle editor. En esta ventana puede habilitar atajos de teclado, editar y ajustar a sus necesidades.

Vim tiene soporte para Groovy. Desde la versión 6 está disponible predeterminadamente el soporte para Groovy y Grails. En el sitio Web de vim está el desarrollo del script, para el caso que no pueda actualizar su versión de vim (por dependencias) en http://www.vim.org/scripts/script.php?script_id=945 para aquellos que se sienten reales programadores, con programas reales.

Continúa en comentarios...

Para (X)Emacs (no discutamos) existen dos alternativas de plugin para groovy. A partir del modo-ruby (http://groovy.codehaus.org/Emacs+Plugin o basado en el modo-CC (http://groovy.codehaus.org/Emacs+Plugin), recordando que son mutuamente excluyentes. Asimismo, puede habilitar un modo-Groovy descargando el archivo http://svn.groovy.codehaus.org/browse/~raw,r=HEAD/groovy/trunk/groovy/ide/emacs/inf-groovy.el y colocándola en la ruta de carga predeterminada de Emacs. Enseguida, agregue las siguientes líneas a su archivo ~/.emacs:

;;; turn on syntax hilighting
(global-font-lock-mode 1)

;;; use groovy-mode when file ends in .groovy or has #!/bin/groovy at start
(autoload 'groovy-mode "groovy-mode" "Groovy editing mode." t)
(add-to-list 'auto-mode-alist '("\.groovy$" . groovy-mode))
(add-to-list 'interpreter-mode-alist '("groovy" . groovy-mode))

Para MacOS X, XCode de Apple dispone soporte incluido para groovy disponible en http://www.vengefulcow.com/groovy/groovy-xcode.zip. En el sitio http://www.vengefulcow.com/groovy/ se incluye información para SubEthaEdit (tanto 1.x en http://kasparov.skife.org/groovy.plist como para la 2.x en http://www.vengefulcow.com/groovy/.

Crimson Editor (http://www.crimsoneditor.com/), el freeware opensource padre del editor Emerald proporciona, además de sus huellitas de can, agilidad y ligereza, tiene un agregado desarrollado por G2one para groovy en http://docs.codehaus.org/download/attachments/2747/crimson_groovy.zip. ¿Por qué vale la pena? Porque es ligerísimo, y requiere Windows 95 o NT 4 para correr. Su fiel descendiente, Emerald Editor continúa su batuta, extendiéndose para usarse en Windows-GNU/Linux-*BSD-MacOSX (lo pongo aparte porque hay software *BSD no tan compatible con MacOS X). El sitio del sucesor es http://www.emeraldeditor.com/.

Enseguida, el GNU enscript (http://www.codento.com/people/mtr/genscript/) posee un archivo de estado desarrollado por G2one en http://docs.codehaus.org/download/attachments/2747/groovy.st?version=1. Necesita instalarse junto a los demás archivos state, por ejemplo, SUSE Linux los coloca en /usr/share/enscript/hl (verifique con su gestor de paquetes la ruta que su distribución asigna para este programa).

Finalmente, para los fans de wxWidgets, Editra (http://editra.org/), realizado utilizando Python 2.5 y wxPython 2.8.3, tiene soporte para groovy desde la versión 0.4.83. Es multiplataforma (no está de más recalcarlo).

Continúa en los comentarios...

SynergyJ.com la empresa detrás de los portales de SpringHispano.org y Grails.org.mx están complacidos de invitar a desarrolladores interesados a que participen en los cursos que estarán impartiendo a partir del 29 de Agosto, los cursos son:

Desarrollo Profesional con Springframework 2.5

Desarrollando Agil con Groovy & Grails

Desarrollo Profesional con EJB3

Persistencia en Java con Hibernate

La información la pueden encontrar en cada liga respectivamente, así como los costos y la información de contacto...

Quedamos a sus apreciables órdenes...

ATTE

Staff de SynergyJ

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

La agenda del día es la siguiente:

1. "Patrones de Integración Empresariales con Apache Camel" por Domingo Suarez Torres (@domix) En esta charla se presentara una introducción a los Patrones de Integración Empresariales, y a Apache Camel
2. "Introducción a Griffon" por Andres Almiray (@aalmiray) Charla en la cual hablara de como desarrolar aplicaciones con el lenguaje Groovy y el framework de desarrollo para Swing, Griffon.

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 pagina de registro es: http://www.coetus.info/coetus/events/detail/12

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), Andrés Valdez(@avaldini) y Rodolfo Velasco (@rvelascor), 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...

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

El equipo de @grailsmx y @springhispano estuvimos en uno(si no que el mejor del año) de los eventos de tecnología que reune muchas de las actividades y presentaciones que todo desarrollador le gustaría apreciar: el 1er. Campus Party México...

Este evento de tecnología nos dejo una experiencia muy agradable pues tuvimos la oportunidad de ponerle rostro a los usuarios de twitter, así como, a los miembros de la comunidad, también, pudimos conocer a más desarrolladores...

En este evento tuvimos participación en una breve ponencia denominada: Introducción a Grails, en donde el interes de los desarrolladores fue muy favorable, inclusive se organizo un pequeño camp al final de la presentación en donde entramos un poquito más a profundidad con características que no se vieron durante la hora anterior...

Queremos agradecer a #cpartymx por habernos invitado, a @domix una felicitación por el excelente manejo de los contenidos en el área de innovación, a los campuseros que se acercaron a nosotros, y a todos los que nos atendieron amablamente...

En seguida dejamos algunas ligas de fotos y contenido para que le hechen un vistazo y tambien la presentación de la ponencia...

Fotos en flickr: http://flickr.com/campuspartymexico

Twitter: http://twitter.com/campuspartymx

La presentación de "Introducción a Grails"...

Y aqui el video en youtube.com:

De antemano muchas gracias a todos...

ATTE

neodevelop

José Juan Reyes (@neodevelop) y Domingo Suárez Torres (@domix) una vez mas entregan otra edición del podcast de grails.org.mx

En este episodio hablamos sobre uno de los usos de la metaprogramación que Groovy hace en las clases de las librerias estandar de Java, nos referimos al GDK, especificamente hablamos en esta ocasión del GSQL, les dejamos un ejemplo listo para ser ejecutado:

//Esta anotacion nos sirve para indicarle a Groovy
//que use la libreria de Hsqldb
@Grab(group='org.hsqldb', module='hsqldb', version='1.8.0.10')
class Conexion {
	def sql
	public Conexion() {
		/* Esto es un truco para que jale la anotacion @Grab en Groovy 1.6.x, 
		   en Groovy 1.7 deberia funcionar sin este truco */
		this.getClass().getClassLoader().getURLs().each {
			ClassLoader.getSystemClassLoader().addURL(it)
		}
		
		/* Creamos nuestra conexion a la base de datos, los parametros enviados son:
		   url, username, password, y driverClassName */
		sql = groovy.sql.Sql.newInstance('jdbc:hsqldb:file:ejemploDB', 'sa', '', 'org.hsqldb.jdbcDriver')
	}
	

	def creaEstructura() {
		// delete table if previously created
		try {
		   sql.execute("drop table PERSON")
		} catch(Exception e){}
		
		// create table
		sql.execute('''create table PERSON (
		    id integer not null primary key,
		    firstname varchar(20),
		    lastname varchar(20),
		    location_id integer,
		    location_name varchar(30)
		)''')
		sql.commit()
	}
	
	def agregaRegistros() {
		// now let's populate the table
		def people = sql.dataSet("PERSON")
		people.add( firstname:"James", lastname:"Strachan", id:1, location_id:10, location_name:'London' )
		people.add( firstname:"Bob", lastname:"Mcwhirter", id:2, location_id:20, location_name:'Atlanta' )
		people.add( firstname:"Sam", lastname:"Pullara", id:3, location_id:30, location_name:'California' )
		sql.commit()
		def results = sql.firstRow("select firstname, lastname from PERSON where id=1").firstname
		def expected = "James"
		assert results == expected
		
		// do a query to confirm that our change actually worked
		results = sql.firstRow("select firstname, lastname from PERSON where id=1").firstname
		expected = "James"
		assert results == expected
	}
	
	def cierraConexion() {
		sql.close()
	}
}

def c = new Conexion()
c.creaEstructura()
c.agregaRegistros()
c.cierraConexion()

Los temas a detalle son:

Video de la charla de JJ sobre Grails en Campus Party

GDK

Imagen del flujo de ejecución de métodos de Groovy

GSQL

Critica de JDBC

Hablamos un poco de ORM

Soporte de JDBC con Groovy usando groovy.sql.Sql

Código en Groovy usando GSQL

Duración: 65 minutos

Tamaño: 33 MB

Lo pueden descargar directo desde aqui o suscribiendose al feed.

No quisimos quedarnos atrás de los tipos de SpringHispano y también nosotros empezamos con la serie de screencast.

En este primer episodio les mostramos una introducción a Groovy, es totalmente recomendable para los interesados y principiantes.

Pueden vernos en linea en Vimeo o suscribirse al Feed

Introducción a Groovy from Grails.org.mx on Vimeo.

 Acabamos de publicar el Episodio 1 de la Temporada 0 de grails.org.mx.

En este screencast vamos a ver como usar los diversos tipos de ciclos que podemos hacer en Groovy, asi como una introducción a las colecciones en Groovy usando Rangos, Listas y Mapas

Ciclos en Groovy y Colecciones from Grails.org.mx on Vimeo.

En este screencast vamos a ver como usar los diversos tipos de ciclos que podemos hacer en Groovy, asi como una introducción a las colecciones en Groovy usando Rangos, Listas y Mapas

De nueva cuenta hacemos otra entrega del unico podcast (hasta ahora) sobre Groovy en español. Gracias por escucharnos.

En esta ocasión hacemos el repaso de varias noticias y de algunos blogs muy interesantes.

• Groovy 1.7.0 and GMaven 1.2 Multi Module Projects
• February 2010 Groovy - Grails Job Market
• Griffon Front-End, Grails Back-End: Groovy End-to-End
• Dierk König interviewed: “The future of Groovy++ is within your Grasp”
• A One Day Griffon Application/Presentation
• La evolución del Código de Grails en video

Por si no pudieron asistir  en vivo al webinar sobre "Groovy y la productividad para el desarrollador Java", aqui les dejamos el video

Webimar: Groovy y la productividad para desarrolladores Java from Grails.org.mx on Vimeo. Las laminas estan disponibles aqui

hi!!!

This time, I wanna write about one book that I'm reading, this is 'Griffon in action' wrote by Andres Almiray and Danno Ferrin. This review describes chapters 1 and 2 ...

It's surprising how the book begins. The authors introduce us to the code immediately with the creation and running of a Griffon application: the trip of 1000 miles in one step begins...

BTW, it was awesome how the Griffon App take the natural look and feel in MacOSX, yeah!!! this mean the menu in the top of the screen and the body in the rest of the app with the aqua style...

The authors' singular style is something important to highlight 'cause it's funny, entertained and friendly. In addition to this, they explain of a very detailed way and step to step the development of the application.

I looked at the Griffon's MVC very similar to Grails in structure (they're cousins :P), however, how they communicate between them(in the MVC way) is different because they go in group. This means that the relation MVC in Griffon is  one view per controller and one domain in each group. In the other hand, Grails can use more than one domain class in controllers or views, In my opinion Grails have many very familiar concepts with Griffon

Also, the book covers the convention over configuration paradigm in a few and is applied in many parts of a Griffon App with specific folders and patterns in names of the components that we're developing...

The authors spent working with the @Bindable annotation, this is a point essential in this chapter because it's a very powerful tool that we allow to control the behavior of one component. This annotation is part of the AST transformations (I've worked with some ones like @Grab and without a doubt they're incredible)

This chapter explains some Groovy stuff with detail to the newbies, that's cool, Java developers can easily understand it and introduce themselves in the Groovy World :P(yeah! more groovy developers now in desktop)

It's important to mention that all of this finally is Java, so we have the support in the JVM and all the API's that nowadays we know and we can add them without problems, Java is a nice place to make desktop apps, but I remember when introduce myself in this kind of apps, well!!! It was a challenge to do some of them and add some behavior, paint the layout, and run it, oh my threads!!! "Somebody gives me another thread in my mind to think the UI and behavior at the same time" I thought...

The bad: In Java we have to deal with some issues like ceremony in the language, UI definition  complexity, app structure, life cycle, build management(a lot, if we're building desktop, applet's or to webstart)

The good: Griffon avoids those traps and my knowledge in Grails helps me a lot to understand in one look how it's structured all the Griffon App's

After, in the second chapter I learned about the ABC of Griffon, this is:

Application.groovy, Builder.groovy, BuildConfig.groovy and Config.groovy

Each one is very important because it defines how the app is showed, assembled and runned, with all of this, I saw in detail the Griffon's directory structure.  Also, in this chapter I can see where to put my source files, how to configure my app, how to add some external libraries and a lil' of testing, with all of this, I explored some of the commands that we have available to work.

Something that we have to deal (also) in Java is about to be careful with the life cycle of desktop app's (when init resources, when to release it, when it's ready to use them), well, with Griffon all of that is solved, in some section of this chapter explain in a better way how to organize and manage an app, since the creation until I stopped it.

I`ll continue reading the book `cause my next review will be about the next 4 chapters, dealing with MVC in depth and the MVC groups..