2GX Session Descriptions

Securing Grails Applications

When you think about securing a Grails application, you probably think of the Spring Security and Shiro plugins. But these plugins only control access to your pages and objects – what about guarding agains cross-site scripting (XSS), cross-site request forgery (CSRF) and SQL injection attacks? The OWASP project maintains a list of the top 10 web application security risks.

Grails Transactions

Properly performing multiple data updates requires a transaction, but how do we do this in Grails? Services are the best option, but there are different approaches that can be used.

Grails Plugin Best Practices

Grails plugins are a great way to reuse and share common code, and to modularize an application. In this talk we'll look at the general process for creating a plugin.

An Introduction To Web Development With Grails 2

Grails brings the powerful "coding by convention" paradigm to Groovy and Java. Grails is not just another flavor in the pool of web development frameworks for Java. Grails leverages the powerful dynamic features of Groovy while taking advantage of best of breed technologies like Hibernate, Spring and Sitemesh to make web application development both fun and easy.

Advanced Web Development Techniques With Grails 2

Getting started building web applications for the Java platform is easy. Following that through to rich interactive applications that solve the business needs is more tricky. Grails 2 goes the whole way to address pain points not only for simple applications but of real enterprise applications with real demands. This session steps through many of the advanced features of Grails 2 that help get your applications through that last 20% that teams often struggle with. This session is not the standard hello world CRUD introduction to Grails.

Metaprogramming With The Groovy Runtime - Part 1 of 2

The dynamic runtime nature of Groovy is one of the things that sets it apart from standard Java and 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. This Part 1 of 2 will cover the runtime metaprogramming capabilities of Groovy. The session will dive deep into Groovy's Meta Object Protocol (MOP) which implements the incredibly dynamic runtime dispatch mechanism. The session will include a lot of live code demonstrating really powerful runtime features of the language.

Metaprogramming With The Groovy Compiler - Part 2 of 2

The dynamic runtime nature of Groovy is really powerful and really flexible. The runtime capabilities of the language allow for a lot of capabilities that are not possible with less dynamic languages. Those runtime capabilities are really powerful but are not the whole story of Groovy's dynamic capabilities. Groovy also allows for a lot of dynamic behavior to be introduced at compile time. Participating in the compilation process isn't something that application developers are generally used to doing, but Groovy makes it somewhat easy to jump into that process without having to write a whole compiler of your own. This session will dive deep into the features of Groovy that allow for you to participate in the compilation process to control what the compiler emits. You will learn to add methods to classes, modify existing and more, all at compile time.

Polyglot Web Development With Grails 2

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.

Part of what makes Grails so compelling is its really powerful plugin system. The Grails plugin system allows capabilities to be bolted on to applications, including adding support for a variety of programming languages. All of the major programming languages available on the JVM are supported by The Grails Framework. These include Java, Groovy, Scala, Clojure and others.

Embedding Groovy in your Java applications

The Groovy language has always been promoted as an excellent companion to the Java language, but also as a lightweight platform for building DSLs on the JVM. In practice, Groovy offers a wide range of options to integrate with Java: plain application then use it as a jar dependency, cross-compilation, GroovyScriptEngine, GroovyShell, ... Furthermore, each of those solutions have benefits or disavantages that you might not be aware of.

Type checking your DSLs

Since Groovy 2.0, the Groovy language offers the ability to type check your code at compile time. Type checking is a nice feature for people who come from a strongly typed language world and do not feel comfortable with dynamic typing. On the other hand, Groovy is also a perfect match when it comes to writing DSLs. It becomes even more interesting if you know that you can combine strategies in order to provide the user with a statically checked DSLs.

Becoming Productive Groovy/Grails and Spring Developer with IntelliJ IDEA

When it comes to productivity, what counts is reliable and smart support from your IDE for the frameworks in your project. IntelliJ IDEA’s support for Groovy, Grails and Spring has been going strong for the last few years, expanding and refining its features with each new release.

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

The Art of Builds - An in-depth comparison of build tools

Discussions around Builds and Buildsystems haven't been treated for many years with the conceptual depth and principles they deserve and require. The lack of this is even more painful today as modern builds form a crucial part of a continuous delivery pipeline far away from the simple copy, compile and archive of the past. We will discuss the concepts of declarative and imperative builds, standardization of your build process, the executional model of a build system and dependency management. We will shed a lot of light into the dark with surprising results that are crucial to understand when deciding for a build system.

