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

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.

This session presents a detailed technical discussion of many of the ways that these technologies all play well together. Topics will include:

Writing Spring Beans In Groovy

The Groovy Spring Bean Builder

Dependency Injection In Grails

Spring's Database Transaction Management In Grails

Spring MVC and Grails

Configuring The Spring Application Context To Add Whole New

-Capabilities To A Grails App

Spring Remoting In Grails

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 Pratik Patel

As with many technologies, the basics are easy. The hard part comes when the developer needs to do sophisticated integration, development, and testing as part of an enterprise application. A large enterprise application requires the developer to think of issues that affect the development, scalability and robustness of the application. This presentation will cover the advanced topics described below with a focus on the new persistence features in Spring 3.0 and JPA 2.0.

A large enterprise application often will have several sub-projects that each contain their own JPA persistence unit. This opens up a number of questions around how to organize the persistence units and how the code between sub-projects should interoperate. Developers will gain insight into these issues and will see a couple of solutions using live code examples.

Many enterprise applications require integration with an application server's JTA mechanism. JTA integration allows for JPA components to work with container managed transactions and distributed transactions. A typical usage scenario for JPA & JTA is this: read from a database using JPA, perform some business logic, put a mess

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/OSGi, and SpringSource dm Server, nearing a production release after approximately nine months of effort.

Topics covered will include:

A brief overview of St. Jude and the SRM domain.

SRM 1.x:

- Architecture

- Development Process

- Domain Model

- Technology Stack

- Issues

The crossroads that led to the development of SRM 2.0.

SRM 2.0 and the SRM Data Bus:

- Architecture

- Demos

How Spring Dynamic Modules and dm Server enabled:

- effective modularization of system responsibilities

- strict enforcement of module boundaries

- isolation of risk, change, technology, dependencies, and developer responsibility

- an innovative plug-in architecture allowing functional extension of the system without modification to the core platform

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

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

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.

Patterns overview

Implementing common patterns in Groovy

Beyond Gang-of-four patterns in Java and Groovy

Lots of examples

By Craig Walls

Spring 3.0 introduced the Spring Expression Language (SpEL), an extremely powerful yet succinct way to wire non-trivial values into Spring beans. In this presentation, we'll explore SpEL in great detail and see how SpEL opens up a whole new realm of bean wiring possibilities.

Spring's brand of dependency injection is quite awesome. But there are times when simple bean references and static values won't cut it. Sometimes it makes more sense to wire bean properties with values that are evaluated dynamically at runtime.

That's where the Spring Expression Language (SpEL) comes in. SpEL is one of the most interesting of the many new features in Spring 3.0. With SpEL you can succinctly wire in values derived...

...from system properties

...mathematically

...from the values of other bean properties

...from the results of static methods

...from almost anything you can conjure up

Previously, most of these types of wiring could only be accomplished with more XML confi

By Ben Alex

Spring Roo is SpringSource's new open source technology which delivers working enterprise Java applications within 10 minutes. Roo's incredible productivity boost is reflected by end user comments like "I'm impressed", "liking it", "here comes some innovation", "Roo looks interesting and works", "very impressive tool" and "very cool". Come along and find out what has got everyone excited, direct from Ben Alex - the Roo project's founder and lead.

Spring Roo provides interactive, lightweight (a 3 Mb download!), user customizable tooling that enables rapid delivery of high performance enterprise Java applications. Spring Roo includes numerous features, some of which include:

Working applications within 10 minutes of finishing the download

100% Java programming, offering developers a familiar, mature and mainstream programming platform

Transparent, reliable and productive IDE services like code assist, debuggers, visual error reporting etc

Extremely efficient runtime performance, type safety and zero runtime dependencies on Roo

Zero lock-in and dependence on Roo (optionally jump-start your project then remove it in ~4 clicks!)

Automat

By Ben Alex

While an "out of the box" install of Spring Roo provides a tremendous productivity improvement for new Java developers and seasoned architects alike, there are many exciting opportunities for further gains once you start developing Roo "add-ons". Writing a Roo "add-on" enables you to fine-tune how Roo works and add support for extra technologies. Despite such flexibility, add-ons are surprisingly easy to write and brief (many core Roo add-ons are only a dozen lines of code). This session will be of interest to anyone interested in developing their own Roo add-ons, as well as those who are simply curious how Roo works under the hood and want to gain a better understanding of the technology.

