By Rod Johnson

Rod welcomes you to SpringOne 2GX

.

By Adrian Colyer

SpringOne CTO Adrian Colyer hosts the technical keynote

By Juergen Hoeller

Spring 3.0 established itself as a powerful basis for next-generation application design. Spring 3.1 adds dedicated conversation management facilities and many further improvements in Spring MVC, as well as explicit support for Servlet 3.0 and Tomcat 7 features. In this session, we will focus on selected key themes of Spring 3.1 in the context of modern web applications.

Details updated soon.

By Juergen Hoeller

Spring is known to have a strong story for applications running on J2EE 1.4 and also on Java EE 5 servers. What is the situation like with Java EE 6, e.g. when running Spring 3.0/3.1 on GlassFish 3? What pieces of EE 6 are useful outside of an EE server as well, e.g. on Tomcat 7? This talk provides a pragmatic overview of the state of the art in 2010/2011.

Details added soon

By Ben Alex and Stefan Schmidt

One of the most exciting improvements in Spring Roo 1.1 is the addition of a powerful OSGi-based add-on discovery and distribution feature. This new feature allows anyone to write Spring Roo add-ons and have them immediately and easily made available to the entire Spring Roo community. In this session we will introduce RooBot, the automatic provisioning server which underpins this new feature. We'll then write a Spring Roo add-on and make it immediately available to all the Spring Roo installations on attendee laptops. Also in this session we'll explore some of the architectural background necessary to write add-ons, plus offer practical advice and time-saving hints for those wanting to extend Spring Roo into new capability areas.

Session Detail

By Ben Alex and Amit Manjhi

Who says you can't build rich web apps for your business? Follow along in this session to learn how you can use the latest integrated set of tools from Google and VMware to take your internal business apps into the cloud. We'll cover how to get started using GWT with Spring Roo and SpringSource Tool Suite (STS), as well as the new data presentation widgets and MVP framework that will be available in the 2.1 release of GWT.

This talk shows how to quickly build a GWT application using Roo. After a demo of a Roo-generated GWT app, the talk takes a deep dive into the architecture of the generated GWT app. The generated GWT app follows the best architectural practices of Google AdWords front end, the poster child GWT app. The talk covers the main components of the architecture framework that GWT 2.1 introduces, using actual code samples. The main components covered are: RequestFacotry (the new RPC mechanism), Activities (the pattern to organize the presenters of an MVP pattern), Places (a bookamarkable URL), Editor support (support to generate the views), cell widgets (the new data presentation widgets for displaying large amounts of data), and logging and monitoring. A theme of the talk is how GWT and Roo combine to simplify the developer's task, enabling them to just write non-boiler-late code.

By Ben Alex

Delight your customers and impress your colleagues by delivering enterprise Spring applications faster than ever before. In this session we'll introduce Spring Roo, an open source tool that makes it easy to build applications using the Java language, standards and technologies you already know. We'll also be showing you an exciting new feature which lets you update running Java applications without restarting the server and the considerable time-savings that this provides.

In this demonstration-oriented session, we will show you how Spring Roo delivers:

* Support for Java standards including JPA, Servlet Spec, JSP, JavaBean Validation, JavaMail, JMS etc

* Transparently reverse engineering and synchronising database schemas

* Scaffolded UIs in Google Web Toolkit (GWT), Adobe Flex and Spring MVC

* Automatic JUnit tests, Maven builds, JSP pages, toString() methods etc

* Deploying to clouds such as Google App Engine

* Extending Roo with add-ons

* Removing Roo from your project in four clicks

This session will also highlight what's new in Spring Roo 1.1 and preview other in-depth sessions at SpringOne that cover Spring Roo.

By Ben Alex and Andy Clement

Delight your customers and impress your colleagues by delivering enterprise Spring applications faster than ever before. In this session we'll introduce Spring Roo, an open source tool that makes it easy to build applications using the Java language, standards and technologies you already know. We'll also be showing you an exciting new feature which lets you update running Java applications without restarting the server and the considerable time-savings that this provides.

In this demonstration-oriented session, we will show you how Spring Roo delivers:

* Support for Java standards including JPA, Servlet Spec, JSP, JavaBean Validation, JavaMail, JMS etc

* Transparently reverse engineering and synchronising database schemas

* Scaffolded UIs in Google Web Toolkit (GWT), Adobe Flex and Spring MVC

* Automatic JUnit tests, Maven builds, JSP pages, toString() methods etc

* Deploying to clouds such as Google App Engine

* Extending Roo with add-ons

* Removing Roo from your project in four clicks

This session will also highlight what's new in Spring Roo 1.1 and preview other in-depth sessions at SpringOne that cover Spring Roo.

By Peter Bell

The easy part of implementing Domain Specific Languages in Groovy is coding them. The hard part comes when you have to think about testing, documenting, evolving and providing appropriate editing interfaces for them.

In this session we'll go beyond the syntax and look at the real world engineering concerns for widespread use of a DSL and various proven strategies for building DSLs that will grow with your projects and work for your target users.

By Peter Bell

Oh no, you're new Groovy DSL is actually popular. And of course, the feature requests keep come in. But what do you do to evolve your DSLs without breaking the existing models as your understanding of the domain changes radically over time?

This session will take a DSL and show examples of the four key strategies available: "fixing the API", "backwards compatibility", "versioning" and "automated evolution/checking" and the implications of each strategy on the best way to implement DSLs that are likely to change substantially over time.

By Peter Bell

In this session we'll build up a DSL in Groovy test first, showing a number of test strategies which can be used to develop various types of DSLs.

We'll also look at the various approaches to testing your DSLs even if you don't TDD them.

By Tim Berglund

Watch Preview Video

Grails is emerging as a standard JVM web framework in environments ranging from startups to the enterprise. It's a full-stack solution build on rock-solid components, fully relying on convention over configuration, and using the best application language the JVM has yet seen: Groovy. This is the place to be for web apps on the JVM.

In this introductory talk, we'll get a whirlwind introduction to Grails, visiting seven things you need to know about the framework to get started.

Programming in Groovy

Creating an app

Interacting with the database

Building your UI

Processing web requests

Tapping the huge plugin community

Deploying to production

By Tim Berglund

Out of the box, Grails famously relies on Hibernate for database persistence through the agency of GORM, the Grails Object-Relational Mapping API. But are Grails apps permanently beholden to relational datastores, even when the relational model is not an appropriate solution for the problem at hand? No!

Grails provides popular plugins for such NoSQL contenders as MongoDB, Voldemort, Cassandra, and Redis. In this session, we'll take a quick look at each of those four NoSQL database technologies, how the products function on their own, and how their Grails plugins work. We'll also take a long step back and develop an understanding of why NoSQL products exist and how they differentiate themselves as containers for our data.

By Ken Sipe and 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 will span dependency management, test result analysis, code sharing, parallel testing, incremental builds, integrating with Ant/Maven and more.

By Ken Sipe and 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 Brian Sletten

The Semantic Web is Tim Berners-Lee's full vision of what the Web can and will be. This HTML stuff we are all so enamored with is just the tip of the iceberg. "Web 2.0" is a kindergarten plaything (and a stupid name). Webs of linked data will allow us unprecedented flexibility in how we produce and consume information. While many people have been waiting on the sideline for the Semantic Web to get here, others have been making it happen.

Groovy raises the bar on what is possible with Semantic Technologies on the JVM. A rich dynamic language that interacts with a rich dynamic data model is all kinds of cool. We will combine Groovy metaprogramming and its expressive syntax to extend several existing Java-based Semantic Web technologies. We will also see how to consume machine-processable web pages using RDFa parsers, query data sources w/ SPARQL and even invoke an OWL reasoner.

This talk should be accessible to anyone familiar with Groovy. No Semantic Web knowledge will be assumed.

By Brian Sletten

Most organizations have a pretty conservative attitude toward adopting technology. If you are allowed to use a language like Groovy, chances are it is still going to be deployed in a conventional container like Tomcat or some other J2EE infrastructure.

What would happen if you took the power of a language like Groovy and married it to a next-generation environment like NetKernel? Imagine combining the power of Groovy metaprogramming with a microkernel-based resource-oriented environment. Expressive, powerful, scalable. It's pretty much guaranteed to rip a hole in the space time continuum. Come watch it happen.

You will be amazed at how much can be accomplished with so little code (not to mention how well it will perform).

We will start with an introduction to NetKernel and then steadily apply some Metaprogramming Fu to build up from there.

You do not need to know anything about NetKernel, but this will be a challenging (and fun) talk.

By Matt Stine

