Griffon Jumpstart

Have to renew or spice up a desktop application at work? In need of a rich desktop experience but don't now where to start? If any of these sound familiar to you or you're just curious to know more about Griffon then you've come to the right place.

Groovy AST Demystified

Compilers are powerful tools, they pretty much translate your thoughts into machine code. Extensible compilers are even more powerful. It turns out that the Groovy compiler can be extended by means of AST transformations.

Grails goes Graph

Thanks to the GORM abstraction layer introduced in Grails 2.0, adding new persistence engines is much easier compared to Grails 1.x times. During the last months the Grails Neo4j plugin was established and is now in a phase of stabilization. Despite that it's already used in production.

Hacking the Grails Spring Security Plugin

Spring Security and the Grails Spring Security Core plugin have many extension points, but it's often not clear where to look when you want to change how things work for your application. In this talk we'll look at customizing behavior, from overriding configuration parameters to creating custom subclasses.

The Grails Cache Plugins

The new Grails cache plugins build on the Spring 3.1 Caching API to provide easy and transparent caching to Grails applications. Using annotations and GSP tags you can quickly configure service method, controller action, and page fragment caching to help your application scale by avoiding regenerating expensive responses and method calls.

Under the Hood: Using Native Hibernate in Grails

GORM is very powerful and makes it simple to work with databases but there are features and configuration options that aren't available or are inconvenient to work with.

Under the Hood: Using Spring in Grails

The Spring framework makes up the core of Grails, providing bean management, dependency injection and transaction support. Grails controllers and the web tier use and extend Spring MVC.

Developing Mobile HTML5 Apps with Grails

Developing applications for mobile devices using web technologies is now well within reach. When the capabilities of HTML5 are combined with CSS3 and JavaScript, web application developers have an opportunity to develop compelling mobile applications using familiar tools.

While the HTML5 specification is still evolving, there is a lot that can be used right now to build mobile web apps. Mobile web apps are now starting to provide many of the features that were once only available to native-language-based apps in Java, Objective-C, etc.

Groovy as a weapon of massive PAASification

Amadeus is a leading actor in the Travel Industry. Our e-Commerce division, responsible for providing cross-channels (B2B, B2C, Travel or Airline agents) front-ends, has been developing community applications, self-hosted in a SaaS model, for now more than 10 years; they are multi-tenant, as to share the same infrastructure for all our customers.

We therefore built a highly sophisticated model of physical and logical farms, partitioning the traffic and optimizing resources. We operate 700+ JEE nodes, split in 30+ logical clusters, deployed on less than 10 physical server pools. Today, this infrastructure is delivering a billion dynamic pages per month, for more than 5 million bookings, with a 10 times factor growth expected in the coming years.

Even though thousands of parameters are available to tailor our products to any one particular needs, the recent evolution of the IT Industry towards PAAS ecosystems modified customer expectations: they are now looking for the capability to extend our applications, interact with their own IT, influence our business logic or even graphical interface.

To support this vision, we started developing an extensibility framework, based on scripting technologies. Though being language agnostic, we quickly decided to invest on the Groovy language and rely on JSR 223 to embed it into our applications.

However, transforming a multi-tenant & community SAAS ecosystem into a flexible PAAS environment implies to take up multiple challenges, especially around sandboxing – access & resource control – or productivity and production constraints, such as hot-reloading or instantaneous fallback mechanism.

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

Thorough Introduction To Grails 2

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.

What Is New In Grails 2?

In this session, Grails core developer Jeff Brown 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.

Groovy 2: type checking to the rescue!

Choosing a language is often a matter of taste. While a lot of people using Groovy come from a Java background, not every Java developer is willing to use Groovy because of its dynamic nature. Often, those people are disturbed by the lack of error reporting at compile time for code that would be obviously wrong in a static world. Unfortunately, by nature, Groovy cannot catch such errors because program semantics are ensured at runtime.

Well, this was before Groovy 2. In the latest version of the language, we introduced two annotations, @TypeChecked and @CompileStatic, which are precisely aimed at helping Java developers to seal the semantics of the language at compile time.

Just do it: Migrating to Grails

Are you in the process of evaluating adopting Grails? Are you 'too comfortable' with you current Jsf/struts application but you don't want to be left behind? In this session, you will learn how to migrate a pure Java application to Grails with and emphasis of getting the least code redone while aiming to maximize those areas where Grails delivers a big productivity boost.

Warp 10: High performance Grails

Using any framework wrong will result in poor results, including performance. Grails can deliver excellent performance to those that ask nicely, but there are many pitfalls and landmines scattered. In this session you will learn how to architect a new application to start on the right foot when it comes to performance, avoiding costly future refactoring. For existing applications, there will be well defined processes to find out the pieces that are slowing your Grails application.

Gradle - the Innovation continues

The Gradle development team have not been taking it easy since the release of Gradle 1.0. New features and innovations are constantly being added, rough edges are being smoothed and the platform continues to expand. In this session we’ll explore the most notable additions to Gradle since the release of 1.0 and preview some of the new and exciting features just over the horizon with Gradle founder and Gradleware CEO Hans Dockter and Gradle core developer Luke Daley.

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.