At its heart, Roo offers a core set of services that permit add-ons to be used. This session will explore everything you need to know to confidently develop your own add-ons.

During this session Ben will actually build a simple Roo add-on live on stage. What better proof of how easy it is?! We'll do this by:

Looking at how to check the Roo project out of SVN, build it, and configure your development environment to support add-on development.

A quick tour of Roo's core infrastructure. This infrastructure includes major building blocks like the shell, file system manager, file system monitor, file undo capability, classpath abstraction, Abstract Syntax Tree (AST) parsing and binding, projec

Prerequisite: Introducing Spring Roo: extreme productivity in 10 minutes

By Ben Alex and Luke Taylor

Spring Security is a popular, open-source Java security framework that represents the Spring portfolio's official security capability. It has received hundreds of thousands of downloads, been ported to other platforms (such as Python and Microsoft .NET) and represents a popular choice in many banking, government, and military installations.

This session presents practical solutions for addressing today's complex enterprise application security requirements using Spring Security. It takes attendees on a step-by-step journey that begins with the simple security requirement of a login form, and grows to include more advanced requirements such as web request authorization, single sign on and federated identity, advanced method authorization, plus rich client security considerations. Many of the exciting new features in Spring Security 3 (such as Spring Framework 3-powered expression language authorization) will also be covered.

This session promises to be intensely demonstration-oriented, with at least five separate live demonstrations and code discussions. As such, you will not only discover the important architectural concepts and standards applicable to enterprise application security, but you'll also receive plenty of practical tips and solid advice on using this powerful and flexible security framework.

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 Alex Antonov

In the beginning Orbitz had a Jini based distributed system. The system design provided easy scalability and stability, but at the cost of tight coupling because of many shared modules and components, as well as Java serialization rules. In order to improve cohesion between individual services the decision has been made to migrate to a RESTful web services architecture. The new design is based on Google Protocol Buffers to define message formats and Spring/Spring MVC to handle client-server interaction. This resulted in a loosely coupled federation of services, each with its individual release and deployment schedule, which enabled more developer innovation and easier access to more data in a uniform fashion.

The audience will be shown in detail how to deal with Google Protocol Buffers, how to define and consume the messages, how to implement the client and the server sides using Spring and Spring MVC (showing custom Views, DataBinders and other Protobuf specific implementations of Spring/MVC components) and a demo building an actual client and a server in under 15 minutes.

What you will get from this session:

- using Google Protocol Buffers to constitute language neutral contracts

- using standard HTTP plumbing and intermediaries

- designing a reverse proxy for request routing based on RESTful URLs

- establishing OLAs for governance and service isolation

- utilizing the power of Spring/Spring M

By Chris Beams and Mark Pollack

In this talk we will provide a hands-on tour of the new dependency injection features in Spring 3.0. Focusing on container configuration, we will show by example the use of Java, Groovy, Annotations and just a wee-bit of XML to wire up your application. Just as important to knowing how to configure the container, we will also discuss why you would choose one method over another, how they can be mixed and matched, and how a global view of the application can be viewed inside STS.

Session Detail

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 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 Imad Bernoussi

Enterprise business applications require agile approach and right tooling to improve the development experience and performance. Spring offers different modules used to support business needs (integration, persistence, transaction...), but combined to complex business logic description, requirements tractability and incremental specification flexibility can put a big mess.

During this session you will learn how to improve Spring based enterprise application development, focusing on M2Spring tools that provides a high level UML modeling approach for structuring application business logic and simplified integration of Spring implementation, based on model driven code generation.

In this session we will highlight the features of Spring that make using M2Spring tooling and Spring frameworks together and we will show by example how to generate and build business applications.

By Kent Brown and Mark Pollack

In many environments today there are multiple technology stacks and the services built on the various technologies need to be able to connect to each other. The web service standards around SOAP were defined to make this interoperability possible. In this session we will look at the web service capabilities of the .NET and Spring frameworks and ways that Microsoft and SpringSource are working together to make interoperability between the platforms easier for developers.

• Overview of Spring Web Services capabilities

• Overview of Windows Communication Foundation (WCF) web services capabilities