Patterns delivering JSON with Grails

JSON (JavaScript Object Notation) is now the lingua franca of data interchange. Most platforms such as browsers, phones, client and embedded applications have support for consuming/producing JSON. Native Browser compatibility makes it especially convenient for our modern web architecture.

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

Utilizing Groovy based closures for flexible real-time analytics

Real-time analytics is the process of monitoring and often reacting to web based events or machine-to-machine communication and then quickly deliver the appropriate response to an end-user or machine process. The challenge though is how can we modify the analytics algorithms and reference data without shutting down the data feeds.

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.

Working with Databases and Groovy

This talk reviews the features in Groovy which make it easy to work with databases. It reviews the features of Groovy SQL including Groovy's LINQ-like lazy evaluation technology called datasets. In addition, it looks at working with a couple of NoSQL databases: MongoDB (using GMongo) and Neo4J (using it's Java api and via Gremlin support).

Leveraging Groovy for Capturing Business Rules

Groovy has excellent support for the creation of Domain Specific Languages (DSLs). Such DSLs can be particularly useful when writing business rules. Rules can be written in English-like phrases which are straight-forward to read or write (by non-developers) yet can be fully executable code corresponding to a layer over the top of a traditional logic solving API. This talk illustrates various DSLs, highlights several logic solving APIs and looks at the pros and cons of the various approaches (including tool support, flexibility, lock-in).

Grails-Powered HTML RIAs

Page-based web applications were once the norm, but times have changed. Users increasingly expect rich, desktop-like experiences from their browser-based applications. They demand apps that adhere to common standards, without the need for special plugins. Finally, they want to use them on any device, from smartphone to flat-screen.

It's a daunting task, but help is on the way. Grails provides an awesome foundation for HTML-based Rich Internet Applications. In this session, we'll see how Grails can make HTML RIAs a snap.

JavaScript is the language of the web, but it has its warts. Grails plugins allow us to easily leverage intermediary languages like CoffeeScript or TypeScript to help create large-scale client-side code. Libraries like ExtJS or Dojo offer expansive UI toolkits that hook perfectly into Grails REST APIs. JSON and GSON are excellent data exchange formats, as long as you properly plan out their structure. And GORM is incredibly powerful, but without careful thought you can inadvertently send huge amounts of unnecessary data to the client.

Spock: Logical Testing for Enterprise Applications

The Spock framework brings simple, elegant testing to Java and Groovy projects. It integrates cleanly with JUnit, so Spock tests can be integrated as part of an existing test suite. Spock also includes an embedded mocking framework that can be used right away.

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

RESTful Groovy

The JAX-RS 2.0 specification is part of Java EE 7, but can be used now. It contains the expected annotations for the HTTP verbs (@GET, @POST, and so on) and mechanisms for retrieving variables, but only a few methods for doing hypermedia. This presentation will review those techniques by adding both structural and transitional links to resource representations. Groovy is used to simplify the code and also to implement a MessageBodyWriter for JSON data.

Prerequisite: Some knowledge of Groovy would be helpful

A Groovy Mullet: JavaScript in the front, Groovy in the back

Grails 2.3 makes it much easier to build RESTful web services from your domain classes, and even includes hypermedia capabilities. This presentation will demonstrate those capabilities and then add a JavaScript client-side framework like AngularJS. The Ratpack framework will also be used as an alternative server-side implementation.

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.

Advanced Groovy Tips and Tricks

Groovy has a very easy learning curve for Java developers, so many people become Groovy users without realizing all it can do. This presentation will examine features of Groovy that can make your life easier once you're past the initial adoption stage.

Prerequisite: Some Groovy knowledge

Lift-off with Groovy 2.1

Let's talk about all the new features of Groovy 2.1!

With 1.7 million downloads last year, Groovy continues leading the pack of alternative languages for the JVM. Groovy 2.0 was released almost a year ago, introducing its modularity, its JDK 7 support with "Project Coin" syntax enhancements and usage of "Invoke Dynamic", and proposing static type checking and static compilation support.

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.

Application Architectures with Grails

Grails is geared towards an MVC architecture with a database back-end and a service layer. But is this the only way to write Grails applications? What other architectures are possible and what is required to implement them?

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

Grails and the Realtime Web

Grails 2.3 is coming with new asynchronous and eventing features, driven by the same usability that shapes the Grails success amid developers. That means the framework now supports the modern definition of "realtime".

