Flying with Griffon 2010 Style

Building a desktop application is a hard task, there are some many things to keep track of that many projects simply fail to meet their goals.

Setting up the project structure keeping each artifact on a well identified location given its responsibility and type, defining the base schema for managing the application's life cycle, making sure the build is properly setup, and more. These are recurring tasks that should be handled by a tool or better yet, a framework.

Griffon Plugin Development

The Griffon framework can be extended via plugins. Plugins can work their magic both at build time and runtime. Building a plugin is actually an easy task however there are a few things you should know to get the most out of the Griffon plugin system.

Extreme Scaffolding & User Interface Techniques in Grails

This talk will examine various techniques and solutions for extending the Grails UI in interesting ways. The underlying platform for Grails offers a powerful combination of great ideas, such as scaffolding, sitemesh templates, taglibs, templates, and other that get us nice and close to DRY goal. We will examine several plugins and techniques that take these ideas even further, resulting in yet another boost to productivity.

When GSP is not enough - using ZK RIA Framework with Grails

The ZK Framework is a RIA AJAX framework that encourages server side development to create Rich Internet Application. It abstracts AJAX calls for you and allows you to code all of your UI logic in Groovy or Java, without having to spend a lot of time worrying about generated HTML / CSS / JavaScript, and getting all those technologies to work together along with Grails backend. The ZKGrails integrates ZK with Grails, including automatic component binding with GORM.

Advanced GORM - Performance, Customization and Monitoring

You've used GORM in Grails apps, you've written custom criteria and HQL queries, and now you're ready to take database access in Grails to the next level.

Database Migrations in Grails

Hibernate's create-drop mode is great when you're prototyping your Grails applications but once you get past the initial stages of your project you'll need to manage database changes (adding, removing, and renaming tables, columns, and indexes, refactoring data, etc.)

Grails Spring Security Plugins

In this talk we'll look at the new Spring Security Core plugin and its dependent plugins. The core plugin provides all of the standard functionality you expect from a security plugin (URL security, users, roles, form-based authentication, etc.) and extension plugins add extra functionality such as OpenID support, LDAP authentication, object and method security with ACLs, and more.

DSL Evolution for Groovy Developers

Oh no, you're new Groovy DSL is actually popular. And of course, the feature requests keep come in. But what do you do to evolve your DSLs without breaking the existing models as your understanding of the domain changes radically over time?

TDD for DSLs in Groovy

In this session we'll build up a DSL in Groovy test first, showing a number of test strategies which can be used to develop various types of DSLs.

Grails Without SQL

Out of the box, Grails famously relies on Hibernate for database persistence through the agency of GORM, the Grails Object-Relational Mapping API. But are Grails apps permanently beholden to relational datastores, even when the relational model is not an appropriate solution for the problem at hand? No!

Seven Steps to Learning Grails

Grails is emerging as a standard JVM web framework in environments ranging from startups to the enterprise. It's a full-stack solution build on rock-solid components, fully relying on convention over configuration, and using the best application language the JVM has yet seen: Groovy. This is the place to be for web apps on the JVM.

In this introductory talk, we'll get a whirlwind introduction to Grails, visiting seven things you need to know about the framework to get started.

Compile Time and Runtime Metaprogramming With Groovy

The dynamic nature of Groovy makes it a fantastic language for building dynamic applications for the Java Platform. The metaprogramming capabilities offered by the language provide everything that an application development team needs to build systems that are far more capable than their all Java counterparts. Taking advantage of Groovy's metaprogramming capabilities brings great new possibilities that would be very difficult or just plain impossible to write with Java alone. Building Domain Specific Languages in Groovy is easy to do once a team has a good understanding of the Metaobject-Protocol (MOP) and the method dispatch mechanisms used by the Groovy runtime environment.

Extending Grails - The Plugin System

Grails is a super powerful framework for building applications for the Java platform. Grails addresses the pain points that the other web applications frameworks leave you with. This session covers the details you need to further extend Grails to help Grails help you in your environment.

GORM Inside And Out

GORM is a super powerful ORM tool that makes ORM simple by leveraging the flexibility and expressiveness of a dynamic language like Groovy. With GORM developers get access to all of the power and flexibility of an ORM tool like Hibernate without any of the complexity.

Prerequisite: Advanced Grails

