Using Groovy for Testing

Full Paper

We quickly sample a flavor of many techniques and tools including these topics:

• Using Easyb for BDD flavored acceptance tests
• developer testing using JUnit 4, TestNG, Instinct, Spock and GMock
• writing domain specific testing languages (testing DSLs)
• testing web applications with WebTest, Tellurium, Selenium and WebDriver
• testing RESTful and SOAP flavored web services
• testing databases with DbUnit
• testing rich clients and GUIs with FEST
• performance testing with JMeter
• leveraging AllPairs, All combinations and other testing techniques
• model driven testing

Agile Developer Practices for Dynamic Languages

Full Paper

Developer practices for traditional and Agile Java development are well understood and documented. But dynamic languages (Groovy, Ruby, and others) change the ground rules. Many of the common practices, refactoring techniques, and design patterns we have been taught either no longer apply or should be applied differently and some new techniques also come into play. In this talk, we'll relearn how to do Agile development with dynamic languages.

• What Java practices should you "unlearn"!
• Myths and truths about dynamic typing
• Interface-oriented style versus duck-typing vs chicken-typing
• Better patterns: Adapter, Builder, Delegation, Visitor, Strategy, Singleton, Immutable, Factories, Proxies and more
• Refactoring your Refactoring and Closure refactoring
• Applying functional style with closures and currying
• Pondering the relevance of the open-closed principle
• Do you need dependency injection when you have a MOP?
• Examining the need for mocking and testing frameworks
• Dealing with Feature Interaction
• Practices to consider when writing DSLs

Writing Domain Specific Languages (DSLs) using Groovy

Full Paper (rtf)

Understanding the domain within which customers live and evolve is a key factor in the success of a project. From this domain and its wealth of concepts, as software developers and architects, we can derive a design that is aimed at solving problems encountered in the day-to-day business. Unfortunately, the statements which make most sense to the customer are seldom the ones which make most sense to your favorite Intel or competing processor. Much of Computer Science has been devoted to building languages further advanced than our original assembly languages. From COBOL to Object-Oriented languages, from Logic processing languages and SQL to rules engines. All have taken us forward in leaps and bounds but have failed to get very close to the language of the subject matter expert. This talk examines whether dynamic language in general and Groovy in practicular take us even further towards this goal.

With the advent of dynamic languages, a new era has come to let you create languages taylored to a given domain of knowledge, allowing you to share a common methaphore of understanding between developers and subject matter experts.

Groovy, the popular and successful dynamic language for the JVM, offers a lot of features that allow you to create embedded Domain-Specific Languages. Closures, compile-time and run-time metaprogramming, operator overloading, named arguments, a more concise and expressive syntax, are elements of Groovy you can take advantage of to create your own mini derived language. We also look at the promise of parser combinators to enhance DSL creation even further.

The purpose of this presentation is to show how to write such DSLs in Groovy, discovering in turn those various techniques, with practical and concrete examples taken from real-life projects leveraging Groovy DSLs.