• Code walkthrough of a sample application demonstrating interoperability between the two platforms

By Dennis Callaghan, Michael Cote, Al Hilwa, Andi Mann, and Javier Soltero

Join Javier Soltero, SpringSource CTO of Management Products for an expert panel discussion about the future of enterprise deployment and what IT operations staff should be looking for when considering their production system needs. The panel includes notable industry experts: Michael Cote (Redmonk), Andi Mann (EMA), Dennis Callahan (The 451 Group), Al Hilwa (IDC).

Session Detail

By Isaac Christoffersen

With the heavy use of virtualization techonolgies in today's data centers, it has become increasingly easy to provision new servers to meet peak system demands. However, this new level of responsiveness has created new challenges for the operations management of the data center.

Using three customer case studies, this presentation will talk about how Hyperic HQ was used to greatly simplify the inventory management and system monitoring challenges. This presentation will also talk about how a monitoring solution must be a part of any Infrastructure and Platform as a Service solutions.

This session covers:

Today's data center challenges

Leveraging Intelligent Data Center

-Platform and Infrastructure as a Service

-Aligning IT and Business

Monitoring the Infrastructure

Case Study – Commercial Internet Service Provider

Case Study – US Army

Case Study – US Intelligence Agency

Demonstration

-Creating a new virtual machine

-Registering the VM in Hyperic Server

-Configuring statistics collection

Conclusion

-The move towards the intelligent data center

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 Christophe Coenraets and Jeremy Grelle

For the last few years, the industry has shifted its attention to the client and the quality of the user experience. The incremental improvements that we have witnessed so far are just first steps on a path towards "High Definition" user interfaces: vector graphics-powered expressiveness, in-context collaboration, rich media integration, real time data, and offline capabilities will become standard attributes of most web applications.

In this session, Christophe Coenraets will provide an in-depth technical introduction to Flex, a complete solution for building this new breed of applications and demonstrate the integration with Java and Spring powered back-ends.

Session Detail

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

TBD

TBD

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

Gradle pushes declarative builds to a new level. It allows users to provide there own declarative elements and to customize the behavior of the build-in ones. Thus enabling concise, expressive and maintainable builds. All this is build on a rich, flexible imperative layer of tasks.

With its Deep API Gradle allows you to hook in and customize every aspect of the build, be it configuration or execution behavior.

Gradle comes with many optimization strategies for building fast and yet reliable. It has a powerful support for multi-project builds and transitive dependency management. It allows to integrate with your existing Ant/Maven builds and your Ivy/Maven/Custom repositories.

The demos wi

By Hans Dockter

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.

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.

Prerequisite: Introduction to Gradle

By Keith Donald

Spring provides a full open-source stack for building, running, and managing web applications on the Java platform. This session provides an overview of this stack and shows how the pieces fit together. Attendees learn how Spring simplifies the development and deployment of enterprise web applications.

Spring Web MVC is a popular web framework, and the foundation of the Spring 3 Web Stack. Version 3.0 of Spring MVC introduces major new features, including support for annotated @Controllers, comprehensive REST support, convention-over-configuration, an enhanced data binding and UI messaging facility, and declarative validation support. This presentation shows you how to apply these core features to gain development productivity and implementation consistency.

Building on Spring MVC are a number of interesting modules. Spring Web Flow adds significant power for implementing multi-step flows within a Spring MVC-based app. Spring Javascript integrates leading UI toolkits such as Dojo for add

By Keith Donald

Web Flow is a Spring Web MVC extension that allows you to define Controllers using a higher-order domain-specific-language. This language is designed to model user interactions that require several requests into the server to complete, or may be invoked from different contexts. This session dives deep into the features of the Web Flow 2 definition language, and illustrates how to use it to create sophisticated controller modules.

In this session you will learn:

* How to implement reusable controller modules as self-contained bundles that can be refreshed without container restart

* How to handle Ajax events and render partial responses

* How to secure flows, including their startup

* How to simply data access concerns and prevent lazy loading exceptions by using flow-managed persistence

* How to test your flow logic

* General best-practices for designing and implementing flows

* Guidelines for deploying flows alongside Spring Web MVC multi-action @Controllers

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 and plugins. This will feature a good amount of live coding to show the concepts in action.

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.