The Service-Oriented Front-End Architecture (SOFEA) was first described in an article posted to The Server Side in late 2007. In that article, Ganesh Prasad, Rajat Taneja and Vikrant Todankar introduced a new architectural style for building web applications. Since that time numerous frameworks have begun to facilitate building applications in this style. This talk will focus on the combination of Grails and the Yahoo! User Interface Library for building SOFEA applications.

SOFEA Principles

Grails REST services

YUI REST clients

Use-cases in SOFEA style:

Rich Editable Data Tables

Autocompletion

By Venkat Subramaniam

Groovy is a elegant, dynamic, agile, OO language. I like to program in Groovy because it is fun and the code is concise and highly expressive. Writing code in a language is hardly about using its syntax, however. It is about using the right idioms. Come to this section to pick up some nice Groovy idioms.

In this presentation you will take some Java code that does common operations and transform it to idiomatic Groovy. You will participate in exploring various options as you help transform several examples. Each example is intended to hone a particular idiom or Groovy facility.

Prerequisite: Some knowledge of Groovy is helpful but not required.

By Venkat Subramaniam

Groovy is concise and expressive. However, writing good quality code takes effort and discipline.

Come to this session to learn about good coding styles, ways to observe, and measure the quality of your Groovy code. We will take several Groovy code examples, identify smells in them, measure and refactor to

improve the quality.

By Venkat Subramaniam

Functional programming style is gaining popularity. Though Groovy is not a functional programming language, writing in functional style is common and idiomatic in Groovy. While you have used these features in Groovy, learning the tents of functional programming will help you recognized these and make better use of them in the future.

In this presentation we will learn what functional programming is and its benefits. Then we will explore the functional style of programming in Groovy.

By Venkat Subramaniam

The concise, expressive syntax of Groovy and the ability to create internal DSLs make Groovy a great language for testing related tools. I

In this presentation you will learn different Groovy based testing related tools that can help you attain and sustain agility on your projects. Rather than looking at a mere laundry list of tools, we will explore the key benefits and rationale for each tool, and understand strengths and weaknesses.

By Guillaume LaForge

Guillaume will present Gaelyk, a lightweight Groovy toolkit for easily developing Groovy applications to be deployed on Google App Engine Java. We'll learn more about what the toolkit provides, how to leverage it for your own needs through some demos.

We'll see how to setup a Gaelyk application thanks to a template project, how to develop groovlets controllers and view templates, how to define routes for the URL routing system. We'll also describe all the syntax sugar and the shortcuts provided by Gaelyk on top of the Google App Engine SDK, and we'll eventually discuss briefly the simple plugin system that comes built-in.

By Guillaume LaForge

In "Groovy update, to infinity and beyond!", Guillaume Laforge will come back on Groovy's past, present and future. First, we'll do a quick review of Groovy 1.6 features: multiple assignment and option return in if/else and try/catch blocks, AST transformations with @Delegate, @Lazy, @Immutable, @Mixin and friends, the Grape dependency module, metaprogramming enhancements, JSR-223, JMX and OSGi support built-in. Then we'll dive into Groovy 1.7, especially how to simplify the creation of AST transformations, the small incremental improvements to the Groovy GDK, how to "customize the truth", power asserts, and more.

Eventually we'll discover the upcoming features in Groovy 1.8, for instance how to extend annotations beyond Java 5, potential new features such as structural pattern matching, parser combinators, actors, AST templates, and more.

By Graeme Rocher

Grails provides a dynamic and agile development framework for web applications that is based on the most stable and productive open source libraries, including the Spring framework.

This session will describe the latest features available in the new Grails 1.3 release and will describe the roadmap for upcoming releases.

By Graeme Rocher

Grails provides solid and mature support for SQL databases, but what about the upcoming range of NoSQL data stores? I

In this talk Graeme will discuss how Grails can be backed onto alternative data store such as key/value, document and graph based data stores.

By Jeff Brown

GORM is a super powerful ORM tool that makes ORM simple by leveraging the flexibility and expressiveness of a dynamic language like Groovy. With GORM developers get access to all of the power and flexibility of an ORM tool like Hibernate without any of the complexity.

This session will cover a lot of the GORM API from the developer's perspective as well as diving into some of the implementation details. Knowing how some of this works under the covers will give developers an opportunity to not only improve their productivity with GORM but also open up possibilities of using dynamic metaprogramming in other aspects of their application development efforts.

Prerequisite: Advanced Grails

By Jeff Brown

Grails is a super powerful framework for building applications for the Java platform. Grails addresses the pain points that the other web applications frameworks leave you with. This session covers the details you need to further extend Grails to help Grails help you in your environment.

Since 2006 Grails has had a really powerful and flexible plugin system. Much of the functionality in Grails itself is implemented as plugins. Grails makes it easy for you to further extend the framework to address needs in your environment. This session will detail how some of the core plugins work. The session will also cover all of the information needed to customize existing behavior or introduce whole new capabilities to the framework through the plugin system and other techniques.

By Jeff Brown

The dynamic nature of Groovy makes it a fantastic language for building dynamic applications for the Java Platform. The metaprogramming capabilities offered by the language provide everything that an application development team needs to build systems that are far more capable than their all Java counterparts. Taking advantage of Groovy's metaprogramming capabilities brings great new possibilities that would be very difficult or just plain impossible to write with Java alone. Building Domain Specific Languages in Groovy is easy to do once a team has a good understanding of the Metaobject-Protocol (MOP) and the method dispatch mechanisms used by the Groovy runtime environment.

This session will cover in detail a number of advanced metaprogramming concepts in Groovy. The discussion will cover using dynamic method interception, meta-class manipulation, AST transformations and Groovy's Metaobject-Protocol (MP) to build flexible applications in Groovy including implementing a Domain Specific Language (DSL).

By Jeff Brown

Grails is one of the most flexible and most powerful frameworks on The Java Platform. Grails leverages the flexibility offered by the platform in a way that other web frameworks do not. Grails is a fantastic platform for polglot web programming.

Part of what makes Grails so compelling is its really powerful plugin system. The Grails plugin system allows capabilities to be bolted on to applications, including adding support for a variety of programming languages. All of the major programming languages available on the JVM are supported by The Grails Framework. These include Java, Groovy, Scala, Clojure and others. This session will dive in to that aspect of the framework with a focus on Scala and Clojure and will demonstrate what is involved in adding support for new languages.

Prerequisite: Advanced Grails

By Hans Dockter

For our production code we apply a wealth of design values and principles. Currently this is rarely done for our builds. Yet the project automation domain, specially in the enterprise, is often at least as complex as the business domain.

The design of your build is heavily influenced and possibly constrained by the design of the build system you are using. The main focus of this talk is to evaluate those design forces of the build systems. Mostly with the help of two books: Refactoring by Martin Fowler and Domain Driven Design by Eric Evans.

The build systems under review are dramatically different and thus the design of the corresponding builds. We will talk about best practices for build design and how different build systems might support that or stand in the way, thus preventing expressive, maintainable and easy to use builds. Those differences should be a major factor when you are choosing a build system appropriate to your needs.

The speaker is the founder of Gradle. So there might be some bias :). But the design principles referred to are core principles fully accepted by the Java community. The way they are violated is astonishingly obvious once pointed out. Production code would not get away with this and neither should builds.

By Craig Walls

Watch Preview Video

Businesses are increasingly recognizing the value of connecting with their customers on a more personal level. Companies can utilize social networking to transition from "Big Faceless Corporation" to "Friend" by taking their wares to the online communities where their customers are. In this age of social media, those communities are found at social network sites such as Facebook, Twitter, and LinkedIn. In this session, you'll learn how to build applications that interact with the various social networks. We'll also look at Spring Social, a new feature in the Spring portfolio that enables integration with social networks in Spring-based applications.

Session Detail

By Craig Walls

Watch Preview Video

Businesses are increasingly recognizing the value of connecting with their customers on a more personal level. Companies can utilize social networking to transition from "Big Faceless Corporation" to "Friend" by taking their wares to the online communities where their customers are. In this age of social media, those communities are found at social network sites such as Facebook, Twitter, and LinkedIn. In this session, you'll learn how to build applications that interact with the various social networks. We'll also look at Spring Social, a new feature in the Spring portfolio that enables integration with social networks in Spring-based applications.

Session Detail

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 life cycle, 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. In this session you will learn how to build a RESTful and rich application in less than 40 minutes, honest!

By Andres Almiray

The Griffon framework can be extended via plugins. Plugins can work their magic both at build time and runtime. Building a plugin is actually an easy task however there are a few things you should know to get the most out of the Griffon plugin system.

Come and share your experiences while building a Griffon plugin. Learn from others about tips & tricks that you can apply to your projects.

By Scott Andrews