In fact, Platform-core plugin currently helps developers at writing Event-Driven Architectures and pushes the boundaries to the Browser with its Events-Push extension. Scalability might also be an outcome of such architecture, since multiple Grails applications can now easily work together. Eventually, with events propagated across server(s) and browsers, a new set of patterns emerges and HTML5 web applications have rarely been so pleasant to write.

Orchestrating Tasks from the Cloud with Groovy and AWS SWF

Some of the most difficult problems in applications today involve coordinating and distributing work in a resilient way. Use cases include communicating with unreliable remote services, parallelization, scheduling critical timers, being immune to server failures... Even if you handle these concerns how do you test this sort of orchestration glue-code? Groovy's powerful metaprogramming capabilities and AWS's robust Simple Workflow Service can be used to solve these problems.

Building a Continuous Delivery pipeline with Gradle and Jenkins

Getting software from a developer's machine to a production environment without a fully automated process is time-consuming and error-prone. Continuous Delivery enables building, testing and deploying of software through build pipelines with well-defined quality gates.

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.

Uncle Sam's Guide to Grails Security

Grails makes it easy to dive right in and build an application, but that's the tip of a very large iceberg. Joe Rinehart's spent years working in highly secured environments and been the subject of many top-to-bottom, OS-to-Web audits. Join him as he introduces publicly available security guidelines for Java/Grails applications made available by some of the strictest clients in the world, showing how Grails can often make life much easier.

Bootstrap Your App

Somehow I've gained a reputation for applications that users think look good and are easy to use. I think my code's sometimes pretty, but please don't ask me to center something in CSS or Photoshop my way to fame and fortune. Recently, all the credit really goes to Twitter's Bootstrap UI library.

Road to Grails 3.0

In this talk Grails project lead, Graeme Rocher, will talk through the latest and greatest happenings in the world of Grails including a walk through of the features included Grails 2.3 and upcoming in Grails 3.0

RESTfully Async with Grails 2.3

In this talk Grails project lead, Graeme Rocher, will talk through the latest Async features offered by Grails and how they can be used to create elegant non-blocking REST APIs.

Search for the Holy Grail (and test it once found)

Grails is awesome! agreed? Good!

Now, search and testing facilities have become such a basic commodity in applications that it's almost taken for granted.

But as a Grails developer you face limitations and concerns: is the library well maintained? Does it fit the framework's paradigm?

After nominating the winners, we’ll show you the advantages of our tools of choice and take a deep dive into the juicy details.

Plugging the users in - extend your application with pluggable Groovy DSL

It is often beneficial to allow users extend your software with their own logic. With the rise of dynamic languages on the JVM it is also much more easier to do than ever before. In this session we will share our experience in creating Groovy authored user plugins interface.

Asgard, the Grails App that Deploys Netflix to the Cloud

Asgard is a free and open source Grails application built and used by Netflix to deploy code changes and to manage resources in the Amazon cloud at large scale.

Exploring Groovy Annotations

Everyday coding involves taking care of so many things that much time can get wasted writing over and over code to deal with the basics of programming. Not so in Groovy, thanks to the annotations that transform your code to synthesize the cruft.

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.

Compile Time metaprogramming with Groovy AST Transformation

The ability to navigate and even alter the abstract syntax tree of your code is very powerful and yet under utilized. Quite a few tools have exploited this capability in Groovy. These techniques can be useful to create fluent syntax and validate DSLs.

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.

Testing Controllers with Spring MVC Test and Spock

Everyone knows controllers can be tricky little buggers to test. Spring MVC Test brought some exciting testing capabilities to Spring 3.2, but it you're left on your own for mocking the service layer in your controllers.

Case Study - Using Grails in the Real World

We all know how to code various patterns of behavior. But when your app needs to be used in the Real World(tm), there are certain things that are key.

Deploying, Scaling, and Running Grails on AWS and VPC

This talk will cover how to get your application running on AWS VPC and related services and various Grails plugins to help you along the way.

Building APIs with Grails

APIs open up our application data and functionality to other clients like mobile applications, JavaScript clients and even potentially other companies. The most prominent way of implementing them is by using the REST architectural style and it is now almost expected for all web developers to know how to build good RESTful APIs. As Grails developers, we have a few options readily available to us to simplify this task and Grails 2.3 included lots of new REST support.