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

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

Nacho Brito ha publicado un libro sobre Grails en español. El libro aun no esta a la venta, saldra a la venta el proximo 28 de mayo.

Este libro realmente promete, el contenido es muy bueno y conocemos la calidad que Nacho imprime en sus proyectos. Cabe mencionar que el libro tiene licencia Creative Commons 3.0

Pueden acceder a este libro en su sitio web oficial aqui.

En horabuena por Nacho, estas iniciativas en nuestro idioma hacen falta...

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:

El desarrollo en Grails no necesita más que un editor de texto, pero hay herramientas más sofisticadas para incrementar la productividad. Características como el resaltado de sintaxis, la ejecución de comandos propios, entre otros, los hacen buenas alternativas. Y como en gustos se rompen géneros, hay para todos. Hablaremos de algunos IDEs que soportan integración con Grails, en mayor o menor medida. Si el que Usted utiliza no está en esta lista, sírvase comentarlo para incluirlo.

Comienza esta lista el preferido por muchos, el comercial y robusto IntelliJ IDEA IDE. Tras instalar Groovy y Grails, descargue e instale IntelliJ IDEA desde http://www.jetbrains.com/idea/download/. Estando instalado, en el cuadro de diálogo Settings en IntelliJ IDEA, descargue e instale el plug-in JetGroovy y configúrelo seleccionando las rutas a Groovy y a Grails. Opcionalmente puede descargar e instalar InspectorGroovy, un plug-in con inspecciones de código específico de Groovy.

Una vez realizado esto, en el cuadro de diálogo "New Project" (nuevo proyecto) aparece el tipo "Grails Application" (aplicación Grails). Con ello se comienza un projecto Grails como cualquier otro en IntelliJ IDEA. Especificando el nombre y lugar, se genera la estructura. Y si acaso se necesitara, tiene resaltado de sintaxis para afinar cualquier detalle, y con la asistencia de código para objetos Grails, la vida es más sencilla. En la vista de projecto (Project View) se pueden generar clases y editar archivos gsp generados, pudiéndose usar clases y bibliotecas definidas en un plugin de Grails.

El siguiente en la lista, NetBeans IDE. Desde la versión 6.5, tiene soporte nativo para Groovy y Grails. Sólo hay que descargar e instalarlo. Una vez instalado, en la ventana Options (opciones), bajo Miscellaneous (diversos) seleccione la ruta de Grails en el panel "Groovy". Si se usa MacOS X, Miscellaneous se encuentra bajo "NetBeans Preferences".

Para crear la aplicación:

1. Seleccione el proyecto con el Asistente de Nuevo Proyecto, dele nombre y localización. Se generarán los archivos necesarios y se completarán valores predeterminados.

2. Cree la clase de dominio, dando clic derecho al nodo "Domain classes". Nombre la clase de dominio "Book" (Book.groovy) y llene dos stings, "title" y "author".

class Book {
	String title
	String author
}

y cree valores iniciales en la clase Bootstrap.groovy:

class BootStrap {
	def init = { servletContext ->
		//Aquí se crea la información de prueba
		new Book(author:"Domingo Suárez",title:"SpringHispano in Action").save()
		new Book(author:"José Juan Reyes",title:"Grails.org.mx in Action").save()
		}
		def destroy = {
		}
	}

3. Cree el controller. Dé clic derecho al nodo Controllers. Escriba "Book" y vea que se generará la clase "BookControler". Comente con diagonales la línea autogenerada y agregue "def scaffold = Book", para que luzca aquél BookController.groovy algo así:

