2GX - Groovy / Grails - Schedule

By Ben Alex
Spring Roo is SpringSource's new open source technology which features an pragmatic focus, aimed squarely at making the life of mainstream enterprise developers more productive and pleasant without sacrificing engineering integrity or flexibility. Whether you're a new Java developer or a seasoned architect, Roo offers a serious productivity boost that delivers fully-fledged working applications in a matter of minutes. Whilst Roo fully supports existing server-centric web frameworks, it is particularly optimised for Generation IV web technologies such as GWT and Flex. So not only are your applications delivered with sustainably increased productivity, but your applications can easily incorporate the enhanced usability and performance of single page applications. All without a single line of JavaScript or
HTML in sight.


Spring ROO is radically different from other convention over configuration frameworks in other ways, too. You won't have to learn a new language or unlearn what you already know. You won't have to ponder what latest scripting language or text editor you are expected to use instead of Java and an IDE. You won't be expected to blatantly banish engineering principles like OO, DDD, language features and performance. You won't need to delete your existing project and start over, just for the privilege of a limited productivity spike.

In this presentation, Ben Alex will introduce Spring Roo. Ben will cover topics such as:
- What is Roo
- Getting started with Roo
- Building a new enterprise application in under 15 minutes
- Exposing a web front-end quickly, easily and flexibly
- Roo metadata and internals
- Reviewing the Roo roadmap and release schedule
- How to provide feedback and become involved

Attendees who invest their time in this session will leave with a comprehensive understanding of what Roo is and its basic operation. We look forward to introducing this exciting new member of the Spring portfolio to you.

By Andres Almiray
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.

Come see how a restful desktop application can be be boostrapped in literally minutes thanks to the power of well thought conventions and a good deal of Groovy elbow grease. Welcome to the Griffon revolution.

By Andres Almiray
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.



In this session we will sample each and every one of Griffon's testing plugins, like Easyb and FEST to name a few.

By Burt Beckwith
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".



The Grails UI-Performance plugin implements many of these best practices, including compressing and minifying static and dynamic content, aggressive caching, bundling files, creating image sprites and more. We'll look at the wrong way to send content to your users' browsers and the right way, and use YSlow to measure the improvements along the way. Your users will appreciate the zippier response times, and you'll appreciate the decreased server load.

By Burt Beckwith
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.



In this talk we'll look at improving performance of Grails apps by avoiding mapped collections, strategies for second-level caching using EhCache, runtime monitoring and graphing, and using a custom Configuration subclass to customize your Hibernate config beyond what GORM mappings provide.

By Burt Beckwith
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.


This talk will demonstrate getting started with the Spring Security plugin and also show how easy it is to add Basic Authentication, LDAP, and even OpenID and Facebook authentication to an application. We'll also look at the various configuration options and extension points for when you need to customize beyond the standard configuration.

By Burt Beckwith
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 talk we'll look at implementing Tomcat's HTTP Session clustering, distributed second-level Hibernate caching using EhCache, and using the JDBC store feature of Quartz so your servers can handle the load while maintaining consistent data.

By Jeff Brown
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.



Dynamic languages provide a lot of power and flexibility compared to statically typed
languages. Groovy brings that power and flexibility to the Java platform in a way that
is totally compatible with all of your existing Java code, tools and infrastructure. This
session covers all of the fundamentals of Groovy and gives developers a whole lot of
practical information they need to get started with the language.

By Jeff Brown
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.


This session is for Grails developers who want to accelerate their Grails Kung-Fu to the next level and
really take advantage of the power and flexibility that Grails has to offer.

By Jeff Brown
TBD

TBD

By Jeff Brown
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.




In this session we will discuss Grails as an application platform. The lecture and demonstrations will focus on using Grails to build the service layer of a layered application architecture. The Grails service layer may be accessed from a wide array of technologies including Swing applications, .NET applications, other Grails applications and much more. Building a service layer for The Java Platform has never been easier.