What if a user reports your application is slow? At that point, it’s too late. Runtime performance is more than an ops team’s concern. Continuous performance profiling is an important part of the agile developer’s bag of tools. Spring Insight enables developers to watch what their application is actually doing in real time and zero in on performance issues. Come to this session to learn about Spring Insight from its creators. Learn how to easily enhance the default instrumentation to gain even greater visibility into your application.

Session Detail

By Scott Andrews and Jon Travis

What if a user reports your application is slow? At that point, it’s too late. Runtime performance is more than an ops team’s concern. Continuous performance profiling is an important part of the agile developer’s bag of tools. Spring Insight enables developers to watch what their application is actually doing in real time and zero in on performance issues. Come to this session to learn about Spring Insight from its creators. Learn how to easily enhance the default instrumentation to gain even greater visibility into your application.

Session Detail

By Scott Andrews and Jeremy Grelle

The role that server-side Java plays in a web application is rapidly changing due to the rising prevalence of high-performance JavaScript VMs and browser support for advanced HTML5 APIs such as Canvas, Web Sockets, and Web Workers. This session will show how a RESTful Java back end built with Spring can provide scalable rich data and services to complement a smart client-side framework such as jQuery, Dojo, or GWT and its use of the HTML5 APIs.

This session is aimed at experienced Java web developers. It will cover:

-Rapidly building lightweight RESTful services with Spring 3.0 and Spring Roo to support rich HTML5 clients

-How to carry over the concepts of Java EE APIs such as JPA and Bean Validation to a smart client

-Async message-based communication over Web Sockets.

By Jean Barmash

This talk will examine various techniques and solutions for extending the Grails UI in interesting ways. The underlying platform for Grails offers a powerful combination of great ideas, such as scaffolding, sitemesh templates, taglibs, templates, and other that get us nice and close to DRY goal. We will examine several plugins and techniques that take these ideas even further, resulting in yet another boost to productivity.

We will start with diving a bit deeper into the scaffolding generation process, and then focus on several plugins that help ease UI development, including some scaffolding plugins and ZKGrails.

By Jean Barmash

The ZK Framework is a RIA AJAX framework that encourages server side development to create Rich Internet Application. It abstracts AJAX calls for you and allows you to code all of your UI logic in Groovy or Java, without having to spend a lot of time worrying about generated HTML / CSS / JavaScript, and getting all those technologies to work together along with Grails backend. The ZKGrails integrates ZK with Grails, including automatic component binding with GORM.

As a result you can use Grails strengths (GORM, Services) along with the productivity of ZK framework.

By Swapnil Bawaskar and Costin Leau

A pragmatic look on how to achieve easy gains in a Spring application through caching. This session will analyze the usual bottlenecks found in common application stacks and ways to address them. Various caching patterns will be discussed, with focus not just on performance but also scalability.

Session Detail

By Chris Beams

Spring 3.1 introduces a number of often-requested configuration features. Need a standalone datasource in dev, but one from JNDI in production? Environment-Specific Bean Definitions are a first-class approach to solving this very common kind of problem. Love code-based configuration, but need the power and concision of Spring XML namespaces? Spring's new *Builder APIs are what you need.

Session Details

By Chris Beams

Spring 3.1 introduces a number of often-requested configuration features. Need a standalone datasource in dev, but one from JNDI in production? Environment-Specific Bean Definitions are a first-class approach to solving this very common kind of problem. Love code-based configuration, but need the power and concision of Spring XML namespaces? Spring's new *Builder APIs are what you need.

Session Details

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

In this talk we'll look at the new Spring Security Core plugin and its dependent plugins. The core plugin provides all of the standard functionality you expect from a security plugin (URL security, users, roles, form-based authentication, etc.) and extension plugins add extra functionality such as OpenID support, LDAP authentication, object and method security with ACLs, and more.

We'll look at the various plugins and create some sample applications to see how easy it is to secure a Grails application with Spring Security.

By Burt Beckwith

Hibernate's create-drop mode is great when you're prototyping your Grails applications but once you get past the initial stages of your project you'll need to manage database changes (adding, removing, and renaming tables, columns, and indexes, refactoring data, etc.)

You can do this by hand but there are excellent tools and plugins available and in this talk we'll compare the various approaches available.

By Stephen Bohlen and Mark Pollack

In this session you will learn the basics of getting started using Spring on .NET. All your friendly features will be there to great you: dependency injection, AOP, declarative transaction management, web framework, ORM, and messaging middleware integration, but with a .NET twist. Moving beyond the Spring Framework itself, the .NET version of Spring Integration will also be discussed. Come and see how you can your existing Spring Java skills to develop easily testable POCO based .NET applications

Session Detail

By Jon Brisbin

Public clouds like Amazon EC2 and Google AppEngine have revolutionized computing and application development. But what if you already have a bunch of servers in an air-conditioned room sucking City Power like angry beavers and you want to take advantage of the economies of scale and the efficiency of virtualization that make the big clouds work, but do it in your own data center? It's not trivial, but you can host a private cloud in your own data center and your organization can benefit from transitioning your internal development to a PaaS or SaaS architecture. This session will be an end-to-end outline of creating a private cloud.

Session Detail

By David Brown and Jags Ramnarayan

NoSQL databases offer horizontal scalability through data partitioning and relaxing the consistency semantics in traditional SQL databases. But, often, this also means that developers have to relinquish the use of SQL as the querying language. This talk presents, SQLFabric, a SQL data grid that brings together Apache Derby and GemFire data grid to offer a horizontally scalable, memory oriented data management system where developers can continue to use SQL. We discuss the product features, where it strays from popular SQL databases and how it compares to other "noSQL" offerings

Session Detail

By Reid Carlberg and Ramnivas Laddad

All enterprise developers know that the data access layer of the application has the potential to be a critical bottleneck for performance and a limiting factor on application design. This session will discuss the details behind the full set of data access techniques available in the VMforce cloud platform including an in depth discussion of the JPA implementation, Spring Roo tooling and best practices for high performance cloud applications.

Session Detail

By Dave Carroll

Force.com provides a full, integrated stack of services that lets you build, test and deploy applications in the cloud. Join this session and learn about Force.com, its database, the novel metadata-driven capabilities that underpin the user interface and web service APIs, and the mobile, collaboration, security and distribution features. This session will cover the SOAP and REST web service APIs for Force.com that give access to operational control of persistence, asynchronous callouts on data changes, and a metadata API to get the data behind the data.

Session Detail

By Dave Carroll and Quinton Wall

In this lightning session, developers will learn all the essential elements necessary to use the VMforce enterprise Java cloud application platform. The session will cover basic project configuration, Force.com database support, connectivity to Force.com services, integration with the Spring framework including a quick tour of the Spring Roo add-on for VMforce. If developers can only make it to one VMforce conference session, then this Lightning Overview will give them all the information they need to get started.

Session Detail

By Cagatay Civici and Rossen Stoyanchev

It's been a year since the Sun Mojarra JSF 2 runtime became available. There is no lack of blogs and articles on what's new and noteworthy. In this session you'll learn what is important from a Spring developer's point of view:

What can I do with JSF 2? What is the status of the Spring Web Flow integration for JSF? What JSF 2 features are supported? How much value does Spring Web Flow provide in a JSF 2 world?

JSF component libraries are the key value proposition of JSF. Consequently in this session we'll use demos to show just what is possible with JSF 2 component libraries such as PrimeFaces (and RichFaces). More importantly through a series of focused showcase examples we'll cover common uses cases and reasons for using those libraries in combination with Spring Web Flow.

Last but not least this session will discuss the small Spring Faces component library, which is not going to be upgraded to support JSF 2. We'll discuss how its key features - Ajax support, modal dialogs, client side validation, and progressive enhancement, may continue to live on.

Session detail

By Roy Clarkson and Jeremy Grelle

With the rising prevalence of advanced mobile platforms such as iPhone, Android, and Web OS, the desire for rich mobile clients as another means of accessing enterprise services is becoming something that can no longer be ignored. In this session, we will explore the current mobile development landscape and discuss what you as a Spring developer can do to support this increasingly important paradigm. We will examine the benefits and tradeoffs of native mobile client development vs. web-based mobile client development, and we will explore some of the emerging cross-platform options such as PhoneGap. We will look at the various strategies for utilizing a Spring back-end with these mobile platforms, such as consumption of RESTful services, authentication and authorization via OAuth, and server-push style messaging.

Session Detail

By Andy Clement and Christian Dupuis

Spring started off to greatly increase the developer productivity; and as you all know successfully delivered on that promise. But there is more SpringSource can do to make your life as a developer more productive. In this session, we will demo current state-of-art developer tools for Spring, Roo, Groovy and Grails. We will explain how these free tools can help you along the build-run-manage lifecycle of your application and prepare you for the cloud adventure.

