Groovy, Grails, Griffon @ ESDC 2010

In just a few weeks (March 1-3) the first edition of ESDC will take place in San Mateo, California. ESDC is a brand new conference that offers more than 70 workshops and technical classes. There are plenty of topics to choose from. Groovy, Grails and Griffon are no exception. A list of Groovy related workshops and classes follows.

Groovy Tutorial – Scripting on the JVM - Paul King

Groovy is a dynamic language for the JVM; it’s like a super version of Java. For Java programmers, it offers a syntax that closely resembles (in some cases exactly resembles) Java, but offers many improvements that not only greatly simplify code but also provide an enriched environment with many productivity features. In many cases, such features are promised in Java versions 7, 8 or up, but they are available today in Groovy.

For non-Java programmers, Groovy provides a great entry point to the JVM. It allows code to be written which harnesses many of JVM features without the large learning curve associated with learning all of Java. Groovy’s mix of language design choices and features make it suitable for everything from small scripting tasks through to large complex software systems with stringent Agile quality requirements.

The tutorial will introduce attendees to Groovy, cover writing their first programs, run through a whirlwind tour of the basic language features, including data types, regex handling, XML processing, databases, graphics, file processing, build tasks, using Closures, testing and more.

The tutorial will also talk about the pros and cons of using Groovy, available tool support, great ways to introduce Groovy intro your project, what practices may change if you adopt Groovy, and briefly compare Groovy with other JVM languages.

Prerequisites: This is an introductory workshop. It assumes that attendees have some programming experience but requires no in-depth Java experience. It is suitable for Java programmers wanting to increase their productivity by using a dynamic language or for non-Java developers such as PHP or .NET developers wanting to leverage the JVM without the burden of learning all of Java.

Groovy Power Features - Paul King

Groovy is a dynamic language for the JVM; it’s like a super version of Java. For Java programmers, it offers a syntax that closely resembles (in some cases exactly resembles) Java, but offers many improvements that not only greatly simplify code but also provide an enriched environment with many productivity features. In many cases, such features are promised in Java versions 7 and later, but they are available today in Groovy.

Some of the power features of Groovy you’ll learn about are:

• Leveraging Groovy’s features to write DSLs
• Writing Web Service servers and clients in a few lines of code
• Replacing Design Patterns with language features and/or libraries
• Talking to the Polyglot world from Groovy: Scala, Clojure, Jython, JRuby, JavaScript and Jaskell
• Harnessing constraint/logic and functional programming
• Simple but powerful tests
• Simplify how you write build tasks
• Accessing Hibernate through GORM
• Harnessing parallel processing
• Leveraging Spring and OSGi

Prerequisites: This is an intermediate to advanced tutorial. It assumes that attendees have some previous exposure to Groovy or are accomplished at Java. Alternatively, you can take the Groovy Tutorial.

Make Your Builds More Groovy - Paul King

The bane of many developers' lives is their build scripts. They find them hard to write, hard to understand later, and each project seems to do things in vastly different ways and they take forever to run—if they successfully run at all. This class looks at the available technologies to ease the burden of writing build files with a particular focus on technologies that support the Groovy programming language. We’ll cover:

The “build your own” approach, including process and parallelization features using Ant from Groovy; using Groovy from Ant; using Ivy; using Gant; using Maven and GMaven; using Graven; using Gradle; continuous integration server hooks; and deployment management.

While these options leverage the Groovy language, they are by no means solely for building projects that make heavy use of Groovy directly. All of these technologies are very much applicable to Java only as well as polyglot projects. A brief look at non-Groovy alternatives will also be covered.

As we discuss each technology (some would argue that some of the options we have for writing builds actually can make our lives worse!), we’ll try to look at the pros and cons and best practices.

Groovy from the Trenches - Andrew Glover

Groovy has been successfully leveraged at various companies around the world in order to build enterprise applications on the Java platform quickly. In particular, Groovy has proved its value at a large financial services client on more than one occasion to build mission critical applications in short order, all while leveraging their existing investment in the Java platform from developer tools all they way to data center management.

From exposing legacy data models via RESTful Web services, to mission-critical reporting applications built with GroovySQL and Spring, to Groovy's core language features and much, much more, I'll show you tips and tricks that separate Groovy from the pack and expose how one can quickly build real world applications that meet a business's needs quickly with fewer lines of code.

Make the Most of your Testing Time in the Java Virtual Machine - Andres Almiray