By Andy Clement
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.

During this session Andy will cover how this was done and what it means for a Groovy developer in Eclipse - particularly when mixing Java and Groovy in the same project. He will look at the new incremental compilation behaviour it enables and what other features of the Eclipse UI 'just work' because of the approach taken. Finally the session will touch on exploitation of this builder technology outside of eclipse for batch/Ant compilation.

By Hamlet D'Arcy
'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.



At the end we'll prognosticate about the future of programming languages in general, and hypothesize about where the Groovy features fit into the history of languages. Fun!

By Hamlet D'Arcy
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.

Learn about morphisms, option types, tail call optimization, pattern matching, and functional composition in the context of solving classic CS problems side-by-side with a more traditional functional language, and decide for yourself how terms like elegance and simplicity should drive your coding. This is not meant to be an intro to functional programming but no prior experience is required.

By Hamlet D'Arcy
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.

Come learn the engineering practices and tools that you can use to battle tight coupling, monolithic projects, and tangled dependencies, and then decide for yourself whether Groovy is the answer for your project. Plan on returning to work with a vision of what your team can do to write better software.

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

You'll be introduced to the OSGi framework by building a Groovy based
application that introduces the core concepts of OSGi such as themodule system, service registry, and service life cycles. We'll also cover common pifalls encountered by mixing Groovy and OSGi, as well
the latest OSGi tools available.

By Scott Davis
"The proof of the pudding is in the eating. By a small sample we may judge of the whole piece." (Miguel de Cervantes Saavedra)

Most Grails tutorials demonstrate how easy it is to build simple CRUD (Create/Retrieve/Update/Delete) applications. While skinning a database with a web front-end is undeniably one beneficial aspect of Grails, it isn't the only thing Grails is good for. As you'll see here, Grails can be used to build a wide variety of web applications. You won't see a single HTML table with "edit" and "delete" links, I promise.

In this talk, we look at a variety of Grails applications that go beyond the simple CRUD metaphor -- blogs, wikis, maps, portals, and more.

By Scott Davis
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.


Come see how these two best-of-breed frameworks work together.

By Scott Davis
"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.

In this talk, we use EasyB to gather user stories as executable documentation. We look at GroovyTestCases -- a drop-in replacement for JUnit TestCases that expand the pool of helpful assertions. We'll explore mocking and stubbing with Groovy. And we'll finally go public with Groovy's privacy "issues".

By Hans Dockter
Gradle is a Groovy based build system which makes use of this new possibilities. It combines the flexibility of Ant with a build-by-convention approach a la Maven. But both implemented in a more powerful and less restrictive way. This talk will be mostly driven by live demos. We introduce Gradle with a simple hello world build and then work with a plain Java and a Java Web project. From there we go to a more complex multi-project build. During those live sessions we will discuss most of the major Gradle features, like dependency management, Ant integration and much more. We will learn about Gradle's rich domain model which provides a true build language. Thus offering the abstractions missing with Ant without the restrictions and obstacles of a framework.

During those live sessions we will discuss most of the major Gradle features, like dependency management, Ant integration and much more. We will learn about Gradle's rich domain model which provides a true build language. Thus offering the abstractions missing with Ant without the restrictions and obstacles of a framework.

By Hans Dockter
Gradle is a Groovy based build system which makes use of this new possibilities. It combines the flexibility of Ant with a build-by-convention approach a la Maven. But both implemented in a more powerful and less restrictive way. This talk will be mostly driven by live demos. We introduce Gradle with a simple hello world build and then work with a plain Java and a Java Web project. From there we go to a more complex multi-project build.

During those live sessions we will discuss most of the major Gradle features, like dependency management, Ant integration and much more. We will learn about Gradle's rich domain model which provides a true build language. Thus offering the abstractions missing with Ant without the restrictions and obstacles of a framework.

