Groovy is an agile dynamic language for the Java platform. The language and its libraries bring many things to the table to ease the process of building applications for the Java platform. This session provides a detailed run through Groovy with lots of code samples to drive home the power of the language.

What is the Griffon Framework? And how would I use it? This session will help those who may not have been following the Griffon framework understand what it is and see how it works.

Building a desktop application is a hard task, there are some many things to keep track of that many projects simply fail to meet their goals. Setting up the project structure keeping each artifact on a well identified location given its responsibility and type, defining the base schema for managing the application's lif ecycle, making sure the build is properly setup, 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 quick.

The Rails tenets are great, for web based applications. But how do the values hold up when applied to Desktop and Rich Internet Applications?

Testing a desktop application, an often neglected task left to the last possible moment if it is not entirely scrapped from the schedule, the QA team should be able to handle the load, ain't that right? with Griffon there are no more excuses, there is an easier way to make ends meet when testing a desktop application. Griffon will help you keep an eye on your application's green bar from the get go, it also comes with a full arsenal of plugins that make this task even more enjoyable and rewarding.

The Spring Security (Acegi) plugin for Grails has gotten a bad rap. Earlier versions of the plugin and the Acegi framework were somewhat cumbersome to use but new features in Spring Security 2.0 and lots of enhancements and features in the Grails plugin have made securing your Grails apps easy.

Everyone knows that Grails provides a fantastic MVC framework for building web applications. What many developers do not realize is that Grails provides a truly powerful and flexible application platform that may be used to build applications that do not have a browser front end at all.

"Tests don't break things; they dispel the illusion that it works." (Anonymous)

In this era of "Test-First" and "Test-Driven" development, the modern software engineer knows that testing is no longer an optional part of the process. You need to have the best tools at your fingertips: a set of utilities that maximize your results with a minimum of effort. Groovy offers Java developers an optimal set of testing tools.

OSGi, Jigsaw, modularity, service lifecycles, bundles... where do you start? This talk covers the basics of using OSGi and Groovy together.

Ever since Grails came out a few years ago it has grown in excitement and expectations. Grails allows an easy ability for developers to create applications in a faster pace. For Java developers it was even more exceptional because they were able to leverage technologies most were already familiar with, Hibernate and Spring. Especially interesting was the use of Grails Object Relational Mapping (GORM), GORM is the database persistence layer behind GRAILS. This allows for creating dynamic queries that are easily readable like "User.findByFirstAndLast(..)", which will generate a query to find by the columns first and last. Using queries like this makes it very quick and easy to create queries, especially with criteria queries. So what's the downside? We HAVE to use Grails. For some newer apps this may not be an issue. But a legacy application or an organization that does not want to jump down the dynamic path THAT fast it can be an issue. Well no more, with Grails 1.1 the ability to use GORM with a regular spring application is now realized.

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 boiler-plate 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!

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 which marries the underlying application. This test suite enables change and produces accordance among Agile teams in short order.

The Amazon Elastic Compute Cloud (EC2) is probably the best known web service from Amazon but it’s not the only one. There are other highly scalable and reliable web services that you can use in your Grails applications including the Simple Storage Service (S3), Simple Queuing Service (SQS) and SimpleDB, a non-relational database. Although, using these web services couples your application to Amazon, they let you build highly scalable applications without the pain and cost of having to develop your own infrastructure.

You've heard about how easy it is to build web apps with Grails. Maybe you've even seen the simple CRUD app in a blink of an eye, but do you want to see what Grails is really capable of? Then join us as we walk through the construction of a real web application with this powerful framework. Along the way we'll see how to take advantage of Grails' features like GORM, service classes, custom tags, and URL mapping.

Groovy provides excellent facilities for parsing and creating XML. As well as providing syntactic sugar on top of traditional Java-based parsing approaches (e.g. SAX, DOM, StAX), it has its own XmlParser and XmlSlurper libraries which support XPath-like expressions at the object level (akin to LINQ in the .Net world). In addition, Groovy's markup builders provide an elegant and efficient way to create and modify XML. Groovy also has various options available for SOAP and RESTful web services. We'll examine the most popular of these.