class BookController {
	//def index = { }
	def scaffold = Book

4. Por último, dé clic derecho a la aplicación y seleccione "Run". La aplicación se despliega a jetty, como se puede apreciar en la ventana Services. De allí, hasta el infinito.

La integración de Eclipse IDE con Grails está en proceso. Se puede, hasta cierto punto, trabajar con un grado mediano de comodidad en él. Empero, no debería ser la elección en un ambiente de producción. Si tiene paciencia para los pequeños (pero en momentos engorrosos) detalles (o bugs) del proyecto, puede ir observando su progreso, que poco a poco está completando su desarrollo. Las siguientes observaciones son precisamente por este carácter de "en desarrollo":

La primera consideración con Eclipse es que se sabe que no correrá apropiadamente si se intenta usar el directorio raíz de su unidad de almacenamiento para su proyecto, o rutas con espacios.

Se necesita enunciar la variable GRAILS_HOME, además de en el ambiente estándar, en Eclipse. Dentro de Windows > Preferences... > Java > Build path > Classpath Variables > New introduzca dicha variable.

Al crear un nuevo proyecto, Eclipse creará los archivos necesarios. Si el proyecto Grails que esté trabajando tiene plugins instalados, necesita agregarlos a los directorios directamente dentro del folder plugins/src/ de su ruta de fuentes de Eclipse. Esto se realiza dando clic derecho al folder "Groovy" o "Java" y seleccionando build path > source. De lo contrario, se objetndrán errores en los enunciados de importación.

Si se están usando JSPs necesiará agregar la biblioteca tools.jar de su JDK al classpath del proyecto o jetty desplegará errores de compilación.

Si se está usando el plugin Groovy de Eclipse asegúrese de habilitar la preferencia "Disable Groovy Compiler Generating Class Files" (en Project > Preferences > Groovy Project Preferences, o si usa una versión muy anterior, en Windows > Preferences > Groovy Preferences). Predeterminadamente esta opción está deshabilitada y genera archivos de clase para sus archivos groovy, almacenándolos en el basedir del proyecto Grails. Cuando se generan estos archivos, hay comportameinto inesperado como no poder generar controladores y vistas para sus clases de dominio. Empero, si va a usar el Step Debugging de Eclipse, asegúrese de desabilitar esta preferencia.

Si presenta todavía problemas, muy probablemente esté faltando una biblioteca. Asegúrese que todas se agreguen al build path del proyecto.

Y ya encarrerados con IDEs que tienen soporte parcial para Groovy y Grails, Geany (http://www.geany.org/) tiene soporte para Groovy desde la versión 0.17 y no requiere mayor configuración. No obstante, por ahora sólo soporta completar código para las clases locales, lo cual no es muy útil. Esto se está actualizando, pero yo no esperaría la solución muy pronto.

En la siguiente entrada se mencionarán los editores de texto con características adicionales.

A manera de comentario. Tengo entendido que tanto KDevelop como Anjuta están desarrollando soporte para Groovy y Grails, pero en ningún lado encuentro en qué estado se encuentran. ¿Alguien sabe algo al respecto?

Actualización 2 julio '09. Me habían señalado, y se me olvidó mencionar, para quienes trabajan "en la nube" a Aptana Cloud. Tiene soporte para Java, Groovy y Rails, además de PHP, Rails, Jaxer y próximamente Python. Bastante amigable, y con posibilidades de cuentas sin tener que pagar mensualidad alguna. Conozco gente quien piensa que la nube es lo de hoy. Sólo menciono la alternativa.

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

No cabe duda que los chicos de SpringSource se están aplicando al mejorar de manera tan rápida y efectiva este framework, ya considerado plataforma, apenas a principios de año teniamos la versión 1.1 esperandola con ansias y en el libro de The Definitive Guide to Grails mencionaba en un pequeño apartado que para dicha publicación ya iba a estar en puerta la versión 1.1.1; estamos a mediados de año y ya estamos en el M2 de este framework basado en Groovy, Spring, Hibernate y otros de los mejores productos open source para desarrollo Java. Y precisamente hablando de esto quiero mencionar las mejoras que vienen con esta nueva versión, basado en la publicación de las notas de liberación: http://www.grails.org/1.2-M2+Release+Notes

De las mejoras y características más sobresalientes en mi opinión es que ahora esta versión ya viene basada en Spring 3, el cual, viene también con nuevas características que no podemos pasar desapercibidas, para el caso muy especifico de esta version de Grails rescatamos la posibilidad de usar las anotaciones de Spring como son: @Service, @Component, etc. Cualquier clase puede ser anotada como @Component y ser inyectada en cualquier otra...

Incluso podemos anotar con @Controller y mapear a nivel de método con @RequestMapping como si lon hicieramos en Spring directo.

Ahora podemos reescribir cualquier URI en cualquier otra usando el archivo de UrlMappings de Grails por ejemplo: "/hello"(uri:"/hello.dispatch") , muy útil para recursos estaticos o simplemente tener una URI adornada...

Transacciones por método a través de @Transactional, construido de la misma forma en el escaneo de componentes, ahora podemos usarlo a nivel de método.

Mejoras en los finders dinámicos proveídos por el GORM en donde ya podemos incluir valores booleanos en las firmas de los métodos para buscar a través de ellos.

Además de soporte de query's nombrados a través de la declaración de un closure en la clase de dominio y la invocación de métodos estáticos en donde se requiera usarlos.

Soporte para la relación hasOne donde la llave foranea se encuentra en el hijo y no en el padre de la asociación

Errores de validación estrictos, hay un argumento nuevo en el método save de los objetos de dominio que permite arroja una excepcion si un error ocurre.

Precompilación de las GSP en el deployment de la WAR lo que permite usar menos espacio en memoria al momento de hacer deploys

Multiples contenedores embedidos soportados, ahora ya podemos escoger entre Jetty y Tomcat...Coolness no?

Mapeos de URL Nombradas y la asociación de tags dinámicos basados en dicha configuración hecha dentro del archivo UrlMappings en donde podremos usar tags generadas en base a la escritura de la relación existente entre las peticiones que escribamos y los controllers y action's que las atiendan...

Estas son algunas de las nuevas funcionalidades que encontraremos en esta nueva versión de Grails(faltan un par), les recomendamos que la prueben...

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

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

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

Este episodio es el podcast de amniversario, cumplimos un año hablando sobre Groovy & Grails, adovo¡.

En este episodio hablamos sobre metaprogramación, el elemento clavey fundamental para hacer de Groovy un lenguaje dinamico para poder crear DSLs (Domain Specific Languages). Les dejamos un ejmplo de como hacer metaprogramación muy sencillo:

def s = "hola mundo"
s.metaClass.metodoInexistente = {->
    println "hola"
}
println s.class.name
s.metodoInexistente()

Los temas a detalle son:

1. Agregado soporte de compresión y descomprensión con metaprogramación
2. Agentes concurrentes con Groovy
3. Nuevo DSL para administrar dependencias con Grails
4. Foros nuevos

Duración: 65 minutos

Tamaño: 30.9 MB

Lo pueden descargar directo desde aqui o suscribiendose al feed.

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.

Me encontre un proyecto maravilloso llamado Gource que extrae el historial de repositorios Git y Mercurial para ver gráficamente los cambios al repositorio. Lo use para producir el siguiente video:

Grails Code Evolution from Grails.org.mx on Vimeo.

This video shows the Grails codebase evolution since March 2006 to early february 2010, really awesome, the video was produced using Gource. The music is from 'Brad Sucks'

Genial no creen?

Los invitamos a asistir a la 13va. Reunión de la Comunidad SpringHispano.org y Grails.org.mx. que se llevara a cabo el 20 de Febrero de 2010 a las 10:00 am. en donde presentaremos.

Taller de desarrollo web con Grails 1.2.1, por Domingo Suarez Torres (@domix)

En donde veremos los fundamentos y principales artefactos que debemos comprender para desarrollar aplicaciones web con Grails usando Groovy y Java. Este taller será completamente practico y al termino del taller los asistentes tendrán los elementos necesarios para empezar a desarrollar aplicaciones con Grails.

Les recordamos que la entrada es totalmente gratuita, pero el cupo es limitado y el registro es necesario.

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. El registro se hace aquí.

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

ATTE

Staff de SH.org, grails.org.mx

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

Nuevamente hacemos entrega de otro episodio de este su podcast favorito (por ser hasta el único) sobre Groovy y Grails.

En esta ocasión solo hablamos de unas noticias y algunos blogs interesantes

• Java 3D Fun with Groovy
• The GPars Project - Reference Documentation
• Griffon Guide - Reference Documentation
• Grails - Grails 1.3.1 released
• Interview and Book Excerpt: Dave Klein's Grails A Quick-Start Guide
• Spring: the foundation for Grails
• What's a plugin-oriented architecture?

Duración: 35 minutos

Tamaño: 19 MB

Lo pueden descargar directo desde aqui o suscribiendose al feed.