This session will move through a quick introduction of GORM, HQL, and the GORM plugins.

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

The first milestone version of Spring Integration 2.0 has just recently been released. This version builds upon a Spring 3.0 foundation and will provide several new features including extensive Spring EL support, AOP interception for publishing Messages, and Message Channels that are backed by JMS Destinations. The 2.0 release will also include enhanced OSGi support and several new adapters such as JDBC, TCP/UDP, XMPP, and RSS.

This session will begin with a quick overview of Spring Integration 1.0 for those who are not yet familiar with the project. Next, we'll go through some demos of the features that are already available in the first milestone. Finally, we'll explore the 2.0 roadmap and discuss the features that will be available over the next couple of months leading up to the 2.0 final release. This is your chance to not only catch a glimpse of the project's future but even to influence it with your own ideas and feedback. Don't miss the opportunity!

Session Detail

By Mark Fisher and Dave Syer

In this presentation Dave Syer and Mark Fisher will show how to reduce the burden of manual processing in a batch processing environment, and demonstrate how some common real-life use cases can be implemented using features from Spring Batch and Spring Integration. Automation and cost reduction is a key theme for operators and the SpringSource stack has features that make these concerns accessible to developers, so that they become natural and cheap to implement and embed in any application.
Starting with a simple job, the presentation shows how to trigger its execution using file-polling. The sample is then expanded to show interesting partial failure and automatic retry and restart scenarios, all with transparent monitoring and management through a simple user interface.

Session Detail

By Mark Fisher and Mark Pollack

This intermediate level talk will provide a quick review of the foundational JMS support in Spring (JmsTemplate and message driven POJOs) and then discuss several best practices regarding using JMS with Spring. Some of the best practice topics covered are effective JMS resource management, strategies for transactional message processing in conjunction with database access, and broker configuration tips for ActiveMQ. The use of JMS throughout the Spring portfolio will also be demonstrated, showing BlazeDS and Spring.NET for integration with Adobe and Microsoft .NET platforms as well and the use of JMS in Spring Web Services and Spring Integration.

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

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.

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 Jeremy Grelle

Traditional JSF development has gained a reputation for being overly complex and cumbersome. Spring Faces introduces a host of features that improve the development experience and performance a JSF application. In this session, attendees will see a real-time demonstration of how Spring Faces makes the JSF experience more productive and reduces the pain of container re-starts and verbose configuration.

This live coding session will highlight the features of Spring Faces that make using JSF and Spring together a more cohesive experience:

* High-level DSL for structuring control logic that utilizes EL and Groovy and is both easy to unit test and fully dynamic and refreshable in-container at runtime.
* Introduction of view and flow scopes that fit more naturally with JSF's stateful model
* Reduction in external configuration with no need for JSF managed- bean or navigation-rule definitions
* Easy-to-introduce client-side validation and Ajax
* Flow-managed persistence contexts that enable true transparent persistence.
* Simplified integration with Spring Security
* Less conceptual disconnect by enabling the Spring programming model throughout the stack ("turtles all the way down")

Session Details

By Jeremy Grelle

Spring JavaScript is a JavaScript abstraction framework that allows you to progressively enhance a web page with behavior. The framework consists of a public JavaScript API along with an implementation that builds on the Dojo Toolkit. Spring.js simplifies the use of Dojo for common enterprise scenarios while retaining its full-power for advanced use cases. Come to this session to learn to use Spring.js and Dojo to create compelling user interfaces for your Spring MVC web applications.

This session will walk through using Spring.js to add a number of rich web capabilities to your applications, including:

* Decorating standard HTML links and forms with Ajax events

* Linking in partial updates to a page

* Adding effects such as progress indicators, blinds, and popups

* Performing client-side validation

In addition, you'll see how Spring.js can help with:

* Gracefully degrading when JavaScript is not available

* Meeting requirements for accessibility

* Applying progressive enhancement techniques

By Ben Hale

The dm Server 2.0 release adds significant features to the world's most advanced OSGi-based application server. This session will go into detail about the new repository structure, cloning, rfc-66, web slices, and more.

Session Detail

By Filip Hanik