Session Detail

By Hamlet D`Arcy

The Groovy Programming Language advertises itself as an "agile and dynamic Language for the JVM", but what does this mean exactly? This session explains Lean Software Development, and shows how your choice of programming language can help your entire process remain nimble and adaptive.

Come learn about the principles of Lean, and see how Groovy and the associated ecosystem help eliminate waste, defer commitment, and build quality into your product. Leave with new ideas about collaboration that both developers and business users will embrace.

Audience: Team leads looking for low risk but effective ways to increase velocity.

By Hamlet D`Arcy

"The Pragmatic Programmer" admonished us all to "write code that writes code": use code generators to increase productivity and avoid duplication. Today's language communities have clearly caught on, as more and more frameworks generate code at compile time: AST Transforms, Project Lombok, Spring Roo, and more.

This session reviews these approaches including examples of how and why we'd want to do this. Come see the newest Groovy language tools, look in-depth at production deployed AST Transforms, and view libraries based on these techniques.

Audience: developers searching for cutting edge solutions to increasing team velocity.

By John Davies

Innovation in the payment landscape is accelerating. New payment options, such as micropayments, combined with new technologies, such as virtual wallets and virtual currency, is changing the payment world. Working with Incept5, SpringSource is actively engaged in Visa's effort to drive innovation in the payment landscape by defining new payment standards and payment APIs.

Session Detail

By Joshua Davis

This session will describe hands-on procedure to use the Grails Portal project as a launching pad for quickly creating web applications. The first part of the session will be spent discussing the advantages that Grails gives to developing User Portals. The second part will have a detailed discussion and examples of integrating Apache Shiro security with Grails Web Flow and the reasoning behind selecting these plug-ins. The session will conclude with a discussion on how these features can be extended to create a fully dynamic portal with personalization and other popular plug-ins.

The main topics of this session are to discuss the best ways to use Grails Scaffolding, GORM, Apache Shiro, Ajax, Grails Web-Flow, and custom GSP tags together to make software development a quick and easy process. In addition, we will be discussing interesting ways to extend the project and Grails to incorporate new functionality through Grails plug-ins. To augment the discuss, sample application and code will be presented.

By Joshua Davis

This session will describe the use of Daisy, an Open Source Content Management System (CMS) and the different options for integrating it with Grails.

The main topics of this session will be covering Grails and how it can integrate with CMS's (not just Daisy), different approaches to using CMS's based on type of applications, and the steps used when creating the Daisy Grails Plug-in. In addition, we will give an overview of how the dynamic nature of Groovy and Grails make the approach of using deploying a CMS a much simpler, and efficient solution. To augment the discussion, sample applications and code will be presented.

By Scott Davis

As software engineers, we take comfort in the idea of concrete specifications. As web developers, our hearts are either broken (frequently!), or we recognize the W3C's role is a delicate balance of leading the browser developers in new and exciting directions while, in their own words, "paving over the cow paths" of existing, de facto standards.

HTML 5 offers dramatic new improvements for page organization, offering out-of-the-box support for elements like header, footer, nav, section, and article. HTML 5 adds native support for form features such as placeholder text, autocomplete, autofocus, and validation. Additionally, there are a host of new form elements available (email, url, number, range, date, and search) that gracefully degrade in "classic" web browsers -- IE, I'm looking at you!

In this talk, you won't be subjected to discussions about the features that will appear in some distant future release of a web browser. Instead, you'll see the HTML 5 features that are already being used by Google, Apple, and others. You'll see the features that are supported by today's browsers, ready for you to use right now.

By Scott Davis

"CouchDB is built of the Web. I’ve never seen software that so completely embraces the philosophies behind HTTP." Jacob Kaplan-Moss, Django Developer

If you want to get a room full of programmers all riled up, just casually drop the word, "NoSQL." To some, NoSQL means, "death to all antiquated, 1970s-era persistence solutions!" Others take a more pragmatic approach -- "Not Only SQL" means that while relational databases are suitable for some applications, there is an emerging crop of equally viable (and interesting) persistence strategies out there.

Apache CouchDB is a schema-free document store that uses HTTP GETs, PUTs, and DELETEs instead of SQL SELECTs, INSERTs, and DELETEs. It speaks JSON fluently instead of tables, columns, and rows. It uses JavaScript Map/Reduce functions instead of SQL for the query language. It offers effortless replication among distributed CouchDB instances.

And how does Grails -- a web framework that is tightly coupled to relational databases via GORM (the Grails Object-Relational Mapping API) and Hibernate -- deal with a non-relational document store behind the scenes? I guess that you'll just have to show up to find out, won't you? If you've been around the block once or twice with Grails but are new to CouchDB, this talk offers an exploration into each technology and how they can be teased into working together.

By Rajeev Dayal and Christian Dupuis

Join us the session to learn how you can use Google's Plugin for Eclipse alongside SpringSource Tool Suite to build complex, cloud-deployable apps, and Google's Speed Tracer in conjunction with Spring Insight to measure application performance both in the browser and on the server. As Developers we're concerned with speed and efficiency -- build the fastest apps possible in the shortest amount of time. Having the right developer tools at your disposal is crucial.

Session Detail

By Keith Donald

A deep-dive into the latest capabilities of MVC, Spring's REST-ful web application development platform.

Session Detail

By Keith Donald

A deep-dive into the latest capabilities of MVC, Spring's REST-ful web application development platform.

Session Detail

By Keith Donald

This session will explore the architecture of a real-world open source web application system built on SpringSource technology. Attendees will gain insight into the technologies employed, the domain problems solved, and the project team's development practices.

Session Detail

By Keith Donald and Stefan Schmidt

Spring MVC is one of the most popular web frameworks in enterprise Java, successfully being deployed in thousands of production applications and used by millions of developers. Spring Roo delivers a set of integrated, highly-productive tooling for those developers building REST-based Spring MVC applications than can serve JavaScript, Flash, and Desktop (.NET/Swing) clients. In Spring Roo 1.1 there were significant improvements made to Roo's Spring MVC support, including fine-grained, incremental round-tripping of individual JSP elements, new integration with JQuery, and better workflow features. In this presentation attendees will discover the power of using Spring Roo to build Spring MVC applications, including detailed cover of how to get started, edit pages, add controllers and other tasks typical of MVC development.

Session Detail

By Christian Dupuis

Spring started off to greatly increase the developer productivity; and as you all know successfully delivered on that promise. But there is more SpringSource can do to make your life as a developer more productive. In this session, we will demo current state-of-art developer tools for Spring, Roo, Groovy and Grails. We will explain how these free tools can help you along the build-run-manage lifecycle of your application and prepare you for the cloud adventure.

Session Detail

By Brian Dussault and Tom McCuch

In this case study, Brian Dussault from EMC will walk through EMC's requirements and vision for the EMC Next Generation ERP solution – a Pass-by-Reference integration architecture that supports very high availability with no loss of messages across a highly distributed cloud-based deployment. Tom McCuch, a Sr. Systems Engineer with SpringSource, will demonstrate how SpringSource is meeting EMC’s requirements with a modern integration architecture optimized for the cloud that integrates Spring Integration - a highly distributed POJO-based message bus, GemFire Enterprise - a highly-distributed POJO-based data grid, and RabbitMQ – a highly distributed protocol-based messaging transport.

Session Details

By Mark Fisher, Mark Pollack, and Matthias Radestock

The Spring AMQP project's goal is to simplify development of messaging applications based on the AMQP protocol. Spring AMQP provides portable Java and .NET API across RabbitMQ and Apache Qpid implementations as well as convenient abstractions that promote a POJO based programming model. If you are familiar with Spring's JMS support, you will feel right at home. In this session you will take a tour of Spring AMQP features such as publishing, message converters, and creating multithreaded consumers. Support for the management of the RabbitMQ server will also be covered as well as its configuration using Spring.

Session Detail

By Mark Fisher

Mark and Oleg will provide a guided tour of the new features of Spring Integration 2.0 which would include the unveiling of Spring Integration ROO add-on. Along the way, you will learn about Spring Integration's support for Spring Framework 3.0 features such as the Spring Expression Language, ConversionService, and RestTemplate. You will also learn about several new adapters including AMQP, XMPP, TCP/UDP, JDBC, JMX, and more.

Details to be added

By Mark Fisher and Oleg Zhurakousky

Mark and Oleg will provide a guided tour of the new features of Spring Integration 2.0 which would include the unveiling of Spring Integration ROO add-on. Along the way, you will learn about Spring Integration's support for Spring Framework 3.0 features such as the Spring Expression Language, ConversionService, and RestTemplate. You will also learn about several new adapters including AMQP, XMPP, TCP/UDP, JDBC, JMX, and more.