By Keith Donald
Spring offers several interesting modules for building and running rich web applications: Spring MVC, Spring Web Flow, Spring JavaScript, and Spring Faces. This session will provide an overview of these modules and show how they relate to one another. Attendees will see how Spring simplifies the development and deployment of rich web applications on containers like Tomcat, as well as on Spring's new application server. Attendees will also gain insight into the Spring 3.0 roadmap, including exciting new REST, JSON, and Flex support.

Spring Web MVC is a popular web framework, and the foundational platform for powering Spring-based web applications. Version 2.5 introduces major new features that simplify the core MVC programming model, including support for annotated @Controllers and convention-over-configuration. This session shows how to apply these new features to gain development productivity and implementation consistency.

Building on the Spring MVC platform are a number of interesting modules. Spring Web Flow 2 adds significant power for implementing flows within a Spring MVC-based app. Spring Faces, a new module, provides support for JavaServerFaces in a familiar Spring MVC environment. And last but not last least, Spring Javascript, a new module, integrates leading UI toolkits such as Dojo into a Spring MVC environment for applying progressive enhancement techniques with Ajax. This session provides an update on these technologies, shows how to put these technologies into practice, and addresses what's coming in Spring Web 3.0. It is an overview session and sets the foundation for the rich web track at SpringOne 2008.

By Christian Dupuis
SpringSource Tool Suite (STS) provides the best Eclipse-powered development environment for building Spring-powered enterprise applications. STS combines Spring IDE and Eclipse Mylyn to significantly streamline the development process and help making SpringSource best-practice knowledge and recommendations available to developers at their fingertips while working in their IDE. This session will cover the latest features that have been added for STS including Spring Roo support, cloud development tools, virtualization integration and updates for Spring projects.

Detail

By Danno Ferrin
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.


We will start from square one by installing Griffon and build a simple application from scratch. In addition to basics such as file structures, SwingBuilder view scripts, and data binding we will cover intermediate features such as multiple MVC Groups, plugins, and addons. This will be primarily a live coding session. The slides will serve as a guide and as a reminder to the session attendees.

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


In 2004 the web development world was reshaped by a little framework named Rails. What is most notable about Rails was not the technical details of the framework, but the core values that drove these technical decisions. These values have evolved over the years and are now known as the Rails Tenets. How do these values hold when taken to the desktop and Rich Internet applications?

It turns out most of these tenets work very well in a rich application setting, and only two (Fat Model/Skinny Controller and Use REST Interfaces) need alteration (Pervasive MVC and Use Data Binding respectively). This presentation will go over all the values and show how the Griffon framework applies them.

By Robert Fischer
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. T

This session will introduce GORM and work up to some of its intermediate features.

By Robert Fischer
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.

This session introduces Grails, but approaches it from the perspective of an enterprise web development stack, in order to see how Grails works well in mid-size and mature development shops.

By Mark Fisher
Coming Soon

Session Detail

By Adam Fitzgerald
This session covers the basic concepts used for systems and application monitoring and management and provides a guided introduction to Hyperic HQ. Topics include: agent based architectures, data collection, metric definition & correlation, management operations, control actions and alerts. (Level: Beginner)


Session Detail

By Adam Fitzgerald
TBD

TBD

By Adam Fitzgerald
The performance of web architectures vary greatly depending on load, implementation, business function and usage models. This session describes the five critical metrics that are common to all web architectures that operations teams should manage. Understanding these five metrics helps to partition systems and provides faster root cause analysis of when addressing performance problems.


Session Detail

By Adam Fitzgerald
HQU is a plugin framework for Hyperic HQ which allows custom UI to be inserted into, and interact with various aspects of Hyperic HQ. All HQU plugins have the ability to interact with the entire HQ backend, and come with an API which allows for fast development. This session covers the basic HQU plugin architecture, describes how to get started building custom plugins with Groovy and provides practical examples of what is possible for customization.

Session Detail