One of the more exiciting features in the new Servlet 3.0 specification is the standard support for asynchronous request processing, opening up a new gateway for innovative technologies. Asynchronous request processing breaks the thread per request limitation that the Servlet technologies have long suffered from. While containers have provided this functionality in the past, all implementations have been propriatery and often not offered complete solutions. The Servlet 3.0 asynchronous API aims to address a majority of the uses cases for true Web 2.0 functionality as well as keeping the complexity of asynchronous programming at a minimal level.

Session Detail

By Filip Hanik and Jennifer Hickey

Managing production environments offers a large set of challenges. Restricted access, a limited tool set, unpredictable traffic patterns and organizational gaps are only a few. To overcome these barriers one must understand the process, the runtime environment and the practical application of technologies and their behaviours. In this interactive session we will demonstrate capabilities that enable developers, administrators, and operators to diagnose, measure, and monitor their applications and the infrastructure their applications are deployed on. The goal is to achieve swift isolation, correct diagnosis and minimum impact resolution.

Session Detail

By Rob Harrop

Could your application benefit from a more modular architecture? Do you need to load or reload application components while it is running? Do you want to understand what OSGi means for you, an enterprise Java developer? Join Rob Harrop for a basic introduction to the concepts and technology behind OSGi and how it can be used successfully in enterprise applications.

Session Detail

By Rob Harrop

In this session, Rob Harrop, author of the RFC66 reference implementation, provides a rapid-fire tutorial on creating effective modular web applications for OSGi and the RFC66 Web Container.

Attendees will learn how to:

* Install Tomcat and the Web Container reference implementation into OSGi

* Use the OSGi Web Container (RFC66) to deploy web applications on an OSGi platform

* Access shared libraries from their web apps

* Access OSGi services from their web apps

* Design and modularize web applications

* Extend web applications dynamically using standard OSGi features

Attendees should have an understanding of OSGi basics and be familiar with Java Servlets.

By Jennifer Hickey

Today's IT infrastructure undergoes constant change due to technology shifts, cost, scalability, and complexity. This session will cover the features of Hyperic HQ specially designed to handle the high frequency of change, including its broad and extensible support of technologies, powerful auto-discovery, real-time change detection, global resource type templates, events and alerts generation, and scriptable web services API that automate inventory management.

Session Detail

By Jim Jagielski

Look inside any Enterprise environment and you'll find the Apache HTTP Web Server. This session will describe advanced configuration and tuning techniques to get the most out of Apache HTTPD, balancing performance, reliability and security.

Session Detail

By Steve Jin

This session will give you an overview of VMware management APIs, and focus on the open source VI Java API. You will learn how to leverage VMware vSphere for your development, testing and deployment using the API. The coverage includes the basic concepts and object model of the API, how to configure vSphere/VMware Server, how to provision new virtual machines and manage their lifecycles, how to monitor system performances, how to automate system management.

Session Detail

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

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

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.

You'll be amazed at how quickly you can become productive with Grails, not just because of scaffolding but because of the power of “Convention over Configuration,” sensible defaults, and the dynamic goodness of Groovy - all applied to a suite of the best tools in the industry, such as Spring, Hibernate, Tomcat, Ant, Sitemesh, JUnit, and more.

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. We will also see how we can bundle our custom tags into a Grails plugin to reuse in our other projects or to share with the community.

By Kirk Knoernschild

Software architecture is not static, and architectural shifts occur throughout the course of a project. Agile architecture is defined by our willingness and ability to embrace and accommodate architectural change. In this sense, agile architecture is both temporal and structural. The temporal aspect pertains to when decisions are made, and demands that the architect be flexible. The structural aspect demands that the architecture be flexible so that the team is able to accommodate change. In other words, our willingness to embrace change must be accompanied by our ability to accommodate change. Agile architecture demands both, and the absence of one precludes the presence of the other. In this session, we examine these two aspects of agile architecture. We'll discuss the concept of architecture throughout the lifecycle, and the activities performed by an agile architect. Extensive discussion is also devoted to modularity, and how large systems can be organized to increase flexibility, reusability, maintainability, extensibility, and testability. Numerous examples illustrating modularity patterns will be shown using OSGi and Spring DM. And we'll explore the inextricable link between temporal and structural agile architecture.

Session Detail

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 Ramnivas Laddad