Polyglot Web Programming With Grails

Grails is one of the most flexible and most powerful frameworks on The Java Platform. Grails leverages the flexibility offered by the platform in a way that other web frameworks do not. Grails is a fantastic platform for polglot web programming.

Prerequisite: Advanced Grails

Creating a Dynamic Portal using Grails

This session will describe hands-on procedure to use the Grails Portal project as a launching pad for quickly creating web applications. The first part of the session will be spent discussing the advantages that Grails gives to developing User Portals. The second part will have a detailed discussion and examples of integrating Apache Shiro security with Grails Web Flow and the reasoning behind selecting these plug-ins. The session will conclude with a discussion on how these features can be extended to create a fully dynamic portal with personalization and other popular plug-ins.

Integrating Grails with Daisy CMS

This session will describe the use of Daisy, an Open Source Content Management System (CMS) and the different options for integrating it with Grails.

Grails + CouchDB

"CouchDB is built of the Web. I’ve never seen software that so completely embraces the philosophies behind HTTP." Jacob Kaplan-Moss, Django Developer

If you want to get a room full of programmers all riled up, just casually drop the word, "NoSQL." To some, NoSQL means, "death to all antiquated, 1970s-era persistence solutions!" Others take a more pragmatic approach -- "Not Only SQL" means that while relational databases are suitable for some applications, there is an emerging crop of equally viable (and interesting) persistence strategies out there.

Apache CouchDB is a schema-free document store that uses HTTP GETs, PUTs, and DELETEs instead of SQL SELECTs, INSERTs, and DELETEs. It speaks JSON fluently instead of tables, columns, and rows. It uses JavaScript Map/Reduce functions instead of SQL for the query language. It offers effortless replication among distributed CouchDB instances.

Tomorrow's Tech Today: HTML 5 + Grails

As software engineers, we take comfort in the idea of concrete specifications. As web developers, our hearts are either broken (frequently!), or we recognize the W3C's role is a delicate balance of leading the browser developers in new and exciting directions while, in their own words, "paving over the cow paths" of existing, de facto standards.

HTML 5 offers dramatic new improvements for page organization, offering out-of-the-box support for elements like header, footer, nav, section, and article. HTML 5 adds native support for form features such as placeholder text, autocomplete, autofocus, and validation. Additionally, there are a host of new form elements available (email, url, number, range, date, and search) that gracefully degrade in "classic" web browsers -- IE, I'm looking at you!

Beauty and the Beast: Software-Design for Builds and Build Systems

For our production code we apply a wealth of design values and principles. Currently this is rarely done for our builds. Yet the project automation domain, specially in the enterprise, is often at least as complex as the business domain.

The design of your build is heavily influenced and possibly constrained by the design of the build system you are using. The main focus of this talk is to evaluate those design forces of the build systems. Mostly with the help of two books: Refactoring by Martin Fowler and Domain Driven Design by Eric Evans.

Gradle - A Better Way To Build

Gradle allows you to describe your build using a rich, easily extendable build language based on Groovy. It provides compelling solutions for many of the big pain points that exist with current build systems. This session will be mostly driven by live demos. You will see how easy and elegant Gradle enables you to solve a broad range of requirements - over the full life cycle of typical and atypical Java builds.

Gradle in the Enterprise

The project automation requirements of complex enterprise builds are the true stress test for any build system. Gradle has a special focus on enterprise builds. In this session we will talk about and demo on: Multi-project builds, incremental builds, parallel testing, dependency management and concluding with organizing build logic, custom plugins and custom tasks.

Prerequisite: Introduction to Gradle

Code Generation on the JVM: Writing Code that Writes Code

"The Pragmatic Programmer" admonished us all to "write code that writes code": use code generators to increase productivity and avoid duplication. Today's language communities have clearly caught on, as more and more frameworks generate code at compile time: AST Transforms, Project Lombok, Spring Roo, and more.

Slimmed Down Software: A Lean, Groovy Approach

The Groovy Programming Language advertises itself as an "agile and dynamic Language for the JVM", but what does this mean exactly? This session explains Lean Software Development, and shows how your choice of programming language can help your entire process remain nimble and adaptive.

Getting to know Git: How to give back to Grails