By Adam Fitzgerald
Improving response time to operational problems is critical to your IT management team. You can use Hyperic HQ control actions to streamline day-to-day operations, reduce the risk of human error or oversight, and respond rapidly when remote control is necessary. This session gives a practical overview of the control system in Hyperic HQ, how to extend it with User-Defined Control Actions and how to tie these controls to the alerting system.


Session Detail

By Adam Fitzgerald
Public cloud based services are becoming an increasingly popular deployment choice for IT operations teams looking to reduce total hosting costs and scale systems on demand. But how reliable and responsive are they? The developers behind CloudStatus.com describe how they used Hyperic to monitor cloud services from Amazon Web Services and Google App Engine and report on the collected performance and availability data.


Session Detail

By Adam Fitzgerald
Systems and application monitoring provides massive amounts of data critical for operations team to understand the performance of their web infrastructure. However, this data is often incomprehensible to business owners looking to tie application metrics to business goals. This session describes how to effectively translate operational data into metrics that the business cares about and uses practical examples from Hyperic IQ.


Session Detail

By 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 which 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.

By 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 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.


To quote Leonardo da Vinci, "simplicity is the ultimate sophistication." REST embodies this thought and thus yields highly scalable, loosely coupled systems that, as it turns out, are simple to build. There are a few mechanisms for implementing RESTful applications-- Restlets and JSR 311 are two in a handful of options; however, they address one aspect of RESTful applications and ignore other aspects like an ORM and testing. Groovy's Grails 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 see, using Groovy's Grails framework makes building RESTful Web services a snap.

By 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 proven 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.

By Jeremy Grelle
Flex offers several ways to communicate remotely from the client to a back-end system, but it is ultimately agnostic to the technology being used on the server. Connecting a Flex front end to a Spring-based service layer has long been possible, but it hasn't always been easy or obvious how to do so without a heavy investment in proprietary technology. Come to this session to see how to take advantage of the recently open-sourced BlazeDS project from Adobe to make connecting Flex to Spring easier and more natural.

This session will walk through several approaches to communication between Flex and Spring, including:

- Exporting Spring beans for direct remoting

- Creating and consuming RESTful Spring resources

- Creating and consuming SOAP based Spring web services.

Each approach will be examined in detail, with a comparison of the pros and cons of each technique so that attendees may make an informed decision when choosing the approach to use in their own rich applications.

By Paul King
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.


We'll cover:
* Reading, creating and updating XML using various approaches including the pros and cons of the various parsers and markup builders
* dealing with XML namespaces and XPath
* using other XML frameworks: XOM, Dom4j, JDom
* integrating with XSLT, XQuery and validators
* treating non-XML like XML
* GroovySOAP, GroovyWS and Spring web services
* JAXB, XmlBeans, CXF and Axis2 for SOAP web services
* XML-RPC and RESTful options, RSS, ATOM
* trade-offs using Apache Xerces or with native XML support on 1.4 through to 1.7 JVMs
* Testing Web services with SoapUI
* A quick look at Groovy integration in common XML/web-service tools
* Groovy use in web service related products including ESBs and SOA frameworks

By Paul King
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.


We'll examine these tools:
* EasyB: for writing acceptance tests
* Cobertura: for checking code coverage
* CodeNarc: for checking code style
* Simian: for checking code duplication
* GroovyDoc: for writing documentation
* Hudson: for CI builds
* Maven/Ant/Gant/Gradle: for build files
* Spring/Guice: for dependency injection
* GroovyMock/Spock: for mocking and testing
* OSGi: for writing bundles

By Paul King
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

By Paul King
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.


* 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
* Actor/Dataflow libraries: Jetlang, GParallelizer
* Polyglot solutions with Scala and Clojure
* Grid computing and cloud solutions
* Testing multi-threaded programs

By 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 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!



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