Enterprise application development is a gold mine for applications of AOP. There are many crosscutting concerns found in a typical enterprise application, ranging from well-known security and transaction management to application- and technology-specific concerns. Using AOP leads to implementations that are easy to understand and easy to change. When we combine Spring with AspectJ, we get a pragmatic AOP solution. This demo-driven session shows how to implement common functionality needed by typical enterprise applications, with a focus on web applications.

In this session, you will learn how to implement functionalities such as monitoring, exception handling, policy enforcement, transaction management, fault tolerance, and security. You should be able to take these ideas and implement them in your own projects and reap the benefits of AOP.

By Costin Leau and Mark Pollack

The Spring Framework is well-known for tight integration with the J2EE 1.4 and Java EE 5 platforms. Now Java EE 6 is coming our way...

* Where are new integration opportunities emerging?
* Where is the Spring component model compatible with the direction that Java EE 6 is taking?

This talk will provide an analysis and overview on the integration points between the Java EE 6 APIs and Spring.

.

By Charles Lee

Cloud computing is the biggest IT trend in a decade. The promise of cost and time savings are not obvious nor easily realized. We will present cloud deployment strategies for Java web applications using a number of SpringSource products that dramatically compresses the application lifecycle and help you run and manage cloud deployments successfully and efficiently. SpringSource products reduce the learning curve, complexity, time, and cost to leveraging the leading cloud vendor technologies.

This session will include the following topics:

• Java web application deployment
• Deployment blueprints
• Monitoring and Management services
• Auto-scaling and forecasting
• Transitioning from development to production

Session Detail

By Charles Lee

Hyperic HQ collects more application performance metrics and provides more coverage for the entire web infrastructure stack than any other systems monitoring software. HQ's metric data keeps IT infrastructures running smoothly with real-time alerts and on-the-fly analysis for root cause resolution. However, when context is applied to the data, you gain an insight into the performance data that helps operations and business users to analyze, evaluate, plan, act, and make strategic decisions. This session will present different usage scenarios and environments and walk through how Hyperic IQ can apply intelligence to the abundance of application performance data from HQ. We will be looking at a number of IQ's built-in report templates that can easily be adapted to your environment.

Session Detail

By Randy MacBlane and Jon Travis

This session will cover the current features available in SpringSource tc Server, the enterprise version of Apache Tomcat that provides developers with the lightweight server they want paired with the operational management, advanced diagnostics, and mission-critical support capabilities businesses need. SpringSource tc Server is designed to be a drop in replacement for Tomcat 6, ensuring a seamless upgrade path for existing custom-built and commercial software applications already certified for Tomcat. The session will also discuss some of the planned use cases for tc Server and provide attendees with the opportunity to share their needs derived from using Tomcat in production.

If you use Apache Tomcat in development or in production this session will be valuable to you.

Session Detail

By Maudrit Martinez and Vipul Savjani

Learn how Accenture is helping clients maximize their success with reusable and industrialized architectures. This session will focus on the latest release of Accenture Delivery Architecture (ADA) and how Accenture integrates OSS technologies, best practices and processes in ADA to enable full-scale industrialization of software delivery for high performance.

The presentation will also highlight some of the recent steps Accenture has taken to adopt Spring and Skyway, to enable accelerated development through standardized development environments, processes and tools.

The session will feature an overview of the Accenture Foundation Platform for JavaTM, followed by a live demo of how the platform works in the cloud.

Session Detail

By Tom McCuch and Oleg Zhurakousky

Traditional Enterprise Integration products (i.e., Enterprise Services Bus) promote a proprietary development and deployment model that requires a steep, costly organizational learning curve to successfully adopt. In addition, the more successful you are at adopting these development and deployment models - the more locked in to those proprietary products you become. What if Services Oriented Architecture could be be incrementally adopted in a lower risk, more agile way - led by your current Java developers and systems analysts? What if the end-result of this incremental adoption could simply be a re-factored version of your existing Java business application that is still fully portable across all java run-time environments?

Spring Framework, Spring Integration, and Spring Batch are lightweight, embeddable frameworks that serve to support the incremental adoption of SOA within your business applications, not complex, standalone middleware products that aim to control them (and ultimately you). This presentation will demonstrate how a legacy, vertically-integrated Java application can be re-factored toward a more flexible, modular service oriented architecture by the Spring developers you already have using the tools and platforms (tcServer, dmServer) they already know (and love).

