2GX Schedule

By Guillaume LaForge

The latest major version of Groovy was released a few months ago, and it's time to have a closer look at what's inside!

This session will cover the improved Domain-Specific Language capabilities thanks to the command chain expressions. We'll move on to speak about the continued runtime performance improvement work to make Groovy the fastest dynamic language around. Then we'll see how more functional closures have become in this release, and we'll overview the built-in JSON support. And we'll review the most important AST transformations that have been added for removing even more boilerplate code from your code bases. And we'll finish with miscelanous coverage of improvements to the syntax, of improved and secured Groovy integration in your Java applications, and much more.

By Venkat Subramaniam

Java - Groovy integration just works, for most part. Calling into Java code from Groovy is pretty straight forward. Calling into Groovy from Java is easier than you may think (and that's the hard part!). There are a few rough edges you will run into when you try to call from Groovy into other languages.

In this presentation, we will take a look at integration mechanisms and how to work around the few challenges you may run into.

By Jeff Scott Brown

Grails represents technology that offers great flexibility and power without the complexity introduced by other Java web application frameworks.

Custom tag libraries are a snap. GSP Templates provide a simple mechanism for reusing UI elements. Sitemesh is integrated to help provide a consistent presentation across the entire application. GORM is super powerful ORM. Grails provides simple mechanisms for leveraging the power of Ajax.

By Graeme Rocher

In this session, Grails project lead Graeme Rocher will deliver an update on the latest and greats features of the Grails framework - a dynamic, web application framework based on the Groovy language and designed for Spring. Graeme will cover all the new features of Grails 2.3 including Async support, REST improvements, XSS escaping and forked execution

In this session, Grails project lead Graeme Rocher will deliver an update on the latest and greats features of the Grails framework - a dynamic, web application framework based on the Groovy language and designed for Spring. Graeme will cover all the new features of Grails 2.3 including Async support, REST improvements, XSS escaping and forked execution

By Guillaume LaForge and Paul King

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.

The talk highlights many of Groovy's DSL capabilities through numerous realistic examples. We'll give the example, explain the tricks used to implement the DSL, including any pros and cons as well as tackle the often forgotten but key aspects of readability vs complexity, testability, evolution, and the various considerations to keep in mind while designing DSLs.

By Peter Ledbrook

2011 is turning into a tremendously exciting year for Grails developers. One of the most important developments is the arrival of several new cloud hosting providers that work with Grails applications with minimal effort on your part. No longer do we have to look enviously at our Rails comrades who have Heroku et al.

The new batch of solutions are known as Platforms as a Service (PaaS), so this talk will first explain what this means before delving into the individual providers. You'll be able to compare what each provider offers and see how the Grails integration compares as well.

By Jeff Scott Brown

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 Meta Object Protocol (MOP) and the method dispatch mechanisms used by the Groovy runtime environment.

This session will cover in detail a number of advanced metaprogramming concepts in Groovy. The discussion will cover using dynamic method interception, custom meta-class implementations and Groovy's Meta Object Protocol to build flexible applications in Groovy including implementing a Domain Specific Language (DSL).

By Paul King

Groovy 1.9 includes a brand new modularisation feature which allows Groovy to be split into smaller pieces. This mechanism allows us to package up Groovy for different contexts (think enterprise servers, desktops, netbooks and phones) but also to evolve Groovy over time. It also allows module writers greater power in terms of being able to leverage many of the Groovy run-time and compile-time internal features.

This talk looks at these modularisation features including defining modules, module metadata, adding meta-programming features, integration hooks and more. We will also build our own "hello world" module from scratch.

By Burt Beckwith

In this talk we'll look at the 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.

We'll look at the various plugins and create some sample applications to see how easy it is to secure a Grails application with Spring Security.

By Venkat Subramaniam

Multi-core processors have increased the demand to get concurrency right. Thankfully, the options for programming concurrency on the JVM has evolved from the JDK synchronize and suffer model to Software Transactional Memory and actor based concurrency.

In this presentation, we'll learn the reasons to go beyond the traditional JDK solution and how to make use of these two models from Groovy.

By Jim Shingler

By now most everyone in web development has heard of Grails and the productivity gains though its use. But is it ready for a public facing Fortune 500 company website?

In this session we will explore the decision to use Grails, the approach and processes, and the results. We will discuss a variety of topics including:

• The deployment architecture
• Performance
• Caching and Load Balancing
• Statics
• Tools: TC Server, Insight, Hyperic, STS
• JVM settings

By Dave Klein

Grails object relational mapping (GORM) is one of the most powerful features of the Grails framework. Project bootstrapping and CRUD scaffolding are nice things to get you started, but GORM continues to pay off throughout the development of an application. Even maintenance tasks become simpler and more fun with GORM. Now, with Grails 2, GORM has become more powerful and easy to use than ever.

In this presentation we’ll discover what GORM is and what it does for us. We’ll cover dynamic domain class methods, dynamic finders, one-to-many and many-to-many relationships, Hibernate Criteria Builders, new Grails 2 Where Queries, and more. We’ll also take a look at some things to watch out for since, after all, this is Object Relational Mapping we’re talking about.

By Guillaume LaForge

Guillaume will speak about 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, demonstrating views and templates, URL route definitions, plugins, the many shortcuts to the App Engine APIs, the very readable Query DSL to query the datastore.

By Venkat Subramaniam

When I got into Java I had a "Wow, look how easy it is to implement these patterns." When I got into Groovy, I had the same reaction, but only better. The dynamic nature of Groovy makes it easier to implement some common patterns. What's better, there are some patterns that you can exploit in Groovy that are not so easy in Java. In this section, you will learn how to implement some traditional patters in Groovy, and also other patterns you are simply not used to in Java.

This presentation will go far beyond the Gang-of-four (GOF) patterns. You will learn how to implement some GOF patterns, but also some patterns that will allow you to exploit dynamic nature of Groovy and the elegance of Groovy closures.

By Graeme Rocher

In this session, Grails project lead Graeme Rocher, will demonstrate how you can deploy Grails applications into the Cloud and take advantage of a new age of polyglot persistence on the Grails platform.

Demonstrating persistence techniques on a variety of data stores, including Redis, MongoDB and an RDBMS, this talk will demonstrate how specific use cases can benefit from a polyglot approach to persistence allowing for scalable, Cloud-based Grails applications.

By Paul King

Over the years we have seen many debates about how best to write and maintain our programs. Should we use OO or functional? Should we use sequential or concurrent? Should we use static or dynamic typing? What design patterns should we use (or anti-patterns should we avoid)? What can we learn from the strengths and weaknesses of the many languages that are now available for us to program in?

In this talk, we give numerous examples which highlight the different ways to code and test our programs. It looks at the trade-offs that different typing and coding styles give you in terms of a number of features including: ease of reading and writing, tool support, ability to modify, ability to make concurrent, ability to test and a number of other criteria. The talk doesn't attempt to provide a single answer to what is the best one true way to code all programs but gives you many examples to ponder and many context-dependent guidelines for you to factor in to your choices.

By Glen Smith

Grails productivity can be a drug - and the productivity rush can lead to a whole lot of untested, unmaintainable code. If you're written one of these bad boys, or have just take over someone else's messy Grails app, you might not know where to get started in moving your codebase to something that you are actually happy to work with. We'll cover 10 painful but classic hacks/shortcuts in Controllers, Services, Views, Taglibs & Bootstraps and how to fix them!

This hands-on talk introduces you to all the built-in Grails Unit testing infrastructure using Spock - a great new framework for simple expressible tests while we refactor 10 common Grails hacks that need work. We will be covering off 10 classic Grails hacks that affect all the core artifacts in Grails applications. If you've been putting off testing your Grails app, or found it too onerous to make happen, this is the talk for you! It's a fully interactive session, so bring your experiences and your war stories.

By Shawn Hartsock

Your awesome application is getting such heavy use it's starting to slow down. Learn how to add rocket fuel to your rocket fuel! I’ll use examples from my real-world experiences working with Grails applications that have been sunk by heavy load and then turned around and learned how to fly.

Discussed will be techniques for identifying what problem areas to refactor and techniques to improve through put of the application once a problem area is identified.

By Peter Ledbrook

With all the buzz around rapid web application development frameworks, are enterprise developers left looking on enviously? Not at all. Grails brings RAD to web application development in the Java enterprise and this talk discusses the integration options available to you and where difficulties may arise.

Learn how you can get Maven and Grails working together, what's involved in talking to legacy databases, and why plugins are often an ideal solution to code reuse.

By Dierk Koenig

Learn how to easily write a Grails web application that appears to your users as if it was a desktop application.

To this end, we will use the Grails ULC plugin and the UlcBuilder in a live programming experience.

By Paul King

This talk looks at using Groovy for writing multi-threaded, concurrent and parallel programs. We'll briefly look at leveraging legacy Java techniques such as multiple processes, multiple threads, the java.util.concurrent APIs and shared-state atomicity.

We'll then look as some useful AST transforms in core Groovy (Lazy, Synchronized, Immutable, WithReadLock and WithWriteLock) before diving headlong into GPars. GPars is a comprehensive library for parallel execution that provides a menu of options to the developer.

The different choices available have pros and cons depending on the circumstances. We'll look at the parallel collection support and the optional transparent way to use that support. Then we'll examine Map/Reduce. We'll also look at the DataFlow approach to achieving concurrency, the Actors approach, the use of composable asynchronous functions and the use of Agents and Active Objects.

Finally, we'll peek at Multiverse (Software Transactional Memory) and JCSP, two emerging approaches that might appear more prominently in future versions of GPars. Then we'll wrap up with a brief look at testing multi-threaded programs.

By Mark Johnson

Grails is often considered just a quick simple web application development framework. But the truth is it is much more.

This presentation will take a Grails developer beyond 'grails generate-all' to understand how to create a maintainable, secured and high performance grails application for your enterprise.

By Burt Beckwith

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.

In this talk we'll look at some advanced GORM topics including using database views to map domain classes to multiple tables, writing a Configuration subclass to fine-tune domain class mappings and customize Hibernate beyond what GORM mappings provide, how to create immutable read-only domain classes, and some tips for monitoring database access.

By Andres Almiray

Discover how both the Grails and Griffon frameworks bring back the fun to web and desktop development.

Grails and Griffon share a lot of history and code, its very likely that what you learn in one framework can be done in the other and viceversa. Both are pretty much on par when it comes to communication across the wire, serialization or remoting; those are precisely the options that we'll explore in this session to build a Griffon frontend powered by a Grails backend.

By Peter Ledbrook

It's very easy to create plugins for Grails, particularly if all you want to do is share some domain classes between projects. But even with the simplest plugins, you still need to know a few things to make integration with applications and other plugins as smooth as possible.

Learn how to make your plugins as flexible as possible, while minimising integration issues with other plugins. For example, find out how Searchable was modified to allow users to add search to domain classes provided by other plugins; and why the Release plugin switched from a DSL for its configuration to simple properties.

By Kenneth Kousen

Groovy and the Spring framework are old friends. Spring includes dynamic beans that can be modified while a system is still running, and of course the Grails framework is built on top of Spring MVC. Here we'll illustrate all the ways that Groovy works with Spring, and show how a developer can take advantage of those capabilities right away.

Examples will include using Groovy beans in Spring systems, refreshable beans, inline scripted beans, aspects in Groovy, and even the Grails Spring bean builder.

By Burt Beckwith

Cloud Foundry is a revolutionary open-source PaaS service from VMware and Grails applications have first-class support on the platform.

In this talk we'll look at the features of the Grails cloud-foundry and cloud-foundry-ui plugins and sample applications using supported services like MongoDB, Redis, and RabbitMQ. You'll be amazed at how easy it is to build and deploy a cloud-based application with Cloud Foundry and Grails.

By Colin Harrington

Testing is built into grails, but many Grails apps go untested. We'll cover how to test many different artefacts as well cover many principles that have helped lead to succesfully tested Grails application.s

Testing is built into grails, but many Grails apps go untested. We'll cover how to test many different artefacts as well cover many principles that have helped lead to succesfully tested Grails application.

Adapted from a talk called "Testing the Crap out of your Grails application" We'll go beyond the basics and talk about my experiences in the 10+ Grails codebases and tems that I've had the opportunity to work with.

By Dierk Koenig

Many Java developers have come to appreciate Groovy for its conciseness and scripting capabilities but not many use the language to its full extend.

In this talk we will go through some of Groovy's lesser known features by means of live coding. If you seek to make your life as a Java programmer easier by improving your Groovy Kung-Fu, this talk is for you.

By Dierk Koenig

You and your team know Java well and you have invested much to get there. But there are places in any Java project where you have to leave your preferred language to get things done: for build automation, modeling complex business domains, smart configuration, user macros, office integration, ad-hoc inspections, and more.

This session presents seven patterns on how you can leverage your Java knowledge in these areas with the help of the Groovy extension language. The seven patterns are easily remembered by their names: Super Glue, Liquid Heart, Lipstick, Keyhole Surgery, Unlimited Openness, Ghost Writer, House Elf. If you love Java and would like to see it used everywhere in your project, you will find new opportunities here.

By Jim Shingler

You are creating a website and the business wants to change the content on regular basis. What are your options and why a custom CMS solution might be a good answer.

In this session we will look at the problem space requirements: Managing Content, Content Promotion, SEO, and others. We will look at some of the options and why a custom CMS might be the best option. Finally, we will explore how to approach creating a custom CMS solution.

By James Williams

Ratpack is a micro web framework for Groovy inspired by the Sinatra web framework for Ruby. Running Jetty and Groovy's template engine at its core, Ratpack is very capable and extensible while also enabling you to write single file web apps. It fits the sweet spot for problems too small for Grails, yet too big to start from scratch. Ratpack takes routes, also known as URLMappings in Grails, and makes them the star of the show.

In this session, you'll learn how to create Ratpack apps, manage the application lifecycle, authentication, and persistence, and how to interface with Grails applications. Frankie and Sammy would approve...

By Tim Berglund and Matthew McCullough

Gradle is being adopted by enterprises and open-source projects alike for its ease of use, flexibility, and compatibility with existing standards. However, Gradle's true strength shines not when it is viewed as a wrapper around standards, but as a toolkit for creating your own standards to reflect your build patterns and practices. It is extensible at every level, but most powerfully at the level of Gradle plugins.

In this session, you'll learn the Gradle APIs you need to know to develop a plugin, the different ways to organize and distribute plugins, and the way you should use plugins as a means of extending the Gradle DSL to describe your build domain in a concise and idiomatic way. Examples will use real code for a plugin written by Tim and Matthew that can be used in development and automated deployment settings.

By Peter Niederwieser

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.

In the first part of this session, Spock's approach to state-based, data-driven, and behavior-based testing will be demonstrated. Next, we will explore some of Spock's extensions, in particular the Grails plugin and the Spring TestContext Framework integration. Finally, we will look under the covers of Spock and write our own extension. Along the way, expect to see lots of code and live demos.

By Luke Daley

Geb is a browser automation solution for Groovy. It brings together the power of WebDriver, the elegance of jQuery content selection, the robustness of Page Object modelling and the expressiveness of the Groovy language. Geb enables more expressive, more concise, and (very importantly) more maintainable web tests.

In this session we'll explore the foundations of Geb and illustrate how it uses the language features of Groovy to make web automation and testing productive and effective. After exploring the basics we'll explore Geb's rich Content DSL and discuss patterns for achieving maintainable tests. We'll also look at how it combines with Spock, the Enterprise ready testing framework, to enable low cost executable specifications that describe user behaviour, not browser details.

By Luke Daley and Peter Niederwieser

So you already know and love Spock, the Enterprise ready testing framework, but want to know how to make the most of it and take your testing to the next level? Then this talk is for you. Even if you're new to Spock, but are interested in making your testing more effective this talk is for you.

Spock has many hidden gems which we'll be going through in this session. We'll also be looking at some of the upcoming features in Spock 0.7 including; functionality and contract mixins, improved configurability, and several new lumps of syntax sugar.

By Luke Daley

We all know we should be writing functional (i.e. web) tests for our Grails applications, but this can sometimes seem like too much work for not enough gain. In this talk we'll look at the current Grails plugins that are out there that can start to decrease the development and maintenance cost and make getting the coverage you need more achievable.

Firstly we'll explore the powerful combination of Geb, the Groovy browser automation library, with Spock, the Enterprise ready testing framework, as the foundation for our testing stack. From there we'll discuss how to manage test data sets using the combination of the grails-fixtures and grails-build-test-data plugins. We'll then see how to use the grails-remote-control plugin to get inside your application from your functional tests to configure and how to use the grails-develop-functional-tests plugin to decrease the cycle time when writing your tests.

Finally, we'll discuss strategies for partitioning tests into logical groups and using the remote execution facilities of Geb to have your functional test suite run against multiple browsers and architectures.

By Kenneth Kousen

Watch Preview Video

Groovy was never intended to replace Java. Instead, it expands Java capabilities and makes developers' lives easier. In this presentation, we'll survey many ways to make your Java systems easier by adding Groovy.

Among the topics we'll cover are: parsing and generating XML, simplifying your build, making testing easier, quick database access, working with Spring, and mixing Groovy and Java at the code level.

By Tim Berglund

Cassandra is a scalable, highly available, column-oriented data store in use at Facebook, Netflix, Twitter, Reddit, Rackspace, and a growing list of other deployments. It offers a compelling combination of a rich data model, a robust deployment track record, and a sound architecture—and it isn't just for web-scale operations. It might be a good fit for your Grails app!

In this session, we'll learn the basics of Cassandra, then look at how to use it for storing data in a simple Grails application. We'll work through a simple data modeling exercise and look at the code required for interfacing with this leading NoSQL solution.

By Matthew McCullough

The open source, and specifically, the Groovy, Grails, and Gradle communities are abuzz with the use of Git. But why? We'll take a anthropological look at the projects that have converted from Subversion to Git and why they decided to do so.

We'll examine the challenges and eventual successes of several Groovy and Spring project leads and their project migrations to Git. With projects such as Grails having two and a half years on the Git DVCS and Groovy recently converted, we'll dissect the more effective and social development techniques available to the core team and external contributors via Git. As a finale, we'll look at how these same Git benefits can be achieved on internal projects, or reflected back via contributions to open source Spring projects.

By Colin Harrington

There an back again: a story of a simple HTTP request's travels through the depths of an ordinary grails application running in tomcat. Grails is an amazing "convention over configuration" framework that makes the complexities of Spring, Hibernate, etc. a breeze to work with, but it is easy to overlook or misunderstand the many levels of abstraction that make this framework so powerful.

In this session we will do a deep dive of just about every layer that a simple HTTP request goes through just to do accomplish few simple tasks. We'll start with the open socket in tomcat and work our way through every layer of code that our HTTP request invokes. We'll look at Security, Url Mappings, Filters, Controllers, data-binding, Services, GORM/Hibernate/JDBC, Views, Layouts, and all of the icing in-between.

By Glen Smith

There's a lot happening in the view tier these days: layout frameworks, UI frameworks, animation, and lots more. Add Javascript and Ajax to the mix, and your view tier can quickly become an unmaintainable mess. To the rescue comes the new Grails resources infrastructure, less.css, backbone.js, twitter bootstrap, and plenty more! So come along!

This talk presents a practical refactoring of a tangled Grails UI, while exploring strategies for simplifying your view layer giving maximum flexibility and performance. Included in the talk is a discussion of the new Grails resources infrastructure, Less.css framework, Twitter Bootstrap, Backbone.js, Form & Navigation strategies and much more!

By Hans Dockter

Watch Preview Video

This presentation introduces the audience to the power of Gradle through many real-world examples that are demonstrated live. By the end of the presentation, you'll understand how Gradle helps to elegantly solve the challenges that we face in our daily enterprise builds.

We'll go through such powerful concepts as: advantages of declarative over imperative build systems, convention over configuration without rigidity, task definitions and dependencies, the benefits of plugins, deep multi-project support, runtime optimizations through partial builds and harvesting existing functionality through Ant and Maven integration as well as strategies for migrating from these build tools. We will demonstrate some of the innovative goodies that come with Gradle out-of-the-box, like smart incremental builds, the Gradle Daemon and the Gradle Wrapper. We show also many of the new features like Eclipse integration, Sonar integration, Heroku integration, C/C++ support and other new plugins.

By Hans Dockter

In this talk we will cover many Gradle power features that are particularly helpful for the real heavy lifting often needed in enterprise builds.

We will start this session with the concept and advantages of autowiring the Task Dependency Graph based on the inputs and outputs. We will then talk in detail about the new dependency management features such as the new cache, customizable dynamic revision handling and customizable version conflict resolution. From there we'll explore the new extension mechanism for the Gradle DSL and introduce the Gradle daemon. We will also discuss our take on best practices for dealing with module dependencies in the enterprise and how this can be mapped with Gradle. Finally we will show how you can programatically customize the way the Gradle build model is mapped to the STS Gradle Eclipse plugin. All those features are presented in the context of our roadmap and what further improvement you can expect with future releases.

By Scott Davis

Now that HTML5 is the standard output format for Grails 2.0, shouldn't you really dig in and see what all of the excitement is about?

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!

In this talk, you won't be subjected to discussions about the features that will appear in some distant future release of a web browser. Instead, you'll see the HTML 5 features that are already being used by Google, Apple, and others. You'll see the features that are supported by today's browsers, ready for you to use right now.

By Andy Clement and Andrew Eisenberg

The SpringSource Tool Suite makes developing your Groovy and Grails applications significantly easier with its support for debugging, refactoring, editing, and server diagnostics. In this session, we will showcase the Groovy and Grails tooling available in STS, focusing on the more recent advances such as configurable DSL support, Grails refactoring, debugging, and direct deployment to either tcServer or the Cloud Foundry PaaS. From a build point of view we'll take a quick look at the new Gradle support and an alternative to GMaven for building your maven based mixed Java/Groovy projects.

Session Detail

By Shawn Hartsock

You don’t want to have your users tell you about application performance problems. You want to know about them before they do.

vFabric Hyperic can open a window into your running Grails application. You can even use JMX to provide custom visibility to the health and performance of your Grails application.

By Scott Davis

It always amazes me when Groovy developers say, "I don't like JavaScript." Both are dynamic languages that make metaprogramming seamless, but Groovy edges out JavaScript in the race for conciseness and syntactic sugar. That is, until CoffeeScript came onto the scene.

CoffeeScript is to JavaScript as Groovy is to Java -- both give their respective base languages a thoroughly modern makeover. CoffeeScript brings string interpolation (think GStrings), null-safe property access (person?.middleName and our beloved Elvis operator), and much more to JavaScript development. Perhaps CoffeeScript founder Jeremy Ashkenas says it best: "Underneath all of those embarrassing braces and semicolons, JavaScript has always had a gorgeous object model at its heart. CoffeeScript is an attempt to expose the good parts of JavaScript in a simple way."

CoffeeScript is more than an intellectual curiosity. It is the #1 most followed project on GitHub. It ships as a standard library in Rails 3.1. But most importantly, Brendan Eich openly acknowledges that CoffeeScript is influencing the future direction JavaScript (formally, ECMAScript "Harmony"). Much of what you see in CoffeeScript today will become native to JavaScript tomorrow.

Why don't you join me and see what the fuss is all about? You'll never look at JavaScript the same way again.

By Andres Almiray

Despite of all the buzz and hype around webapps over the last 8 years fact is that desktop applications are still found in many places, specially in the enterprise. However the legends are true: building desktop applications is a hard job. But it does not have to be. Enter Griffon.

Griffon aims to bring back the fun and productivity to desktop application development in the same way Grails did it (and continues to do so) on the web. Griffon is rooted in the JVM but has Grails in its DNA. This means you'll find yourself right at home if you're a Java veteran, same goes for all of you that made the jump to Grails. In this session we'll cover the basics to get you started with Griffon. How applications are structured and built. Then we'll switch gears into high speed and cover topics like threading, testing, deploying, handling of legacy code and even network and database integration.

By Mark Johnson

The factory patterns and callbacks have been around for a long time as a technique to provide flavor specific code variations. But they are awkward and hard to update. Enter Groovy closures. Imagine having the ability to inject different coding flavors using code closures. If you need a different flavor, then just pass a different code block. Now imagine that all of this works on the JVM!

This session will use hands on examples to explore how to use and create closures. In addition, during the discussion we will also discuss when it is appropriate and inappropriate to use closures in your applications.

By Jeff Scott Brown

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.

This session will cover a lot of the GORM API from the developer's perspective as well as diving into some of the implementation details. Knowing how some of this works under the covers will give developers an opportunity to not only improve their productivity with GORM but also open up possibilities of using dynamic metaprogramming in other aspects of their application development efforts.

By Venkat Subramaniam

Watch Preview Video

Programming concurrency can be a pain or a pleasure depending on how you approach it. GPars is an elegant fluent library written with Java performance and Groovy conciseness and expressiveness in mind.

In this example-driven presentation, we will deep dive into GPars and learn about its capabilities and how you can put this to good use in creating your next concurrent application.