By Dave Klein
It's amazing how quickly one can build web applications with Grails in a greenfield environment, but most of us do not have that luxury. We have existing infrastructure and applications that we have to maintain and extend. We have legacy databases (or legacy database administrators) to deal with. Does this mean we cannot benefit from the magic of Grails? No way! The ease of use and productivity of Grails is matched by its power and flexibility. In this session we will discuss some of the ways that Grails can be integrated with legacy databases, EJB servers, and even JSF applications. Java web developers in JEE shops will be kicking themselves if they miss this presentation.

Some of the strategies we will cover include: - Calling EJB session beans from a Grail application - Using Grails' ORM mapping to access legacy databases - Accessing JNDI resources from Grails - Using AJAX to call Grails' services from Java Server Faces

By Dave Klein
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.

We will have a brief tutorial on creating Grails custom tags and then build a few to demonstrate just how easy it can be to tap into this powerful feature.

By Guillaume LaForge
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.

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

By Costin Leau
Coming Soon

Session Detail

By Costin Leau
Coming Soon

Session Detail

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

TBD

By Joseph Nusairat
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.

In this presentation we will show how to use GORM in your normal day to day Spring app and how GORM will be able to cut down on development time and increase code cleanliness in your Spring application. We will cover how to use GORM and how to integrate GORM with a regular Java Spring app.

By Arjen Poutsma
With the Spring 3.0 release, we have introduced further annotation-based configuration options, unified expression language support and REST support. This talk discusses Spring as a modern Java 5 oriented application framework - covering the core component model, integration with common technologies such as JPA and JSF, as well as Spring's annotation-driven web MVC.


Session Detail

By Chris Richardson
TBD

TBD

By Thomas Risberg
Most database development can be helped by using available tools, as long as you know what to look for and where to look. We will look at some useful tools and see how they can be configured to help you run within a Spring development environment. We'll also dicuss ways to monitor database activity whether you are using an ORM tool or rely on your hand crafted JDBC statements. This is ctitical in order to tune your Spring application's persistence layer. The talk is rounded out by looking at a few JDBC puzzler's and some tips on how to improve the performance of your database code.


Session Detail

By Graeme Rocher
TBD

TBD

By Graeme Rocher
TBD

TBD

By Ken Sipe
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.




This session will look at OWASP's top ten list and provide code examples of what to look for during code reviews and how to fix sql injection and cross site scripting (XSS). We'll look at several of the grails security plugins and how to best leverage them to protect web application resources.

By Ken Sipe
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.

We'll end with details on how to debugging production jvm issues with VisualVM and BTrace.

