Presentations

Acceptance Testing with Groovy

An ideal way to make use of Groovy's great support for writing domain specific languages (DSLs) is when writing customer or acceptance tests. When using such an approach you typically use a high level English-like testing DSL to express the test. The approach is so popular that in fact numerous frameworks now exist for creating such tests.

We will examine a few of the more popular frameworks and glimpse at a few of the more exotic choices. Frameworks examined include EasyB, Spock, JBehave, Cucumber, Robot Framework, Slim and more. We'll also examine a range of powerful testing approaches beyond these tools which are useful for acceptance testing.

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

This talk looks at using Groovy for multi-threaded, concurrent and grid computing. It covers everything from using processes, multiple threads, the concurrency libraries ear-marked for Java 7, functional programming, actors including a brief glimpse of GPars, as well as map/reduce, grid and cloud computing frameworks.

We'll look at leveraging Java techniques as well as Groovy specific approaches.

• Multiple Processes with Ant, Java and Groovy
• Multiple threads - Java and Groovy support
• The java.util.concurrent APIs, Fork/Join, Atomicity and more
• Useful Java libraries: Google collections and others
• Useful Groovy AST transforms: Lazy, Synchronized, Immutable
• Concurrency libraries: Jetlang, Multiverse
• A brief glimpse at GPars
• Polyglot solutions with Scala and Clojure
• Grid computing and cloud solutions
• Testing multi-threaded programs

Concurrency with GPars

This talk looks at writing concurrent Groovy programs using 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 and the use of Agents for delegated task coordination. Finally, we'll peek at Multiverse (Software Transactional Memory) and JCSP, two emerging approaches that might appear more prominently in future versions of GPars.