Details to be added

By Jeremy Grelle

Spring BlazeDS Integration has proven itself as a powerful tool for enabling rich Flex client applications to fully take advantage of the power and flexibility of Spring-based services. The latest release of Spring BlazeDS Integration and it's accompanying addon for Spring Roo make developing Spring-backed Flex applications easier and more productive than ever. In this session developers will learn the basics of the integration and will learn how to use the Roo addon build a rich application that leverages the remoting, security, and server-push capabilities of this simple-yet-powerful technology. Along the way, we'll cover the new features in Spring BlazeDS Integration 1.5, such as first-class support for AMF serialization of Hibernate entities, that make the Roo addon possible.

Session Detail

By Jeremy Grelle

Spring BlazeDS Integration has proven itself as a powerful tool for enabling rich Flex client applications to fully take advantage of the power and flexibility of Spring-based services. The latest release of Spring BlazeDS Integration and it's accompanying addon for Spring Roo make developing Spring-backed Flex applications easier and more productive than ever. In this session developers will learn the basics of the integration and will learn how to use the Roo addon build a rich application that leverages the remoting, security, and server-push capabilities of this simple-yet-powerful technology. Along the way, we'll cover the new features in Spring BlazeDS Integration 1.5, such as first-class support for AMF serialization of Hibernate entities, that make the Roo addon possible.

Session Detail

By Ben Hale

In the future, nothing will run on bare metal; every workload will be virtualized. You'd better be ready, because your competitors will be. If not, this session will show you how to create, manage, and monitor applications and their virtual environments.

Session Detail

By Colin Harrington

Grails brings a powerful set of tools to the view layer: GSP, Views, Templates, Tag Libraries, and Layouts. Grails' Layouts seem to be the most misunderstood and underutilized component of the view layer. In this talk, we'll do a deep dive on how Grails uses Sitemesh, explore integration/customization points as well as live-coding examples of how to use some of the lesser known tags to achieve a very flexible and intuitive approach to developing DRY applications with Grails.