By Matt Stine
St. Jude Children's Research Hospital's Shared Resource Management (SRM) system is a laboratory management system designed to support core facility activities. It was originally designed to support the laboratories in the Hartwell Center for Bioinformatics and Biotechnology (http://www.hartwellcenter.org) at St. Jude, and was implemented over the course of 3 years using a traditional J2EE stovepipe architecture leveraging EJB 2.0 and a "homegrown" web framework. Fast-forward five years to 2009, and you'll find SRM 2.0, a complete rewrite using Spring, Spring Web MVC, Spring DM, and SpringSource dm Server, nearing a production release after approximately six months of effort.

Topics covered will include:

A brief overview of the SRM domain and requirements.

The eight-year evolution of the SRM 1.x architecture and where traditional J2EE failed us.

The two key architectural concepts enabling rapid delivery of SRM 2.0.

How Spring Dynamic Modules and dm Server enabled:
- effective modularization of key vertical functionality
- separation of architectural concerns
- isolation of a high-risk entity-attribute-value data model extension
- an innovative plug-in architecture allowing functional extension of the system without disturbing core functional areas

By Venkat Subramaniam
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.

Attend this topic if you're familiar with Groovy and want to gain some in depth knowledge of the language.

By Venkat Subramaniam
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.

This session will quickly take you from an introduction of metaprogramming in Groovy to some advanced metaprogramming techniques.

By Venkat Subramaniam
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.



In this presentation, you will learn tips and techniques to use Groovy to unit test both your Java and your Groovy code.

By Venkat Subramaniam
This fast paced presentation is intended for experienced Java programmers. You will start by learning what Groovy is.

The presentation will quickly take you though several features in Groovy including typing, closures, working with strings and collections, Builders, interoperating with Java, and creating DSLs.

By Venkat Subramaniam
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.

In this example driven presentation, you will learn how to put this new capability to good use.

By Dave Syer
Batch processing always starts small and has a habit of getting large and complicated quite quickly. That's why being able to monitor and manage a Batch ecosystem and react automatically to common scenarios is an important concern for many. Come and see what features are available for managing a batch system implemented using Spring technologies.


Session Detail

By Matt Taylor
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".


It includes details of how to do useful things with the basic tools of Grails, some advanced tricks and patterns, and helpful general rules of thumb to use during Grails development.

By Matt Taylor
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.


Some examples will include methods of interacting with the widgets and handling events. We will also talk about how to provide proper JSON data to the widgets from the server.

By Mark Thomas
A default Apache Tomcat installation is secure but each installation environment is different and may have additional security requirements. This presentation will examine the security configuration options available in Apache Tomcat, when to use them (and when not to use them) and the threats they might help mitigate. The rationale behind having resource passwords (eg for database access) in clear text in server.xml will also be discussed.


Session Detail

By Mark Thomas
The range of choices for httpd module and tc Server connector means that there are many ways to configure tc Server as a reverse proxy with httpd. This presentation will explain the pros and cons of each of the options and provide attendees with information on the key configuration parameters for each. Common pitfalls will be discussed and suggestions provided for configuration options to avoid them.


Session Detail

By Mark Thomas
This session will start with an overview of the JVM memory structure and explain some common misconceptions regarding the standard memory related JVM configuration options. Each of the typical OufOfMemoryError failures will be demonstrated and the symptoms explained. Attenedees will also learn how to diagnose these failures. To complete the session, the key tc Server configuration parameters that impact on memory usage will be discussed.


Session Detail

By Scott Vlaminck
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.

This presentation would discuss why and when to use AOP and how to implement AOP in Grails. It would
finish with a discussion of the Circuit Breaker pattern and why AOP is a good fit for implementing the Grails plugin, which will help illuminate when AOP is the right technology to apply to a problem.

By Scott Vlaminck
There are many things you can do with runtime metaprogramming in Groovy and a number of ways to do them. In fact, by building web applications with Grails, you are already using metaprogramming behind the scenes. In fact, I used metaprogramming techniques in creating Sumatra (http://www.assembla.com/spaces/sumatra/wiki). Sumatra is a testing framework that allows easy-to-use JavaScript testing from Groovy unit test classes. I wrote an article that described using Sumatra for the April issue of GroovyMag (http://www.groovymag.com/main.issues.description/id=8/).



This presentation would describe what metaprogramming is, how to use it, and provide real-world examples.

By Craig Walls
In this session, we'll explore modular web application development using Spring-DM and OSGi. I'll dispel the myth that OSGi is hard and show you tips and tricks that make Spring-DM and OSGi development easy.

WAR files, the workhorse standard deployment unit for Java web applications, has been looking a little portly for a long time. Most WAR files contain not only servlets and JSPs, but are usually well-endowed with static content (such as CSS, JavaScript, and images), middle and backend support classes, and a WEB-INF/lib directory chock-full of third party libraries. Even simple web applications can carry around several megabytes worth of baggage.

Monolithic WAR files present some practical issues, including:
- Every WAR file carries its own copy of embedded libraries, increasing the footprint of each web application.
- Parallel development of application modules is hindered, as all modules ultimately are deployed as a single unit.
- Application modularity itself is not enforced, allowing for tight coupling between application layers.

The solution to monolithic WAR files is rather simple: Break them into smaller, more easily managed modules. OSGi makes this possible--Spring-DM makes it easy.

Come see how to apply Spring and OSGi to be able to split web applications into pieces that can be developed, tested, deployed, and managed independent of each other.