In this session we will spend some time getting to know some of the basics of Git and exploring successful tools and workflows. We will also learn how we can utilize git and git-svn to work with grails and many of ~500 plugins listed on grails.org. Finally we'll explore how to submit pull requests, format patches and contribute code back to original authors and the entire community.

Grails Layouts & Sitemesh

Grails brings a powerful set of tools to the view layer: GSP, Views, Templates, Tag Libraries, and Layouts. Grails' Layouts seem to be the most misunderstood and underutilized component of the view layer. In this talk, we'll do a deep dive on how Grails uses Sitemesh, explore integration/customization points as well as live-coding examples of how to use some of the lesser known tags to achieve a very flexible and intuitive approach to developing DRY applications with Grails.

Acceptance Testing with Groovy

An ideal way to make use of Groovy's great support for writing domain specific languages (DSLs) is when writing customer or acceptance tests. When using such an approach you typically use a high level English-like testing DSL to express the test. The approach is so popular that in fact numerous frameworks now exist for creating such tests.

Concurrency with GPars

This talk looks at writing concurrent Groovy programs using GPars. GPars is a comprehensive library for parallel execution that provides a menu of options to the developer.

Groovy and Concurrency

This talk looks at using Groovy for multi-threaded, concurrent and grid computing. It covers everything from using processes, multiple threads, the concurrency libraries ear-marked for Java 7, functional programming, actors including a brief glimpse of GPars, as well as map/reduce, grid and cloud computing frameworks.

Groovy.DSLs(from: beginner, to: expert) 2011 Edition

This talk examines how dynamic languages in general and Groovy in particular take us toward the goal of writing programs for a particular domain using phrases that look familiar to subject matter experts from that domain. Groovy, is a popular and successful dynamic language for the JVM. It offers many features that allow you to create embedded Domain Specific Languages(DSLs) including Closures, compile-time and run-time metaprogramming, command chain expressions, operator overloading, named arguments and other concise syntax conventions.

Grails Integration Strategies

It's amazing how quickly one can build web applications with Grails in a greenfield environment, but most of us do not have that luxury. We have existing infrastructure and applications that we have to maintain and extend. We have legacy databases (or legacy database administrators) to deal with. Does this mean we cannot benefit from the magic of Grails? No way! The ease of use and productivity of Grails is matched by its power and flexibility. In this session we will discuss some of the ways that Grails can be integrated with the enterprise; EJB/JSF applications, Spring/Hibernate, legacy databases, and even non-Java applications.

Grails: Bringing Radical Productivity to the JVM Part I

The goal of this hands-on tutorial is to get started and get productive with Grails. We’ll do this by jumping right in and building an application, from design to deployment.

Grails: Bringing Radical Productivity to the JVM Part II

In Part II of this session, we will continue the build out process with the Grails application.

Groovy Web Services, Part I: REST

Groovy has excellent networking capabilities and is great at processing XML, which makes it a natural for working with RESTful web services.

Groovy Web Services, Part II: SOAP and JAX-WS

Although RESTful web services have gotten better press, SOAP-based web services are often the backbone of many large enterprises. The user-friendly advances in JAX-WS 2.* make developing such services much easier. As with most Java topics, Groovy simplifies the development of web services as well. Since it is particularly well-suited to XML processing, Groovy is quite helpful in the web services and SOA worlds.

Gaelyk, a lightweight Groovy toolkit for Google App Engine

Guillaume will present Gaelyk, a lightweight Groovy toolkit for easily developing Groovy applications to be deployed on Google App Engine Java. We'll learn more about what the toolkit provides, how to leverage it for your own needs through some demos.

Groovy update: to infinity and beyond!

In "Groovy update, to infinity and beyond!", Guillaume Laforge will come back on Groovy's past, present and future. First, we'll do a quick review of Groovy 1.6 features: multiple assignment and option return in if/else and try/catch blocks, AST transformations with @Delegate, @Lazy, @Immutable, @Mixin and friends, the Grape dependency module, metaprogramming enhancements, JSR-223, JMX and OSGi support built-in. Then we'll dive into Groovy 1.7, especially how to simplify the creation of AST transformations, the small incremental improvements to the Groovy GDK, how to "customize the truth", power asserts, and more.

Grails + messaging with AMQP/RabbitMQ