If you are a Grails Developer or just simply fed up with your current templating tools (I'm looking at you tiles) come learn about How Grails uses Sitemesh and apply some of the same principles to your Spring MVC applications.

By Colin Harrington

In this session we will spend some time getting to know some of the basics of Git and exploring successful tools and workflows. We will also learn how we can utilize git and git-svn to work with grails and many of ~500 plugins listed on grails.org. Finally we'll explore how to submit pull requests, format patches and contribute code back to original authors and the entire community.

Git is known as 'the fast version control system' and has gained much popularity in the last couple years for good reason. Grails itself has moved to Git and is now hosted on github - http://github.com/grails.

In this session we will spend some time getting to know some of the basics of Git and exploring successful tools and workflows. We will also learn how we can utilize git and git-svn to work with grails and many of ~500 plugins listed on grails.org. Finally we'll explore how to submit pull requests, format patches and contribute code back to original authors and the entire community.

By Ryan Heaton

OAuth is an open authorization standard that has gained significant momentum in recent years as more and more resource providers adopt it to allow users to share their private data with other applications without compromising their credentials. Some of the most notable adopters include Google, Facebook, Twitter, Yahoo, and Netflix. This broad adoption of OAuth opens the door to a rich set of valuable data and resources that can be leveraged for enormous potential by innovative application developers.

Attendees who invest their time in this session will be able to see OAuth in action, understand how it works, and learn how to use Spring Security to build an OAuth-integrated application. Developers can use OAuth for Spring Security not only as consumers to gain access to protected resources at other sites, but also as providers to add significant value to their own application by making data shareable without compromising security.

Welcome to OAuth for Spring Security!

By Ryan Heaton

OAuth is an open authorization standard that has gained significant momentum in recent years as more and more resource providers adopt it to allow users to share their private data with other applications without compromising their credentials. Some of the most notable adopters include Google, Facebook, Twitter, Yahoo, and Netflix. This broad adoption of OAuth opens the door to a rich set of valuable data and resources that can be leveraged for enormous potential by innovative application developers.

Attendees who invest their time in this session will be able to see OAuth in action, understand how it works, and learn how to use Spring Security to build an OAuth-integrated application. Developers can use OAuth for Spring Security not only as consumers to gain access to protected resources at other sites, but also as providers to add significant value to their own application by making data shareable without compromising security.

Welcome to OAuth for Spring Security!

By Alex Heneveld and Aled Sage

In this session we introduce the Monterey Spring Edition, a powerful middleware platform enabling high performance, adaptive cloud applications targeted at the Spring developer. As well as providing an overview of its core capabilities, we highlight Monterey’s integration with STS to provide a comprehensive PaaS offering enabling the development, deployment and runtime management of policy-driven elastic applications that can span the globe. Using its powerful STS extensions we build, run and manage an elastic booking service in our Monterey Cloud & refactor Spring Travel to access this service. Anyone following this who successfully books a room at the Hotel Monterey wins a mystery prize.

With the increasing demand for production-grade "cloud applications" spanning geographically distributed infrastructure, everything from Enterprise IT applications running in hybrid clouds to massively multi-player online gaming depends on being able to transparently move smaller, more manageable workloads – policy-driven application component mobility not VM migration. Cloudsoft's Monterey Middleware platform uses patented technology to provide this capability. The Monterey Spring Edition takes this a stage further featuring powerful STS extensions and wizards which provide Enterprise Java developers with all the support they need to build, run and manage elastic distributed applications.

By Jennifer Hickey

This session will cover the migration from the technical specifics all the way to motivations, project planning, and end results

Session Detail

By Jennifer Hickey

This session will cover the migration from the technical specifics all the way to motivations, project planning, and end results

Session Detail

By Paul Holmes-Higgin

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.

Conteent rich applications should make use of the new CMIS standard for managing and accessing content. This presentation explains and demonstrates the use of CMIS with the SURF framework as a 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 Alfresco's Web Quick Start, 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.

By Paul Holmes-Higgin

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.

Conteent rich applications should make use of the new CMIS standard for managing and accessing content. This presentation explains and demonstrates the use of CMIS with the SURF framework as a 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 Alfresco's Web Quick Start, 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.

By Scot Junkin

When building content-rich applications, developers often underestimate the challenge of storing the content. Spring developers now have new options for highly flexible, scalable and automated infrastructure, including inside their corporate data centers. In this session, we will look at these options, explain how to leverage them within the Spring framework, as well as share a case study of an enterprise deployment of social networking software with next generation storage technology.

Session Detail

By Scot Junkin

When building content-rich applications, developers often underestimate the challenge of storing the content. Spring developers now have new options for highly flexible, scalable and automated infrastructure, including inside their corporate data centers. In this session, we will look at these options, explain how to leverage them within the Spring framework, as well as share a case study of an enterprise deployment of social networking software with next generation storage technology.

Session Detail

By Mik Kersten

Join Mik Kersten, the CEO of Tasktop Technologies and creator of the Eclipse Mylyn project, for this discussion and demonstration session of how recent the latest Agile and ALM tools can make it dramatically easier to develop, deploy, and evolve your Spring-powered applications. This session will cover new choices for source code repositories for collaborative and social programming, new developments in issue tracking systems, and practical considerations for integrated build and integration testing. Demonstrations will feature a range of best-of-breed Agile and ALM technologies, including the latest open source tools such as Mylyn, Git and Hudson. This session will give you an overview of the state-of-the art for managing the evolution of your code evolve from concept, through Scrum planning, then into development, testing and production.

TBD

By Mik Kersten

Join Mik Kersten, the CEO of Tasktop Technologies and creator of the Eclipse Mylyn project, for this discussion and demonstration session of how recent the latest Agile and ALM tools can make it dramatically easier to develop, deploy, and evolve your Spring-powered applications. This session will cover new choices for source code repositories for collaborative and social programming, new developments in issue tracking systems, and practical considerations for integrated build and integration testing. Demonstrations will feature a range of best-of-breed Agile and ALM technologies, including the latest open source tools such as Mylyn, Git and Hudson. This session will give you an overview of the state-of-the art for managing the evolution of your code evolve from concept, through Scrum planning, then into development, testing and production.

TBD

By Paul King

An ideal way to make use of Groovy's great support for writing domain specific languages (DSLs) is when writing customer or acceptance tests. When using such an approach you typically use a high level English-like testing DSL to express the test. The approach is so popular that in fact numerous frameworks now exist for creating such tests.

We will examine a few of the more popular frameworks and glimpse at a few of the more exotic choices. Frameworks examined include EasyB, Spock, JBehave, Cucumber, Robot Framework, Slim and more. We'll also examine a range of powerful testing approaches beyond these tools which are useful for acceptance testing.

By Paul King

This talk examines how dynamic languages in general and Groovy in particular take us toward the goal of writing programs for a particular domain using phrases that look familiar to subject matter experts from that domain. Groovy, is a popular and successful dynamic language for the JVM. It offers many features that allow you to create embedded Domain Specific Languages(DSLs) including Closures, compile-time and run-time metaprogramming, command chain expressions, operator overloading, named arguments and other concise syntax conventions.

The talk highlights many of Groovy's DSL capabilities through numerous realistic examples. We'll give the example, explain the tricks used to implement the DSL, including any pros and cons as well as tackle the often forgotten but key aspects of readability vs complexity, testability, evolution, and the various considerations to keep in mind while designing 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 a brief glimpse of GPars, 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

Useful Groovy AST transforms: Lazy, Synchronized, Immutable

Concurrency libraries: Jetlang, Multiverse

A brief glimpse at GPars

Polyglot solutions with Scala and Clojure

Grid computing and cloud solutions

Testing multi-threaded programs

By Paul King

This talk looks at writing concurrent Groovy programs using GPars. GPars is a comprehensive library for parallel execution that provides a menu of options to the developer.

The different choices available have pros and cons depending on the circumstances. We'll look at the parallel collection support and the optional transparent way to use that support. Then we'll examine Map/Reduce. We'll also look at the DataFlow approach to achieving concurrency, the Actors approach and the use of Agents for delegated task coordination. Finally, we'll peek at Multiverse (Software Transactional Memory) and JCSP, two emerging approaches that might appear more prominently in future versions of GPars.

By Dave Klein

The goal of this hands-on tutorial is to get started and get productive with Grails. We’ll do this by jumping right in and building an application, from design to deployment.

Rather than try to learn Grails feature by feature, we’ll let it unfold as we build the application. We’ll begin with a simple application structure that runs right out of the box, then we’ll gradually build our application while building our knowledge of Grails. Bring your laptop and be ready to code.

We will be using Grails 1.3.5 for the exercises.

By Dave Klein

In Part II of this session, we will continue the build out process with the Grails application.

When we’re done, you’ll have learned about:

Grails Domain Classes

Dynamic scaffolding

Grails Controllers

Groovy Server Pages

GSP Tags

Grails Object Relational Mapping (GORM)

Dynamically Injected Service Classes

Grails’ Javascript and Ajax Support

URL Mapping

This is an introduction, but it is also a deep dive. So bring your laptop and be ready to code.

We will be using Grails 1.3.5 for the exercises.

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 the enterprise; EJB/JSF applications, Spring/Hibernate, legacy databases, and even non-Java applications.

Some of the strategies we will cover include:

- Integrating with existing Spring MVC applications

- JSF Integration with IceFaces

- Communicating enterprise-wide with Web Services

- 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 any web page

By Kenneth Kousen

Watch Preview Video

Groovy has excellent networking capabilities and is great at processing XML, which makes it a natural for working with RESTful web services.

In this presentation, we'll access multiple web services using Groovy, ranging from Google Charts to Amazon books to Twitter and more. We'll then build and deploy a RESTful web service, both with Groovy alone and using Grails.

By Kenneth Kousen

Watch Preview Video

Although RESTful web services have gotten better press, SOAP-based web services are often the backbone of many large enterprises. The user-friendly advances in JAX-WS 2.* make developing such services much easier. As with most Java topics, Groovy simplifies the development of web services as well. Since it is particularly well-suited to XML processing, Groovy is quite helpful in the web services and SOA worlds.

In this presentation, we'll look at how Groovy interacts with JAX-WS web services. We'll build both clients and services and discuss both the benefits and drawbacks of using Groovy in your web service development.

By Ramnivas Laddad and Quinton Wall

With the announcement of VMforce, VMware and Salesforce are building an enterprise Java Cloud that combines the Spring programming model with VMware flexibility and Force.com reliability and data integrity. This session will discuss the architecture of this new Platform-as-a-Service solution and provide a technical overview of how to run Spring applications that integrate with Force.com services. Topics will include local development, basic Force.com database support, workflow and approval, compile and debug, deployment and management, as well as service utilizations.

Session Detail

By Costin Leau

A pragmatic look on how to achieve easy gains in a Spring application through caching. This session will analyze the usual bottlenecks found in common application stacks and ways to address them. Various caching patterns will be discussed, with focus not just on performance but also scalability.

Session Detail

By Peter Ledbrook

Grails makes it incredibly easy to get a web application up and running, but it makes no guarantees about how well that application will perform and scale. If you issue hundreds of database queries per request, your application won't be a Speedy Gonzalez.

Find out how to track down and fix bottlenecks in various parts of your application, particularly database access and view rendering.

By Peter Ledbrook

It's easy for a Grails application to grow to an unmanageable size as more and more features are added. Fortunately, Grails comes with a built-in mechanism for separating an application into different concerns: plugins!

Learn how Grails fosters a plugin-oriented approach and the different techniques for enabling code reuse.

By Peter Ledbrook

Messaging in the Java world is dominated by JMS and its providers. But is it the best model for your needs? And what if you want to work with non-Java consumers or publishers?

In this session you'll learn how AMQP provides a flexible alternative to JMS and you'll be introduced to a powerful AMQP broker: RabbitMQ. You will also see a practical demonstration of how easy it is to interact with RabbitMQ from a Grails application along with some common scenarios.

By Charles Lee and Chris Richardson

Most people agree that the future of computing is in the cloud. However, what does that imply about how you develop or migrate existing applications to the new environment? Leveraging the lightweight and portable Spring framework appears to be a requirement to creating such applications. However, is that enough? Furthermore, is the cloud of the future in your private data center or in the public infrastructure? Will nirvana be achieved when we create the hybrid cloud to capture the best of both private and public clouds? Please join us as we walk through the evolution and the scenarios of various IaaS, PaaS, and future technologies yet to be made available.

Session Detail

By Josh Long

Spring Integration is a powerful integration framework that enables you to connect your application to the events that are relevant to your business. Unless it doesn't know how. In this talk, the attendee will explore the wide world of Spring Integration adapters, endpoints and general components. The attendee will work through understanding the lifecycle and makeup of existing adapters in Spring Integration, and then look to building custom adapters tailored to a specific business case. This talk is ideal for engineers and architects who want to embrace and extend this very powerful integration framework.

Session Detail

By Maudrit Martinez, Anatoly Polinsky, and Vipul Savjani

Creating a distributed highly scalable system to process close to real time transaction authorization is always a good architecture challenge. Learn how Accenture combined best of breed open source technologies, emerging JVM languages and industrialize architecture approaches to deliver a high performance solution.

This session covers the key use cases implemented, technology stack selection and how Spring Integration, Spring Batch, Distributed Cache, Scala Programming Language and other technologies were applied in the design of the solution.

Session Detail

By Steve Mayzak

Steve will present how to use tc Server Spring Edition to gain visibility into your Spring based applications in real-time. He will explain how tc server builds on the proven base of tomcat to make it ready for the enterprise. He will then demonstrate how to instrument an application with the Spring Edition of tc server, deploy it and then showcase real-world examples of what this visibility really means to you.

Session Detail

By Steve Mayzak

Steve will present how to use tc Server Spring Edition to gain visibility into your Spring based applications in real-time. He will explain how tc server builds on the proven base of tomcat to make it ready for the enterprise. He will then demonstrate how to instrument an application with the Spring Edition of tc server, deploy it and then showcase real-world examples of what this visibility really means to you.

Session Detail

By Tom McCuch

In this case study, Brian Dussault from EMC will walk through EMC's requirements and vision for the EMC Next Generation ERP solution – a Pass-by-Reference integration architecture that supports very high availability with no loss of messages across a highly distributed cloud-based deployment. Tom McCuch, a Sr. Systems Engineer with SpringSource, will demonstrate how SpringSource is meeting EMC’s requirements with a modern integration architecture optimized for the cloud that integrates Spring Integration - a highly distributed POJO-based message bus, GemFire Enterprise - a highly-distributed POJO-based data grid, and RabbitMQ – a highly distributed protocol-based messaging transport.

Session Details

By Richard McDougall

Have you ever wondered how the low level magic of virtual machines works? Have you ever wondered if an application would run differently when it's virtualized, if there are overheads, or what other impacts there might be?

This is a deep technical dive about how virtualization technology works, so that we can fully understand what the implications of developing and deploying applications in a virtual environment.

In this deep dive, we bring virtualization back to basics, and expore the underlying architecture of VMware Workstation, Fusion and datacenter vSphere hypervisors.

We'll learn about how Java runs in a virtual machine environment, give some concrete demonstrations of performance so you can see what to expect in the real world. We'll cover how to optimally setup Java to run best in a virtual environment, including tips and tricks.

We will also learn about how to diagnose and observe performance of applications in a virtual environment, from development through production.

Session Detail

By Richard McDougall

Have you ever wondered how the low level magic of virtual machines works? Have you ever wondered if an application would run differently when it's virtualized, if there are overheads, or what other impacts there might be?

This is a deep technical dive about how virtualization technology works, so that we can fully understand what the implications of developing and deploying applications in a virtual environment.

In this deep dive, we bring virtualization back to basics, and expore the underlying architecture of VMware Workstation, Fusion and datacenter vSphere hypervisors.

We'll learn about how Java runs in a virtual machine environment, give some concrete demonstrations of performance so you can see what to expect in the real world. We'll cover how to optimally setup Java to run best in a virtual environment, including tips and tricks.

We will also learn about how to diagnose and observe performance of applications in a virtual environment, from development through production.

Session Detail

By Sudhir Menon and Jags Ramnarayan

Demand spikes are getting to be far more unpredictable than ever before. One way to achieve predictably low latencies is through main-memory data grids. In this talk, we explore the various features offered by GemFire (and other popular data grids) like Synchronous/asyncrhonous replication, hash or relationship based partitioning, hierarchical caching, parallel behavior execution on data nodes, dynamic rebalancing of data and behavior, etc all from a perspective of managing continuously changing load patterns. We will discuss pros and cons of different approaches and provide design recommendations that can lead to better performance, higher availability and linear scalability and your applications

Session Detail

By Marty Messer

This session will present three case studies that showcase successful implementations of SpringSource Hyperic HQ and describe the resulting benefits and advantages gained by the users.

Session Detail

By David Montag and Thomas Risberg

It's getting more and more common to use non-relational data stores for storing parts of or the entire domain model. In this talk we will show you how you can easily do this with Neo4J (a "NoSQL" graph database) using new features now available in Spring and in Roo. We will introduce the Neo4J database and some graph database concepts. After that we will look at new Spring features that makes it easier to work with the Neo4J graph model. The talk will also highlight support now available in Roo for persisting entity classes in Neo4J.

Session detail

By Justin Murray

In this session, you will learn the key things to consider when you take your application to a virtualization platform, in particular to VMware ESX. The choice of configured memory sizes, virtual CPUs, timekeeping strategies and general virtual machine monitoring will be explored. Best practices will be detailed in each section. An example performance test project will also be shown.

Session Detail

By Justin Murray

In this session, you will learn the key things to consider when you take your application to a virtualization platform, in particular to VMware ESX. The choice of configured memory sizes, virtual CPUs, timekeeping strategies and general virtual machine monitoring will be explored. Best practices will be detailed in each section. An example performance test project will also be shown.

Session Detail

By Peter Niederwieser

Spock is a developer testing framework for Java and Groovy applications. Even though it is fully JUnit-compatible on the outside, Spock isn't just another JUnit clone - its goal is to take developer testing to the next level! With its Groovy-powered and highly expressive testing language, Spock boosts productivity and brings back the fun to testing.

In the first part of this session, Spock's approach to state-based, data-driven, and behavior-based testing will be demonstrated. Next, we will explore some of Spock's extensions, in particular the Grails plugin and the Spring TestContext Framework integration. Finally, we will look under the covers of Spock and write our own extension. Along the way, expect to see lots of code and live demos.

By Peter Niederwieser

Geb is a next generation Functional Web Testing tool that removes the ceremony and tedium of traditional web testing, leaving you with a concise, pragmatic and productive environment in which to work. It combines the power of Groovy with the WebDriver/Selenium 2.0 browser automation library to provide a programmer's DSL for modeling pages (known as the PageObject Pattern) and easily automating real browsers such as Internet Explorer, FireFox and Chrome as well as the HTMLUnit library. Geb can be used standalone, or with testing frameworks such as Spock, JUnit, EasyB or Cucumber.

In this session, you will learn everything you need to know to start using Geb in your own projects. We will cover Geb's programming model, solve real-world testing challenges, and show how Geb integrates with your environment.

By Mark Pollack and Chris Richardson

The needs of many enterprises have stretched traditional RDBMS based solutions to the breaking point and as a result, a plethora of new non-relational storage options have appeared. In this talk your learn about some popular NoSQL database including Redis, Cassandra and MongoDB. We show how the Spring Framework is evolving to support non relational ('NoSQL') databases by bringing traditional Spring values such as portability, productivity and a unified POJO based programming model to this style of data access.

Session Detail

By Arjen Poutsma

In this session, we will take a close look at one of the new features of Spring 3.0: the RestTemplate. We will show how to use this component to interact with RESTful Web sites, varying from Flickr to Twitter and more. We will also dig deeper into the RestTemplate mechanics, and show how you can expand on these.

Details to be added.

By Arjen Poutsma

In this session, Arjen will take a look at the new features found in Spring Web Services 2.0. We will look at the improved @Endpoint programming model, Java 5+ support, the new Web service testing module, and more.

Details to be added

By Arjen Poutsma

In this session, Arjen will take a look at the new features found in Spring Web Services 2.0. We will look at the improved @Endpoint programming model, Java 5+ support, the new Web service testing module, and more.

Details to be added

By Jags Ramnarayan

Demand spikes are getting to be far more unpredictable than ever before. One way to achieve predictably low latencies is through main-memory data grids. In this talk, we explore the various features offered by GemFire (and other popular data grids) like Synchronous/asyncrhonous replication, hash or relationship based partitioning, hierarchical caching, parallel behavior execution on data nodes, dynamic rebalancing of data and behavior, etc all from a perspective of managing continuously changing load patterns. We will discuss pros and cons of different approaches and provide design recommendations that can lead to better performance, higher availability and linear scalability and your applications

Session Detail

By Chris Ramsdale

In this session Chris Ramsdale will get you up and running with Google Web Toolkit (GWT), a development toolkit for building and optimizing sophisticated browser-based applications. Starting with an overview, we'll build a hello-world sample app and then move into deeper topics including: how it works, code generators, native Javascript interop, and compiler optimizations.

Session Detail

By Chris Richardson

Cloud computing isn't just about application deployment. There is also a growing number of cloud-based web services that you can use to develop your application. One of the most well known is Amazon's Simple Storage Service. But there are many others including web services for messaging, relational and NoSQL databases, email and telephony. Using these services allows you to build highly scalable applications without the pain and cost of having to develop and operate your own infrastructure. In this presentation, you will learn how to use some of these web services. We will describe the Java libraries for interacting with them. You will learn about the benefits and drawbacks of these Web services and their typical use cases. We will describe an example application that is built using cloud services.

Session Details

By Chris Richardson

Relational databases have long been considered the one true way to persist enterprise data. But today, NoSQL databases are emerging as a viable alternative for many applications. They can simplify the persistence of complex data models and offer significantly better scalability, and performance. But using NoSQL databases is very different than the ACID/SQL/JDBC/JPA world that we have become ccustomed to. They have different and unfamiliar APIs and a very different and usually limited transaction model. In this presentation, we describe describe some popular NoSQL databases - SimpleDB, MongoDB, and Cassandra. You will learn about each database's data model and Java API. We describe the benefits and drawbacks with using NoSQL databases. Finally, you will learn how to build Java applications that use NoSQL databases in conjunction with an RDBMS.

Session Detail

By Thomas Risberg

It's getting more and more common to use non-relational data stores for storing parts of or the entire domain model. In this talk we will show you how you can easily do this with Neo4J (a "NoSQL" graph database) using new features now available in Spring and in Roo. We will introduce the Neo4J database and some graph database concepts. After that we will look at new Spring features that makes it easier to work with the Neo4J graph model. The talk will also highlight support now available in Roo for persisting entity classes in Neo4J.

Session detail

By Colin Sampaleanu

Most people agree that the future of computing is in the cloud. However, what does that imply about how you develop or migrate existing applications to the new environment? Leveraging the lightweight and portable Spring framework appears to be a requirement to creating such applications. However, is that enough? Furthermore, is the cloud of the future in your private data center or in the public infrastructure? Will nirvana be achieved when we create the hybrid cloud to capture the best of both private and public clouds? Please join us as we walk through the evolution and the scenarios of various IaaS, PaaS, and future technologies yet to be made available.

Session Detail

By Christian Schalk

With Google's announcement of App Engine for Business earlier this year, developers can now build and manage business class applications on Google's Infrastructure. This presentation will introduce Google App Engine for Business explaining how it builds on the the original App Engine product. Specifically covered will be how to build and manage a collection of enterprise applications using the new centralized administration console, as well as sneak preview demos of other upcoming features such as hosted SQL, custom domain SSL etc.

Session Detail

By Christian Schalk

In addition to Google App Engine, Google has also recently launched several new cloud technologies known as the Prediction API, and BigQuery. This talk will serve as a detailed introduction along with various demos of these new cloud technologies with an emphasis on how they can complement existing Google and third party web technologies.

Session Detail

By Stefan Schmidt

Persistence is the lifeblood of enterprise applications. Spring Roo's Java Persistence API (JPA) support has been significantly expanded in Spring Roo 1.1, including upgrades to the latest JPA 2 specification and associated implementations, new support of DataNucleus for Google App Engine deployments, Apache Solr for blazing fast enterprise search and the most highly-voted community feature: database reverse engineering (DBRE). In this session we will explore how Spring Roo's new DBRE feature ventures beyond traditional approaches to reverse engineering to offer a complete, incremental, round-trip-aware capability. We'll also explore how to add Apache Solr integration to your application in just seconds, and tour many of the other new persistence technology improvements.

Session Detail

By Stefan Schmidt

Persistence is the lifeblood of enterprise applications. Spring Roo's Java Persistence API (JPA) support has been significantly expanded in Spring Roo 1.1, including upgrades to the latest JPA 2 specification and associated implementations, new support of DataNucleus for Google App Engine deployments, Apache Solr for blazing fast enterprise search and the most highly-voted community feature: database reverse engineering (DBRE). In this session we will explore how Spring Roo's new DBRE feature ventures beyond traditional approaches to reverse engineering to offer a complete, incremental, round-trip-aware capability. We'll also explore how to add Apache Solr integration to your application in just seconds, and tour many of the other new persistence technology improvements.

Session Detail

By Melanie Spatola

This panel discussion will cover practical information for monitoring and managing production environments using VMware vFabric Hyperic HQ. The panelists will provide short case studies detailing their successful use of Hyperic and describe the direct benefits gained. The discussion portion of the session will cover real-world tips and tricks from users responsible for running Hyperic in mission critical systems.

Session Detail

By Rossen Stoyanchev

It's been a year since the Sun Mojarra JSF 2 runtime became available. There is no lack of blogs and articles on what's new and noteworthy. In this session you'll learn what is important from a Spring developer's point of view:

What can I do with JSF 2? What is the status of the Spring Web Flow integration for JSF? What JSF 2 features are supported? How much value does Spring Web Flow provide in a JSF 2 world?

JSF component libraries are the key value proposition of JSF. Consequently in this session we'll use demos to show just what is possible with JSF 2 component libraries such as PrimeFaces (and RichFaces). More importantly through a series of focused showcase examples we'll cover common uses cases and reasons for using those libraries in combination with Spring Web Flow.

Last but not least this session will discuss the small Spring Faces component library, which is not going to be upgraded to support JSF 2. We'll discuss how its key features - Ajax support, modal dialogs, client side validation, and progressive enhancement, may continue to live on.

Session detail

By Dave Syer

This presentation leads the audience through the minefield of concurrent and distributed computing starting with the basics of Java concurrency, and ending with global patterns for distributed applications. The basic principles of design for such applications are explored and it is shown how using various features of Spring (e.g. task management, scheduling, POJO adapters) can take the pain out of implementing them in many cases.

Details to be added

By Dave Syer

Spring Batch and Spring Integration are complementary technologies and ofetn get deployed together in applications. But what is the best way to manage and monitor those applications in a production environment? This presentation answers that question by looking at typical metrics and alert scenarios used by real projects, and how they have been implemented in SpringSource Hyperic.

Session Detail

By Dave Syer

Spring Batch and Spring Integration are complementary technologies and ofetn get deployed together in applications. But what is the best way to manage and monitor those applications in a production environment? This presentation answers that question by looking at typical metrics and alert scenarios used by real projects, and how they have been implemented in SpringSource Hyperic.

Session Detail

By Gil Tene

Hardware virtualization is ubiquitous and Clouds are growing in popularity, but Java runtimes and frameworks still face challenges in providing application responsiveness, consistency and scale when deployed in virtualized environments. In this session we will explore new deployment paradigms which can dramatically improve application performance and accelerate your adoption of virtualization for Spring deployments.

Session will include:

* Key architectural considerations for Java deployments under hypervisors

* Application types and their suitability for different virtualized architectures

* How to deploy existing applications on virtualized platforms to improve responsiveness, scale and throughput

* New opportunities for application innovations by leveraging elastic, virtualized and cloud-ready platforms

By Mark Thomas

When an application reaches production, the requirements for scalability and/or availability usually mean that some form of load-balancing or clustering is employed. The process of setting up a cluser is complicated by the fact that a small configuration error can have a major impact such as every request resulting in an infinite re-direct, unexpected components appearing in URLs, loss of user sessions and so on. This session will take you through the process of setting up and testing a cluster of tc Servers, highlighting the common pitfalls and explaining how to diagnose cluster configuration issues when they occur.

Session Detail

By Mark Thomas

When an application reaches production, the requirements for scalability and/or availability usually mean that some form of load-balancing or clustering is employed. The process of setting up a cluser is complicated by the fact that a small configuration error can have a major impact such as every request resulting in an infinite re-direct, unexpected components appearing in URLs, loss of user sessions and so on. This session will take you through the process of setting up and testing a cluster of tc Servers, highlighting the common pitfalls and explaining how to diagnose cluster configuration issues when they occur.

Session Detail

By Mark Thomas

Apache Tomcat is the mostly widely deployed application server in today's enterprise market. Developers, QA teams and IT managers all use Tomcat in a wide variety of deployments with incredible success. This session looks inside the popular Apache project to review some of the new features available with Apache Tomcat 7, including asynchronous request processing, memory leak protection, security improvements and simpler embedding.

Session Detail

By Mike Wiesner

Application Security is more than just authentication and authorization, which is covered by Spring Security. To defend your application from potentials attacks, you also need to think about input validation, bindings, dynamic code invocation, generic interfaces and a lot more. But your code should still stay clean and maintainable. In this session, you will see practical solutions how you can use Spring to solve these issues and also how you can protect your application from future (unknown) attacks.

Session Detail

By Mike Wiesner

Application Security is more than just authentication and authorization, which is covered by Spring Security. To defend your application from potentials attacks, you also need to think about input validation, bindings, dynamic code invocation, generic interfaces and a lot more. But your code should still stay clean and maintainable. In this session, you will see practical solutions how you can use Spring to solve these issues and also how you can protect your application from future (unknown) attacks.

Session Detail

By Mike Wiesner

In this demo based session, Mike will show you how you can use Spring Security 3, one of the most popular enterprise security frameworks, to implement Authentication and Authorization requirements in your Java Application. You will learn about the new features of Version 3.0 and 3.1, like the expression language based authorization and also about the new project Spring Security Extensions, which for example enables Kerberos/SPNEGO authentication.

Session Detail

By James Williams

Java Swing has for a long had a bad reputation of being slow, unwieldy, and a difficult platform to develop on. Griffon, a rapid application development framework using Groovy, brings that pain to an end by leveraging the best paradigms of web development on the desktop.

In this session, you'll learn how to business concepts to your applications such as:Database persistence - Printing - Charting - Form validation - Docking - Multi-document interfaces.

By David Winterfeldt

A hands on approach to developing a Flex application using Spring ActionScript with Adobe Cairngorm, remoting, annotation based autowiring, etc. Spring BlazeDS Integration will be used on the backend, but the focus will be developing the client side application. The example is built on the Greenhouse project.

Session Detail

By Rob Woollen

To truly understand the sophistication and potential of the Force.com platform we are going to peek under the kimono in this session. Join salesforce.com principal architect, Rob Woollen, as he discusses the Force.com multi-tenant architecture implementation. You’ll learn the details of how the Force.com platform maintains high performance and scalability for over 80,000 customers and thousands of cloud applications.

Session Detail

By Ari Zilka

Many architects hope the G1 and concurrentmarksweep garbage collectors can help Java applications run optimally. The problem: they randomly pause the applications – and as the heap gets bigger, the pauses grow from seconds to minutes. This talk will explore garbage collection in JVMs, the challenges of generic collectors, and how Ehcache solves the problem by managing the cache, figuring out what to keep and toss out, and hiding the cache's contents from the collector. We’ll also consider the implications of Java memory management on scaling. And we’ll demo a huge JVM running with its cache as heap objects versus letting Ehcache manage that same memory while still keeping the data inside the JVM.

Session Detail