Session Detail

Prerequisite: Spring Integration, OSGi & Spring-DM/dmServer

By Marty Messer

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 John Newton

Rapid assembly of a Spring web application requires an easy-to-use web framework for developers and web designers that makes it very simple to compose content into the user experience. High-end web sites, such as travel and e-commerce sites, may use Spring to integrate enterprise and back-end systems into the site, but can be let down by limited web frameworks, a lack of content services and a mass of disconnected JSP pages.

This presentation explains and demonstrates the SURF framework as a
new web framework founded upon the concept of Scriptable REST.
Scriptable REST quickens the pace for deploying REST controllers and remote application interfaces. It enables a scripting approach to web application assembly – lowering the cost of application development while moving the design of the web site from a purely technical exercise to one that can be built and extended by a web design team.

The SURF web framework improves upon existing web frameworks (such as Tiles or SiteMesh) by offering an easier means for defining and reusing site elements such as pages, templates, layouts, components and chrome. SURF provides remote connectivity management as well as integration to open standards, such as the OASIS CMIS interoperability standard so as separate content management from the application development process.

Using the standard Spring Pet Clinic application as a starting point, this session shows how that application can be developed using SURF’s Scriptable REST architecture. It demonstrates how content is externally managed, deployed and integrated into the application by the end user. It also shows how the application can be extended using scripting that complements the Spring MVC framework.

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.

One of the hottest new features coming out of the spring team is Spring Web Flow. With the 2.0 released recently, it will start to gain even more support. What is Spring Web Flow you ask? Simply it is a way one can easily construct the flow of the website without having to make the services aware of what page the service should forward to next. However, this is not just about controlling the flow, with Spring Web Flow one is able to keep state of the objects for the duration of the flow, one is able to stop someone from entering in the middle of the flow, and most importantly one can create alternate paths inside the flow. All of these features give your application added functionality that

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 Prasad Pimplaskar

VMware vCloud delivers a single way to run, manage, and secure your applications where you want them, when you want them. The vCloud API is an interface for providing and consuming virtual resources in the cloud. It enables deploying and managing virtualized workloads in internal or external clouds as well as interoperability between clouds. In this session you will see the significant innovation that went into architecting a highly available, scalable, extensible, and secure multi-tenant application.

Session Detail

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 Arjen Poutsma

One of the major new themes of Spring 3.0 is the support for REST in Spring MVC. In this session, Arjen will investigate these features from the perspective of a web application developer. Attend this session to learn about URI templates, content-negotiation, and other RESTFul concepts.

We will start by giving an overview of REST: where did it come from, how does it work, how can it be used to build a web application, and where does it make sense to use? Using illustrative examples, we will try to find an answer to these questions.

Next, we look at the new RESTful features in Spring, including:

* RESTful URI's

* URI templates

* Content negotiation

* HTTP method conversion

* ETag support

By Chris Richardson

The Amazon Elastic Compute Cloud (EC2) is ideally suited to running Java applications. It lets you develop using standard Java software packages such as Tomcat and MySQL and rapidly deploy applications on servers that are provisioned and managed via a web services API. And, with its pay as you go pricing model, Amazon EC2 enables startups to launch their application without any upfront investment in computer hardware and allows enterprises to reduce costs and become more agile.

However, because it is a cloud, some aspects of Amazon EC2 are very different than a traditional, physical computing environment. In this session you will learn about those differences and how they impact how you handle security, networking, storage and availability. We describe how to use EC2 and the other Amazon web services to develop and deploy Java applications. You will learn how to use EC2 availability zones to deploy highly available applications. We also discuss how to architect secure applications for Amazon EC2.

Session Detail

By Chris Richardson

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.

In this session you will learn how to use these web services. We describe the various open-source Java libraries for interacting these web services including JetS3t and Typica and how to integrate them into your Grails development model. You will learn about the benefits and drawbacks of these web services and their typical uses cases.

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

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.

Session Topics:

The Grails Architecture

Scripting Grails with Gant

Using Grails' Spring DSL: The BeanBuilder

Adding new methods, properties and constructors with ExpandoMetaClass

Packaging, distributing and installing your plug-in