Messaging in the Java world is dominated by JMS and its providers. But is it the best model for your needs? And what if you want to work with non-Java consumers or publishers?

Plugin-oriented architecture for large-scale Grails development

It's easy for a Grails application to grow to an unmanageable size as more and more features are added. Fortunately, Grails comes with a built-in mechanism for separating an application into different concerns: plugins!

Tuning Grails applications

Grails makes it incredibly easy to get a web application up and running, but it makes no guarantees about how well that application will perform and scale. If you issue hundreds of database queries per request, your application won't be a Speedy Gonzalez.

Functional Web Testing with Geb and Spock

Geb is a next generation Functional Web Testing tool that removes the ceremony and tedium of traditional web testing, leaving you with a concise, pragmatic and productive environment in which to work. It combines the power of Groovy with the WebDriver/Selenium 2.0 browser automation library to provide a programmer's DSL for modeling pages (known as the PageObject Pattern) and easily automating real browsers such as Internet Explorer, FireFox and Chrome as well as the HTMLUnit library. Geb can be used standalone, or with testing frameworks such as Spock, JUnit, EasyB or Cucumber.

Smarter Testing with Spock

Spock is a developer testing framework for Java and Groovy applications. Even though it is fully JUnit-compatible on the outside, Spock isn't just another JUnit clone - its goal is to take developer testing to the next level! With its Groovy-powered and highly expressive testing language, Spock boosts productivity and brings back the fun to testing.

Grails 1.3 Update

Grails provides a dynamic and agile development framework for web applications that is based on the most stable and productive open source libraries, including the Spring framework.

Grails Sans SQL

Grails provides solid and mature support for SQL databases, but what about the upcoming range of NoSQL data stores? I

Groovy + The Semantic Web

The Semantic Web is Tim Berners-Lee's full vision of what the Web can and will be. This HTML stuff we are all so enamored with is just the tip of the iceberg. "Web 2.0" is a kindergarten plaything (and a stupid name). Webs of linked data will allow us unprecedented flexibility in how we produce and consume information. While many people have been waiting on the sideline for the Semantic Web to get here, others have been making it happen.

Metaprogramming the Microkernel: Groovy + NetKernel

Most organizations have a pretty conservative attitude toward adopting technology. If you are allowed to use a language like Groovy, chances are it is still going to be deployed in a conventional container like Tomcat or some other J2EE infrastructure.

What would happen if you took the power of a language like Groovy and married it to a next-generation environment like NetKernel? Imagine combining the power of Groovy metaprogramming with a microkernel-based resource-oriented environment. Expressive, powerful, scalable. It's pretty much guaranteed to rip a hole in the space time continuum. Come watch it happen.

You will be amazed at how much can be accomplished with so little code (not to mention how well it will perform).

Building SOFEA's with Grails and YUI

The Service-Oriented Front-End Architecture (SOFEA) was first described in an article posted to The Server Side in late 2007. In that article, Ganesh Prasad, Rajat Taneja and Vikrant Todankar introduced a new architectural style for building web applications. Since that time numerous frameworks have begun to facilitate building applications in this style. This talk will focus on the combination of Grails and the Yahoo! User Interface Library for building SOFEA applications.

Functional Programming in Groovy

Functional programming style is gaining popularity. Though Groovy is not a functional programming language, writing in functional style is common and idiomatic in Groovy. While you have used these features in Groovy, learning the tents of functional programming will help you recognized these and make better use of them in the future.

Improving your Groovy Code Quality

Groovy is concise and expressive. However, writing good quality code takes effort and discipline.

Transforming to Groovy

Groovy is a elegant, dynamic, agile, OO language. I like to program in Groovy because it is fun and the code is concise and highly expressive. Writing code in a language is hardly about using its syntax, however. It is about using the right idioms. Come to this section to pick up some nice Groovy idioms.

Prerequisite: Some knowledge of Groovy is helpful but not required.

Unit and Functional Testing using Groovy

The concise, expressive syntax of Groovy and the ability to create internal DSLs make Groovy a great language for testing related tools. I

Griffon for the Enterprise

Java Swing has for a long had a bad reputation of being slow, unwieldy, and a difficult platform to develop on. Griffon, a rapid application development framework using Groovy, brings that pain to an end by leveraging the best paradigms of web development on the desktop.