Presentations

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.

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.

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.

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.

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.

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.

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?

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.