Gradle Plugin Best Practices

One of Gradle's attractive features is that plugins are extremely simple to write and can do anything. Gradle plugins can add new functionality, enhance existing functionality or even remove undesired functionality. If you've ever wanted to write a Gradle plugin, or are interested in the deep details of plugins, then this session is for you.

In this session we'll explore some fundamental concepts that can be used as guidelines when developing plugins and new Gradle functionality, and the role of plugins and how they can be used.

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.

Standardizing your Enterprise Build Environment with Gradle

The larger and more diverse your technology organization, the greater the value you can realize in standardizing your build and delivery process. Internal build standards make it easier for people to switch between teams, allowing you to more readily adjust your staffing to meet changing business needs. In this session we’ll walk through examples of leveraging Gradle’s extensibility and plugin mechanisms to develop standards, enforce compliance and deliver tailored out of the box functionality. We will also discuss how to provision such customisations throughout your enterprise in a controllable way.

Gradle - the Innovation continues

The Gradle development team have not been taking it easy since the release of Gradle 1.0. New features and innovations are constantly being added, rough edges are being smoothed and the platform continues to expand. In this session we’ll explore the most notable additions to Gradle since the release of 1.0 and preview some of the new and exciting features just over the horizon with Gradle founder and Gradleware CEO Hans Dockter and Gradle core developer Luke Daley.

Patterns for Efficient Build Promotion

We have seen quite a few larger projects for which a naive practice of early integration between the components lead to constant breakages. Thus they were not capable to successfully build a new version of the software stack for days or even weeks. Obviously the problem of that is dramatic as no regular manual testing and capacity testing is taking place. Not only is this a massive waste of testing resources, it also leads to very long and therefore expensive feedback cycles that severely affect your time-to-market of new features. It also a likely source of conflict between the CI team and software development, as with no other means at hand, there is a desire to create stability by not adding new features or doing important refactoring.

Grails in the Enterprise: Can I? Should we?

Java/J2EE looking for something better but not sure if you can sell paying the price of a new language/framework? Not sure if Grails will work in YOUR environment?

Grails & Async

We will cover techniques for providing resources not contstrained to typical request/response boundaries.

Resources Plugin Deep Dive

Since Grails 2.0 the Resources Plugin has been included by default on new apps. The Resources Plugin provides a powerful streamlined asset pipeline that you can configure and extend. These technologies are essential for providing a performant web experience and is also under appreciated in the community.

GETn2it -- Case study of building a startup's business using Grails and Spring

GETn2it is social marketing platform designed to sell the maximum number of live music event tickets, as well as high-margin on-night food, libation and merchandise in venue and the surrounding concert neighborhood.

There were a number of technical challenges that needed to be met by the platform, and using Grails and the Spring framework to build the platform met those challenges. Key factors like rapid prototyping, agile requirements to meet changing stakeholder needs, and aggregating and processing massive amounts of 3rd party data were all quickly met with Grails and Spring.

Modern Application Architectures with Grails and Spring

Today's modern applications have much different requirements than traditional enterprise applications from a decade ago. Today's applications require things like multiple client channels, integration with big, unstructured data, rapid time to market, and unparalleled scalability. And most traditional enterprise development frameworks aren't well suited to meet these needs.

Creating Groovy DSLs that Developers can Actually Use

In this presentation, Guillaume, Paul, and Andrew will show you how to leverage Groovy to build a Domain-Specific Language (DSL) used to control a rover on Mars! Various metaprogramming techniques and integration mechanisms will be demonstrated. But the language itself is only the first part of the story. Developers cannot be expected to properly use a DSL without first-class IDE support and documentation.

Functional Groovy

Groovy doesn't claim to be a fully-fledged functional programming language but it does provide the Java or Groovy developer with a whole toolbox of features for doing functional style programs. This talk looks at the key Groovy features which support a functional style. Topics covered include using closures, currying and partial evaluation, closure composition, useful functional-centric AST macros, useful functional-centric runtime meta-programming tricks, trampolining, using Java functional libraries, immutable data structures, lazy and infinite lists, using Groovy 2's static typing and approaches for moving beyond Java's type system.

Solving tic-tac-toe: an addendum to the static vs dynamic typing/OO vs functional debates

This talk explores how to write a TicTacToe API meeting some interesting static typing constraints. Specifically, programs using the API may fail to compile depending on the state of play in the game, e.g. trying to call move() with an already completed game board. The real theme behind the talk is not so much in solving the TicTacToe problem but in pushing static typing to its limits (and some might argue beyond its useful limits - you will have to judge for yourself).

Writing your own Groovy 2.0 module

Learn about the modularization features in Groovy 2.0 including everything you need to know to write and use your own modules.

Design Patterns in Groovy

Languages that support both dynamic typing and closures radically simplify the standard design patterns. This presentation will demonstrate how many of the common patterns in Java simply vanish in Groovy, and how much simpler they are even when they remain.

