Getting Groovy on the Web and Desktop

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

Painless Desktop Application Development: The Griffon Experience

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.

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.

Deploying Grails Applications to Cloud Foundry

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

Grails Spring Security Plugins

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.

Grails in Front, Cassandra In Back

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!

Plugging Into Gradle Plugins

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.

A Thorough Introduction To Grails

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

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.

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

Spring Tooling Update - New and Noteworthy

In this session we will walk through the Spring tooling landscape and demo the new and improved features. Attendees will see tooling support for Spring 3.1 in action together with improved support for annotation-based Spring programming including content-assist, validation, quick-fixes and refactorings. We will take a look at improved support for XML-based Spring programming and the tooling support for the Cloud Foundry PaaS. Then a quick tour of recent improvements in the Groovy/Grails support and our new Gradle tooling. We close this session with an overview of the general release cycle and the plan for the next releases.

Tooling the Groovy Ecosystem

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.

Geb - Very Groovy Browser Automation

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.

Next Level Spock

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.

Productive Grails Functional Testing

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.

CoffeeScript for Groovy Developers

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.

HTML 5 for Grails Developers

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!

Enter The Gradle

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.

Enterprise Gradle

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

Testing Grails: Experiencies from the field

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

There an back again: a story of a simple HTTP request

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.

Performance Tuning Grails Applications

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.

The Highly Monitored Grails Application

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

Architecting an Enterprise quality Grails application

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

Groovy Closures - The way to cleaner code

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!

Groovy Modularisation

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.

Groovy and Concurrency with GPars

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 divign headlong into GPars. GPars is a comprehensive library for parallel execution that provides a menu of options to the developer.

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.

Software Development Best Practices - Groovy Edition

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?

GORM: Object Persistence Done Right

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.

Extending Java's reach with Groovy, 7 scenarios

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.

Pro Groovy

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

Rich Grails UIs with Canoo RIA Suite

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

Groovy Spring Beans

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.

Improve Your Java with Groovy

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.

Gaelyk -- Groovy coding the cloud

Guillaume will speak about Gaelyk, a lightweight Groovy toolkit for easily developing Groovy applications to be deployed on Google App Engine Java.

Groovy Update, what's new in 1.8 and what's coming?

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!

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 in the Java Enterprise

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.

Grails in the cloud

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.

Grails plugin development - lessons to learn

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.

Groovy, Gradle, Grails and Git: Why, When, Where, What and How

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.

Plugging Into Gradle Plugins

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.

Next Level Spock

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.

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.

Polyglot Persistence in the Cloud with Grails

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.

What's new in Grails 2.0?

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.0 including agent-based reloading, unit testing mixins, and the latest enhancements to support Servlet 3.0.

Content Mgmt with a Custom Grails CMS

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.

Using Grails on a publicly facing Fortune 500 website

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?

Does my DIV look big in this? Refactoring Your Grails View Tier

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!

Grails Hacker Triage: 10 Shameless Hacks and Refactors

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!

Design Patterns in Groovy

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.

GPars deep dive

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.

Integrating Groovy and JVM Languages

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.

Options for Concurrency in Groovy

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.

Ratpack: Classy and Compact Groovy Web Apps

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.