By Graeme Rocher

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

An extended example of how to write your own Grails 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.

By Colin Sampaleanu

SpringSource tc Server can offer a compelling alternative to traditional (legacy) full stack Java EE application servers, based on a number of factors including performance, licensing cost, resource utilization, usability for agile development environments, and cost of management, among others. However, for organization looking to move existing applications to tc Server, it is not always clear what the effort and impact will be, to move individual applications. This session outlines a clear set of criteria, strategies, and steps (including any needed refactoring) in deciding to move applications to tc Server, and then making the move. The optional use of the Spring Framework, as part of any migration effort, is also covered in this presentation.

Session Detail

By Stefan Schmidt

Spring Roo delivers outstanding productivity gains to any class of application, and in particular web applications built on the proven Spring web stack. In only seconds you can effortlessly add web features including RESTful backends, URI rewriting, Selenium-powered integration tests, Spring Web Flow and Spring JavaScript to your enterprise applications. Join Stefan Schmidt - the author of Roo's web add-ons - to discover more about these Web 2.0 features.

During this session Stefan will develop an enterprise application from scratch, and then progressively explore and fine-tune its web tier. We'll discover how easy it is to add custom controllers, change the look and feel, achieve web authorization and more.

Attendees will leave this session with a comprehensive understanding of the Spring Roo web capabilities, and how easily these can be applied to your own projects.

Prerequisite: Introducing Spring Roo: extreme productivity in 10 minutes

By Matthew 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 Matthew 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 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 Jon Travis

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.

In this talk, I'll describe patterns that Hyperic used to give customers specific one-off plugins to dynamically add UI screens, customize existing features, and integrate with external systems. In addition, I'll explain how to use Groovy to make supporting your deployed applications infinitely easier.

By Scott Vlaminck

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.

In this session we will focus on why and when to use metaprogramming techniques and provide some real-world examples. This session will not focus on the details of how to use metaprogramming in Groovy.

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.

In this session, we'll discuss how to use AOP in Grails, why and when you might want to use AOP, and we'll dive into the implementation of the Grails Circuit Breaker Plugin.

By Chip Witt

The road to application success does not end at deployment. In fact, an application's life is longer after development and initial implementation than it is before, and success is measured almost exclusively by the experience of the application's end-users. Perceived or real, poor application performance can have a lasting effect, and can negatively impact an organization's bottom-line. Measuring availability, key performance metrics, and having timely notification of issues reach the "right people" across the entire application stack is imperative.

In this session we will talk about the importance of a monitoring mindset through the entire "Build -> Run -> Manage" lifecycle of an application, how to identify key performance metrics across an application stack, and how to overlay responsibility work-flows for timely issue notification. The information and discussion is meant to be generally applicable, but specific examples will be imparted using the SpringSource HQ monitoring tool-set.

Session Detail

By Chip Witt

In the age of the cloud and virtualization, infrastructures are changing more rapidly than ever. Ops teams must still provide the same level of oversight to make sure everything is running smoothly. In this session you will learn how to use tools to manage and monitor your entire infrastructure in scalable ways.

Session Detail

By Chip Witt

Hyperic HQ is used to monitor some of the largest and most visible web applications on the internet. This session aims to combine the knowledge gained from these deployments to provide a set of best practices for your web management infrastructure. Topics to be covered include everything from architecture and deployment of HQ, to extension areas of the product to allow for integration with other management systems and processes. We will also cover best practices for instrumentation of applications to provide a smooth transition from development to operations in the build, run, manage application life-cycle.

Session Detail

By Ari Zilka

Spring has made writing enterprise apps a lot less complicated, but the getting performance and scalability you need can still be a challenge. With its recent acquisition of Ehcache and the newly released Terracotta for Hibernate, Terracotta has built a line of distributed cache products that can help Spring developers build fast scalable applications with a lot less hassle.

In this presentation you'll learn how to get high performance and scale using Terracotta as the engine for Ehcache and Hibernate performance. Ari will walk you though the details of real customer applications where Terracotta has been used with Ehcache and Hibernate to achieve 30-90% database offload, 10 times the application throughput, and reduce application latencies to the single-digit millisecond range. Also, get insights into the Terracotta product roadmap and learn about some new features being built for Ehcache

Session Detail