Grokking GORM (and Hibernate)

The Grails Object Relational Mapping (GORM) API is an elegant domain specific language on top of Hibernate. To really understand how it works, you need to understand how Hibernate sees the world. This workshop will explore the behavior of GORM, from following object state transitions to managing the session to fetching lazy associations and more.

Helping Spring with Groovy

The Spring framework has always had a friendly relationship with dynamic languages. In this presentation, we'll look at all the ways you can add Groovy to Spring to make development easier, ranging from simplifying your configuration files to deploying refreshable beans to using Spock tests in the Spring test context and more.

Making Java Groovy

Groovy isn't designed to replace Java -- it just makes Java cleaner and easier to develop. This presentation will look at various tasks Java developers need to do and demonstrate ways Groovy can help.

Testing Grails

Grails comes with extensive testing support, ranging from unit to integration to functional tests. This session will demonstrate the range of options available both natively and through testing plugins.

Prerequisite: Some knowledge of Grails would be helpful but not assumed

Creating Groovy DSLs that Developers can Actually Use

In this presentation, Guillaume, Paul, and Andrew will show you how to leverage Groovy to build a Domain-Specific Language (DSL) used to control a rover on Mars! Various metaprogramming techniques and integration mechanisms will be demonstrated. But the language itself is only the first part of the story. Developers cannot be expected to properly use a DSL without first-class IDE support and documentation.

What's new in Groovy 2.0?

Groovy is a very popular alternative language for the JVM that continues to bring more developer productivity and more performance after each release. In this session, after a quick overview of the key features of Groovy 1.8, we'll dive through the new developments in the recently released Groovy 2.0.

Grails and the World of Tomorrow

It's an interesting time in the world of application development. We're in the middle of a perfect storm in which cloud deployments, alternative data stores, and rich, multi-device client UIs are emerging as the future standards. What does this mean for Grails developers and what does the framework offer in this very different world?

Groovy & Grails for Spring/Java developers

Java is a good all-purpose programming language, but does that mean it's the best tool for all jobs? In this talk, you'll see how Groovy can scratch itches you didn't even know you had. From scripts, to writing unit tests, to building projects, we'll take you through use cases that highlight the advantages of having a second language in your toolbox.

Modularizing your Grails application with private plugins

This talk will cover the most underrated feature of Grails -- the plugin system. Grails plugins are usually thought of as a way to add useful features to a new Grails application, but the plugin system also provides a powerful mechanism for reuse by breaking up a large application into reusable vertical slices.

I'll start with a brief overview of Grails plugin development and expand on this to show how to create private plugins to break apart a monolithic Grails application into reusable application components. I'll show how to implement default functionality in these plugins that you can override in different applications.

GORM Internals

Want to understand the magic of GORM? Then this session is for you.

Grails Update

In this session, Grails project lead Graeme Rocher will deliver an update on the latest and greatest features of the Grails framework, including all the new features introduced in the 2.x line.

Building an Integration Platform with Grails and Gradle

Due to increasing demand for a common interface as well as extensibility for our core software at Adaptive Computing, we have developed a single point of integration using Grails and Gradle in the form of a RESTful web application called Moab Web Services (MWS). As a part of these efforts, we developed a plugin platform that allows us to dynamically modify the behavior of MWS, even after being deployed on a client system and without restarting the application. We tackled numerous obstacles and questions during the development of the platform including JVM classloading, plugin services, plugin conventions, inter-plugin communication, plugin development, configuration and metadata, testing using the Spock framework, exposing plugin web services, and management via a web interface and RESTful API.

Groovy Power Tools

Groovy has been around for some time and is generally recognized as a highly productive object-oriented language with a tight association with Java. Groovy seems to be going through a second wave of popularity with a more diverse repertoire of benefits, including building, deploying and testing, in addition to rapid web development. The fastest growth of productivity tools are all powered by Groovy. Discover the Groovy Truth!

Spock - Unit Test and Prosper

Spock is a groovy based testing framework that leverages all the "best practices" of the last several years taking advantage of many of the development experience of the industry. So combine Junit, BDD, RSpec, Groovy and Vulcans... and you get Spock!

This is a significant advancement in the world of testing.

Prerequisite: junit

Applying Groovy Closures for fun and productivity

You can program higher order functions in Groovy quite easily using closures. But the benefits of closures go far beyond that. Groovy has a variety of capabilities hidden in closures.

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.

Improving your Groovy code quality

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

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.

Streaming Video In Grails

This talk will demonstrate and show how the grails video plugin works by allowing pseudo-streaming to the browser and using ffmpeg to transcode all videos into a common format on the server. Clients ask many times for functionality like this for their sites, and you will learn a easy and simple and free way to fulfill the need.

Web Clustering Integration with Terracotta, Quartz, & Grails 2

Terracotta has a free open source edition which provides excellent functionality for clustering in Grails and Java, and I will show use to set up Terracotta and cluster your application using its main features Ehcache, HTTP Session in Tomcat, and Quartz.