TBD

The next major version of the Groovy Eclipse Plugin is built on a new builder technology, where the Eclipse JDT Compiler has been extended to seamlessly integrate groovy compilation.

Grails is a powerful server-side web framework based on the Model/View/Controller (MVC) design principle. Flex is a popular Rich Internet Application (RIA) framework for building client-side applications.

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.

Metaprogramming and AOP is built into the language. In this presentation you will deep dive into the metaprogramming features of Groovy. You will learn the pros and cons of different features and when to use which. You can learn how to perform code injection and code synthesis.

One of the best ways to introduce Groovy to new projects and teams is to use it for Unit testing Java code. Using Groovy to unit test Java codehas several advantages. You can take advantage of its concise syntax for writing tests. Groovy's dynamic and metaprogramming capabilities can be exploited for mocking purposes.

Grails is more than just a web framework, it is a complete platform and API for runtime configuration. This talk, by Grails project lead Graeme Rocher, will demonstrate Grails' modular architecture and how to hook into runtime configuration to adapt your application based on its environment and/or the presence of other plug-ins.

The talk will start with an overview of the Grails architecture and then jump into an extended example of how to write your own plug-in. As part of the journey you'll learn how to customize the Grails build system, participate in runtime Spring configuration, add new persistence methods that work with Hibernate and enhance your existing classes through Grails' advanced Groovy Meta-programming system.

Part II of the Grails Plug-in System will pick up where Part I left off.

Gradle allows you to describe your build using a rich, easily extendable build language based on Groovy. It provides compelling solutions for many of the big pain points that exist with current build systems. This session will be mostly driven by live demos. You will see how easy and elegant Gradle enables you to solve a broad range of requirements - over the full life cycle of typical and atypical Java builds.

The project automation requirements of complex enterprise builds are the true stress test for any build system. Gradle has a special focus on enterprise builds. In this session we will talk about and demo on: Multi-project builds, incremental builds, parallel testing, dependency management and concluding with organizing build logic, custom plugins and custom tasks.

You've used GORM in Grails apps, you've written custom criteria and HQL queries, and now you're ready to take database access in Grails to the next level.

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.

In this presentation you will learn about Groovy's relatively new capability to provided Abstract Syntax Tree transformations. This powerful features can help you implement Domain-Specific Languages, extend the language in a reasonable fashion, and provide compile time metaprogramming capabilities.

Understanding the domain within which customers 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.

So far, we mostly solved these brainteasers with computer science paradigms like Object-Oriented Programming, n-tier architectures, or with tools such as rules engines to stay close to the domain at hand. However, 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, 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.

Thinking about writing Groovy unit tests for your legacy Java code? This session is an honest discussion about what Groovy will gain youand what it won't.

This presentation will introduce AJAX in Grails through the GrailsUI plugin. We'll start with the core concepts behind the plugin and give examples of the most widely used and interesting widgets GrailsUI provides.

For many, learning Groovy made you think differently about Java. Now it's time to think differently about Groovy. Although Groovy is not a functional language by many measures, it does support many of the common functional idioms and patterns. Come explore both how far functional programming can be pushed in Groovy, where functional programming can't currently go, and where functional programming is headed in future releases of both the language and the JVM.

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 GParallelizer, as well as map reduce, grid and cloud computing frameworks. We'll look at leveraging Java techniques as well as Groovy specific approaches.

After developing Grails applications full-time for over a year, I've learned some useful tips, tricks, and common patterns. In this presentation, I'll share with you real world examples of how I've used Grails "In the Wild".

'A language should have access to its own abstract syntax' John McCarthy, Father of Lisp. Well, now Groovy 1.6 does! This talk is about why AST transformations are important, what you can do with them, and where the language world is headed. We'll dive into some of the useful Groovy annotations and libraries being written that harness AST transformations, see how to write our own, and work with the AST tools coming out with the next version.