The Java platform ecosystem harbors many languages besides Java. In that vast set of languages there is one that has received the title of “Next-Generation Java,” but not because it dismisses Java, not at all! It is because it embraces the language and extends it in a friendly and fluent way. That language is Groovy. Testing Java code can be cumbersome, especially when rigid limits as verbose syntax and static typing get in the way. Groovy can help you write less code while retaining the same behavior. It can also test your Java production code without any special bridge between languages. Groovy integrates seamlessly with all Java libraries, testing frameworks and IDEs, which means you won’t be throwing away your Java knowledge, you’ll just make it groovier. You’ll learn how to use Groovy to aid Java tests in key areas as code verbosity, mocking, XML production/consumption, and behavior-driven development.

Prerequisites: Attendees should have good knowledge of the Java language and common testing frameworks like JUnit and TestNG, and be proficient in one of the major Java IDEs (IDEA, NetBeans, Eclipse), as well in Apache Ant or Maven. Laptops loaded with the latest stable groovy distribution can be found at groovy.codehaus.org/Download

Make Your Tests More Groovy - Paul King

Testing can be a complex and thankless task. The technologies change so fast that your tools don't work as they should or you have to write lots of low-level boilerplate code that is obsolete almost as soon as it's written. Your tests are brittle and hard to relate to customer requirements. You aren't even sure that you are testing the right things. Let's explore some techniques and tools for easing some of these burdens and try to move testing from tedious and hard to easier and fun!

In this class, you’ll sample a flavor of many techniques and tools, and cover 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
• Model-driven testing

Many of the examples will use the Groovy language, but the lessons apply to Ruby, .NET, and other languages and scenarios.

Easy BDD with Groovy - Andrew Glover

The Manifesto for Agile Software Development essentially focuses on meeting customer needs through reducing wasteful activities. For example, Agile developmental practices push for reducing repetitive documentation and for a rapid acceptance of change. Yet, achieving these goals is by no means easy. While a process can enable increased collaboration, for instance, there are various tools that can effectively implement Agile principles.

Once such tool is easyb (www.easyb.org), which is a Groovy-based domain specific language, which facilitates collaboration by bridging those that define requirements (i.e. customers) and those who turn requirements into code (i.e. development). With easyb, collaborative teams can develop stories in a specific format, which are then implemented as tests through a framework that marries the underlying application. This test suite enables change and produces accordance among Agile teams in short order.

In this talk, you will learn how to embrace collaboration and change rapidly by defining easyb stories that exercise a Java application end to end. You will learn how to define specific easyb structures, how to plug them into real code, and how to run them in an automated fashion. You will see first hand how non-coders can define tests easily and how the collaboration this brings yields working software faster.

Building Desktop Applications with Griffon (Part 1 & 2) - Andres Almiray

Building a desktop application is a hard task; there are so many things to keep track of that many projects simply fail to meet their goals. Setting up the project structure, keeping each artifact in a well-identified location given its responsibility and type, defining the base schema for managing the application's life cycle, making sure the build is properly set up, and more. These are recurring tasks that should be handled by a tool or, better yet, a framework. Griffon is such a framework. Inspired by the Grails framework, Griffon aims to bring the same productivity gains to desktop development. There are so many traits shared by both frameworks that a Grails developer should be able to pick up the pace fairly quickly.

Prerequisites: Attendees should have good knowledge of the Java language and Java Swing. Laptops loaded with the latest stable Griffon distribution found at griffon.codehaus.org/Download.

Construction Techniques for Domain Specific Languages - Neal Ford

Domain-specific languages have been the Next Big Thing for years now, but they have quietly started penetrating the development world. This talk covers language techniques in Java, Groovy and Ruby on how and why to create DSLs. This class starts by motivating you to convert APIs into DSLs, and various patterns, anti-patterns, and best practices for how to achieve the optimum effect. You’ll also learn about the very important topic of implicit context, and how language constructs can allow you to write less verbose and more expressive code.

RESTing Easy With Grails - Andrew Glover

Representational state transfer (REST) is a way of thinking, not a protocol or standard. It's a style of designing loosely coupled applications that rely on named resources (in the form of URLs, URIs and URNs, for instance) rather than messages. Ingeniously, REST piggybacks on the already validated and successful infrastructure of the Web: HTTP. That is, REST leverages aspects of the HTTP protocol such as GET and POST requests, which map standard business-application needs, such as create, read, update and delete (CRUD). By associating requests, which act like verbs, with resources, which act like nouns, you end up with a logical expression of behavior (GET this document and DELETE that record, for example).

In this class, you will learn about the mechanism for creating RESTful applications with Groovy’s Grails, which gives you the ability to apply RESTful techniques with a full-fledged Web application framework that supports an ORM and testing to boot! As you will learn, using Groovy's Grails framework makes building RESTful Web services a snap.