You've used Groovy to quickly hack together some short scripts or a simple Grails app. Now you want to treat it more seriously and apply best practices and tools. For Java you'd look at style and coverage checkers, JavaDoc, dependency injection, mocking, testing and build frameworks. For Groovy you have EasyB, Cobertura, CodeNarc, Simian, GroovyDoc, Hudson, Ant, Maven, Gant, Gradle, Spring, Guice, Spock, GMock and more. The talk is packed full of tips and examples for these and other tools.

There are many features provided by The Grails Framework which at first appear to be black magic. Where does the 'log' property come from? How do GORM dynamic finders really work? How can I add similar properties and behavior to classes at runtime? All of these questions will be answered during this session.

Grails brings together the best of breed frameworks on the JVM that allows for a quick time to market rollout of a project. As important as time to market and quality is there is still one thing that requires and demands some time and attention: Security! There is a growing threat with 75% of todays hacking attempts attacking the web tier.

Regardless of the language used, if you are deploying to the JVM it is important to know some of the JVM internals. This session will provide significant details of how heap is divided along with the function of each component. We'll explore how dynamic languages put added gc pressures on the JVM and what to do about it.

The Grails web application is an innovative hybrid of best-of-breed Java technologies and dynamic/convention-based development. The result is a powerful, flexible, exciting framework that still fits comfortably into enterprise stacks.

The Yahoo Performance Team has made a ton of great UI performance tuning information available, both online and in two books, "High Performance Web Sites" and the recently released followup "Even Faster Web Sites".

For years, the venerable Hibernate object-relational mapping framework has dominated the persistence scene in Java. The Grails web application framework extended Hibernate and Spring with their impressive GORM persistence framework, providing convention-over-configuration development to the O/RM and DAO layers.

This presentation will go over how to use Spring Web Flow in Grails to make easy to use page flow based applications.

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 quite nicely to 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.

The Spring Framework is the most comprehensive and most powerful application platform ever built on top of The Java Platform. Spring is the de facto standard platform for building enterprise Java applications. Groovy has always integrated very well with Spring. Spring is an absolutely integral component that supports much of the power, flexibility and ease of development offered by Grails.

There are many things you can do with runtime metaprogramming in Groovy and a number of ways to do them. By building web applications with Grails, you are already using metaprogramming behind the scenes. But it's not always clear why and when you should use metaprogramming techniques in a Grails project.

Aspect-Oriented programming has grown and fallen in popularity, but it has been a buzz word for quite a while. Outside of security and logging, however, it can be difficult to find a realistic scenario where AOP makes sense, so examples can be hard to come by. With the Grails Circuit Breaker Plugin (http://grails.org/plugin/circuit-breaker), I found a real-life scenario where AOP is a perfect fit.

How is your lone web server going to handle all the traffic you'll get when it lands on Slashdot or the front page of Digg? Probably not well. To prepare for all of this popularity you're going to need multiple servers, but there's more to it than buying hardware.

In this Jeopardy style presentation the audience will participate in exploring various topics in Groovy. Some prior knowledge of Groovy is assumed in this session.

As a small company, it's often necessary to add new features to get the biggest customers to buy your product. Hyperic HQ was a large, enterprise application based on J2EE and Struts. When big clients came to us they frequently required feature additions to close the deal. Groovy gave us the power to say YES to these customers without making any invasive modifications to our code base, allowed us to scale up for extremely large customers, and gave us a new point of contact for community contributions.

One of the most compelling features of Grails is it's custom tag libraries. Yet many developers, especially those coming from a JSP or JSF background, run from the room screaming when someone suggests creating a custom tag. Grails custom tag libraries are a powerful way to encapsulate business logic and keep code out of our pages. They are also great for declaring intent and making pages more readable. But here's the best part... they are ridiculously easy to create.

You're most likely familiar with the Gang-of-four design patterns and how to implement them in Java. However, you wouldn't want to implement those patterns in a similar way in Groovy. Furthermore, there are a number of other useful patterns that you can apply in Java and Groovy. In this presentation we'll look at two things: How to use patterns in Groovy and beyond Gang-of-four patterns in Groovy and Java.