By Tim Berglund and Matthew McCullough

Gradle is being adopted by enterprises and open-source projects alike for its ease of use, flexibility, and compatibility with existing standards. However, Gradle's true strength shines not when it is viewed as a wrapper around standards, but as a toolkit for creating your own standards to reflect your build patterns and practices. It is extensible at every level, but most powerfully at the level of Gradle plugins.

In this session, you'll learn the Gradle APIs you need to know to develop a plugin, the different ways to organize and distribute plugins, and the way you should use plugins as a means of extending the Gradle DSL to describe your build domain in a concise and idiomatic way. Examples will use real code for a plugin written by Tim and Matthew that can be used in development and automated deployment settings.

By Tim Berglund

Cassandra is a scalable, highly available, column-oriented data store in use at Facebook, Netflix, Twitter, Reddit, Rackspace, and a growing list of other deployments. It offers a compelling combination of a rich data model, a robust deployment track record, and a sound architecture—and it isn't just for web-scale operations. It might be a good fit for your Grails app!

In this session, we'll learn the basics of Cassandra, then look at how to use it for storing data in a simple Grails application. We'll work through a simple data modeling exercise and look at the code required for interfacing with this leading NoSQL solution.

By Jeff Brown

Grails represents technology that offers great flexibility and power without the complexity introduced by other Java web application frameworks.

Custom tag libraries are a snap. GSP Templates provide a simple mechanism for reusing UI elements. Sitemesh is integrated to help provide a consistent presentation across the entire application. GORM is super powerful ORM. Grails provides simple mechanisms for leveraging the power of Ajax.

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 Meta Object 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, custom meta-class implementations and Groovy's Meta Object Protocol to build flexible applications in Groovy including implementing a Domain Specific Language (DSL).

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.

By Matthew McCullough

The open source, and specifically, the Groovy, Grails, and Gradle communities are abuzz with the use of Git. But why? We'll take a anthropological look at the projects that have converted from Subversion to Git and why they decided to do so.

We'll examine the challenges and eventual successes of several Groovy and Spring project leads and their project migrations to Git. With projects such as Grails having two and a half years on the Git DVCS and Groovy recently converted, we'll dissect the more effective and social development techniques available to the core team and external contributors via Git. As a finale, we'll look at how these same Git benefits can be achieved on internal projects, or reflected back via contributions to open source Spring projects.

By Venkat Subramaniam

Java - Groovy integration just works, for most part. Calling into Java code from Groovy is pretty straight forward. Calling into Groovy from Java is easier than you may think (and that's the hard part!). There are a few rough edges you will run into when you try to call from Groovy into other languages.

In this presentation, we will take a look at integration mechanisms and how to work around the few challenges you may run into.

By Venkat Subramaniam

Multi-core processors have increased the demand to get concurrency right. Thankfully, the options for programming concurrency on the JVM has evolved from the JDK synchronize and suffer model to Software Transactional Memory and actor based concurrency.

In this presentation, we'll learn the reasons to go beyond the traditional JDK solution and how to make use of these two models from Groovy.

By Venkat Subramaniam

When I got into Java I had a "Wow, look how easy it is to implement these patterns." When I got into Groovy, I had the same reaction, but only better. The dynamic nature of Groovy makes it easier to implement some common patterns. What's better, there are some patterns that you can exploit in Groovy that are not so easy in Java. In this section, you will learn how to implement some traditional patters in Groovy, and also other patterns you are simply not used to in Java.

This presentation will go far beyond the Gang-of-four (GOF) patterns. You will learn how to implement some GOF patterns, but also some patterns that will allow you to exploit dynamic nature of Groovy and the elegance of Groovy closures.

By Venkat Subramaniam

Programming concurrency can be a pain or a pleasure depending on how you approach it. GPars is an elegant fluent library written with Java performance and Groovy conciseness and expressiveness in mind.

In this example-driven presentation, we will deep dive into GPars and learn about its capabilities and how you can put this to good use in creating your next concurrent application.

By Craig Walls

Now at version 2, the OAuth protocol is gaining widespread support. Attend this session to learn all about it. More session details to follow soon.1

Session Details

By Craig Walls

APIs are the future of the social web. Learn how to plug SaaS APIs into your app in this session. More session details to follow soon.

Session Detail

By Maciej Skierkowski

Over 60% of enterprise Java apps end up using PHP as their frontend. PaaS is a rapidly evolving technology that is getting closer to being an ideal platform for Java deployment, but without full PHP support, will never meet the needs of many enterprise developers. Spend some time getting to know what PaaS brings to Java deployment and how PHP works in PaaS as well. Anyone who attends will receive a free invitation to AppFog which now supports both Spring and PHP to test out your new knowledge.

Session Detail

By Ben Alex

Ben Alex discusses the biggest challenges facing enterprise developers as applications move the cloud and user disperse to more and more client platforms.

Session Detail

By Andres Almiray

Discover how both the Grails and Griffon frameworks bring back the fun to web and desktop development.

Grails and Griffon share a lot of history and code, its very likely that what you learn in one framework can be done in the other and viceversa. Both are pretty much on par when it comes to communication across the wire, serialization or remoting; those are precisely the options that we'll explore in this session to build a Griffon frontend powered by a Grails backend.

By Andres Almiray

Despite of all the buzz and hype around webapps over the last 8 years fact is that desktop applications are still found in many places, specially in the enterprise. However the legends are true: building desktop applications is a hard job. But it does not have to be. Enter Griffon.

Griffon aims to bring back the fun and productivity to desktop application development in the same way Grails did it (and continues to do so) on the web. Griffon is rooted in the JVM but has Grails in its DNA. This means you'll find yourself right at home if you're a Java veteran, same goes for all of you that made the jump to Grails. In this session we'll cover the basics to get you started with Griffon. How applications are structured and built. Then we'll switch gears into high speed and cover topics like threading, testing, deploying, handling of legacy code and even network and database integration.

By Scott Andrews, Ramnivas Laddad, and Tal Salmona

The session provides an overview of how to build Spring-based applications on the Cloud Foundry platform. The session will cover application configuration parameters, binding services to you application, configuration using STS and vmc commands, and deployment to both micro and public Cloud Foundry. We will also show how debugging works with Cloud Foundry. The session will also discuss application execution analysis and cover how to inspect, determine and resolve execution issues associated with running Spring applications in this cloud architecture.

Session Detail

By Scott Andrews, Jennifer Hickey, and Ramnivas Laddad

This session covers much greater detail about how Spring operates on the Cloud Foundry platform. We will also explore various options to consume services: auto-configuration, the cloud namespace, and Spring 3.1 profiles focusing on how to utilize these mechanisms effectively in various phases of application development cycle.

Session Detail

By Chris Beams and Rossen Stoyanchev

Come to this session to see Spring 3.1's new configuration enhancements in action.

Spring 3.1 offers a wealth of useful new features designed to ease

application configuration. In this session you'll learn about the

new Environment and PropertySource abstractions, bean definition

profiles, Hibernate 4 support, and others. You'll learn why you

should consider the new @Enable* annotations (a Java config

alternative to XML namespaces) for your application and how to

configure Web and even JPA applications without XML. We'll use a

range of examples throughout to demonstrate the new capabilities.

By Chris Beams

The infrastructure that supports Spring projects has seen a number of important changes in the last year – including a major redesign of the springsource.org website, migrations to Git for source control and Github for code hosting, using Gradle as a build system and much more. Come to this session to learn how to make the most of these changes. Whether your aim is learning about Spring, consuming Spring artifacts, tracking issues, building from source, or contributing code to the projects you're most interested in, you'll find that it's never been easier to interact with the Spring development teams and community at large.

Session Detail

By Burt Beckwith

In this talk we'll look at the 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

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 some advanced GORM topics including using database views to map domain classes to multiple tables, writing a Configuration subclass to fine-tune domain class mappings and customize Hibernate beyond what GORM mappings provide, how to create immutable read-only domain classes, and some tips for monitoring database access.

By Burt Beckwith

Cloud Foundry is a revolutionary open-source PaaS service from VMware and Grails applications have first-class support on the platform.

In this talk we'll look at the features of the Grails cloud-foundry and cloud-foundry-ui plugins and sample applications using supported services like MongoDB, Redis, and RabbitMQ. You'll be amazed at how easy it is to build and deploy a cloud-based application with Cloud Foundry and Grails.

By Emad Benjamin

This session shares many of the production proven methods of running Java on vSphere. Covering scalability, load balancer integration, zero-downtime of application releases, best practices, use Java API to automate VM manipulation, troubleshooting techniques, and how to improve your application architecture using vFabric components in addition to vSphere.

Session Detail

By Stephen Bohlen

In many environments today there are multiple technology stacks and the services built on the various technologies need to be able to connect to each other. In this talk we focus on interoperability between Java and .NET, showing how the Spring framework for both Java and .NET can be used to develop elegant and powerful integration solutions with NoSQL, NewSQL, Data Grids, messaging middleware, and more.

Session Detail

By Sam Brannen and Rossen Stoyanchev

This session will give attendees an overview of the new testing features in Spring 3.1 as well the new Spring MVC test support. Sam Brannen will demonstrate how to use the Spring TestContext Framework to write integration tests for Java-based Spring configuration using @Configuration classes. He'll then compare and contrast this approach with XML-based configuration and follow up with a discussion of the new testing support for bean definition profiles. Next, Rossen Stoyanchev will show attendees how testing server-side code with annotated controllers and client-side code with the RestTemplate just got a whole lot easier with the new Spring MVC test support. Come to this session to see these new Spring testing features in action and learn how you can get involved in the Spring MVC Test Support project.

Session Detail

By Jon Brisbin

The Spring Data support for NoSQL databases is designed to be useful from Java. But it's even more so from Groovy. In combination with the RabbitMQ DSL for Groovy, we'll look at making NoSQL at home in the Groovy/Grails world. We'll look at Closures as consumers, the Riak data access DSL that's part of Spring Data for Riak, and using the MongoDB support in Spring Data to NoSQL-enable a Groovy application.

Session Detail

By Jon Brisbin

The demands of modern applications are changing to be more asynchronous in nature. With the increasing popularity of event frameworks like Node.js for building applications, it's possible to event data such that updates to data in the datastore trigger a series of events in the application to do things like freshen caches, perform summary calculations, and sundry other things. This presentation will demonstrate how to event data using the Riak datastore and a postcommit hook that will send an AMQP message through RabbitMQ that can be consumed by Spring Integeration, Spring AMQP, Grails, Node.js, Ruby, or other application backends.

Session Detail

By Edward Callahan and Derek Henninger

Imagine getting your users to build their own applications, particularly the form-based, CRUD-style applications, and easily deploy to Cloud Foundry. WaveMaker enables business developers to build Spring applications using a web-based, drag and drop interface. The resulting rich-web application leverages the full benefits of Spring and is fully tailorable through standard Spring patterns. Using ASTERIA WARP enterprise application integration product, we'll demonstrate how your users can easily retrieve data from disparate sources including SalesForce.com as well as an Excel spreadsheet.

This session will describe the kinds of people who should build applications and the types of applications they can build. We'll provide real world examples and demonstrate how seasoned Spring developers can extend and WaveMaker applications to meet enterprise requirements.

Session Detail

By Roy Clarkson and Keith Donald

Come explore front-end development options for mobile apps based on HTML 5. More session details to be added soon.

Session Detail

By Roy Clarkson and Keith Donald

PhoneGap is an HTML5 app platform that allows you to author native applications with web technologies and get access to APIs and app stores. PhoneGap leverages web technologies developers already know best... HTML and JavaScript. Attend this session to learn all about PhoneGap and how to integrate it into your Spring development.

Session Detail

By Roy Clarkson and Josh Long

Learn about the everyday challenges facing developers of native Android apps, including coverage of how the Spring Android project helps. More session details to follow soon.

Session Detail

By Andy Clement and Martin Lippert

In this session we will walk through the Spring tooling landscape and demo the new and improved features. Attendees will see tooling support for Spring 3.1 in action together with improved support for annotation-based Spring programming including content-assist, validation, quick-fixes and refactorings. We will take a look at improved support for XML-based Spring programming and the tooling support for the Cloud Foundry PaaS. Then a quick tour of recent improvements in the Groovy/Grails support and our new Gradle tooling. We close this session with an overview of the general release cycle and the plan for the next releases.

Session Detail

By Andy Clement and Andrew Eisenberg

The SpringSource Tool Suite makes developing your Groovy and Grails applications significantly easier with its support for debugging, refactoring, editing, and server diagnostics. In this session, we will showcase the Groovy and Grails tooling available in STS, focusing on the more recent advances such as configurable DSL support, Grails refactoring, debugging, and direct deployment to either tcServer or the Cloud Foundry PaaS. From a build point of view we'll take a quick look at the new Gradle support and an alternative to GMaven for building your maven based mixed Java/Groovy projects.

Session Detail

By Derek Collison

This session provides an in depth look at the Cloud Foundry architecture and how understanding the platform structure can help you understand what things are possible to build with your applications. The presentation will cover the Cloud Controller, the Service Provisioning Agent and the Droplet Execution Agent.

Session Detail

By Adrian Colyer and Rod Johnson

Rod Johnson and Adrian Colyer welcome the Spring and Grails communities to SpringOne 2GX 2011 and discuss the pace of innovation in enterprise applications

Session Detail

By Jon Cook and Chris Richardson

Let’s imagine that you were asked to extend a web service without modifying the original implementation. How would you do that? And, what does it mean for a Web service to be extensible anyway? We answer these and other questions in this presentation where we describe a novel, proxy server-based approach for extending REST and SOAP APIs without having to modify the initial implementation. You will learn about the REST maturity model and what it means for a web service to be extensible. We describe how we built the proxy server using technologies such as the Spring framework, the Roo shell and Spring Data for Redis.

Session Detail

By Benjamin Corrie

SpringSource recently announced a new industry-leading Java memory management feature called "Elastic Memory for Java", which is a major step forwards in making vSphere the best place to run Java workloads. Ben will present a detailed technical look at the problem space, some best practice for running Java on virtual and an in-depth look at the new feature and what it offers. The session promises to be an engaging mix of technical insight, live demos and Q&A.

Session Detail

By Luke Daley

We all know we should be writing functional (i.e. web) tests for our Grails applications, but this can sometimes seem like too much work for not enough gain. In this talk we'll look at the current Grails plugins that are out there that can start to decrease the development and maintenance cost and make getting the coverage you need more achievable.

Firstly we'll explore the powerful combination of Geb, the Groovy browser automation library, with Spock, the Enterprise ready testing framework, as the foundation for our testing stack. From there we'll discuss how to manage test data sets using the combination of the grails-fixtures and grails-build-test-data plugins. We'll then see how to use the grails-remote-control plugin to get inside your application from your functional tests to configure and how to use the grails-develop-functional-tests plugin to decrease the cycle time when writing your tests.

Finally, we'll discuss strategies for partitioning tests into logical groups and using the remote execution facilities of Geb to have you

By Luke Daley and Peter Niederwieser

So you already know and love Spock, the Enterprise ready testing framework, but want to know how to make the most of it and take your testing to the next level? Then this talk is for you. Even if you're new to Spock, but are interested in making your testing more effective this talk is for you.

We'll start with how the combination of Spock and the Groovy language makes it easy to bring the concept of “executable specifications” to the realm of unit testing, without the ceremony but with all of the benefits, and why this is so important to the health of your system.

From there we'll discuss extending Spock through its own Extension API and support for JUnit rules, which is one way to make your tests much more expressive and maintainable.

We'll close with Spock's seamless integration with Grails 2.0, and some hidden Spock treasures that help you get even more out of your testing.

By Luke Daley

Geb is a browser automation solution for Groovy. It brings together the power of WebDriver, the elegance of jQuery content selection, the robustness of Page Object modelling and the expressiveness of the Groovy language. Geb enables more expressive, more concise, and (very importantly) more maintainable web tests.

In this session we'll explore the foundations of Geb and illustrate how it uses the language features of Groovy to make web automation and testing productive and effective. After exploring the basics we'll explore Geb's rich Content DSL and discuss patterns for achieving maintainable tests. We'll also look at how it combines with Spock, the Enterprise ready testing framework, to enable low cost executable specifications that describe user behaviour, not browser details.

By John Davies

One hundred thousand messages per second, up-times measured in years, billions of dollars a day, operations in over 100 countries, hundreds of millions of users, that's enterprise!

Regardless of what you program in and at what scale you are going to come across some form of integration, at the simpler levels the frameworks take care of almost everything but as things get more complex old solutions can get cumbersome and new ones are needed, not restricted to Java but definitely Java-centric.

John will walk you through some more challenging integration architectures and a rather unique solution with a combination of Spring Integration and C24's Integration Objects. The solution adds powerful capabilities to Spring Integration such as SWIFT, a nasty banking standard used by the world's banking industry. The talk will include architecture, code and use-cases.

Session Detail

By Scott Davis

Now that HTML5 is the standard output format for Grails 2.0, shouldn't you really dig in and see what all of the excitement is about?

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

It always amazes me when Groovy developers say, "I don't like JavaScript." Both are dynamic languages that make metaprogramming seamless, but Groovy edges out JavaScript in the race for conciseness and syntactic sugar. That is, until CoffeeScript came onto the scene.

CoffeeScript is to JavaScript as Groovy is to Java -- both give their respective base languages a thoroughly modern makeover. CoffeeScript brings string interpolation (think GStrings), null-safe property access (person?.middleName and our beloved Elvis operator), and much more to JavaScript development. Perhaps CoffeeScript founder Jeremy Ashkenas says it best: "Underneath all of those embarrassing braces and semicolons, JavaScript has always had a gorgeous object model at its heart. CoffeeScript is an attempt to expose the good parts of JavaScript in a simple way."

CoffeeScript is more than an intellectual curiosity. It is the #1 most followed project on GitHub. It ships as a standard library in Rails 3.1. But most importantly, Brendan Eich openly acknowledges that CoffeeScript is influencing the future direction JavaScript (formally, ECMAScript "Harmony"). Much of what you see in CoffeeScript today will become native to JavaScript tomorrow.

Why don't you join me and see what the fuss is all about? You'll never look at JavaScript the same way again.

By Hans Dockter

Watch Preview Video

This presentation introduces the audience to the power of Gradle through many real-world examples that are demonstrated live. By the end of the presentation, you'll understand how Gradle helps to elegantly solve the challenges that we face in our daily enterprise builds.

We'll go through such powerful concepts as: advantages of declarative over imperative build systems, convention over configuration without rigidity, task definitions and dependencies, the benefits of plugins, deep multi-project support, runtime optimizations through partial builds and harvesting existing functionality through Ant and Maven integration as well as strategies for migrating from these build tools. We will demonstrate some of the innovative goodies that come with Gradle out-of-the-box, like smart incremental builds, the Gradle Daemon and the Gradle Wrapper. We show also many of the new features like Eclipse integration, Sonar integration, Heroku integration, C/C++ support and oth

By Hans Dockter

In this talk we will cover many Gradle power features that are particularly helpful for the real heavy lifting often needed in enterprise builds.

We will start this session with the concept and advantages of autowiring the Task Dependency Graph based on the inputs and outputs. We will then talk in detail about the new dependency management features such as the new cache, customizable dynamic revision handling and customizable version conflict resolution. From there we'll explore the new extension mechanism for the Gradle DSL and introduce the Gradle daemon. We will also discuss our take on best practices for dealing with module dependencies in the enterprise and how this can be mapped with Gradle. Finally we will show how you can programatically customize the way the Gradle build model is mapped to the STS Gradle Eclipse plugin. All t

By Keith Donald

The JavaScript community is exploding with innovation. Attend this session to learn modern JavaScript patterns and libraries. More session details to be added soon.

Session Detail

By Lee Faus

Cloud deployments are becoming more common place. This presentation looks at how patterns are starting to form in the deployment of technologies that enable cloud infrastructures and how developers can take advantage of these patterns to streamline their development and deployment tasks. Specifically we will focus on consilium1 projects that leveraged these technologies with spring to support master data management for the mainframe, elastic security to support bursting to a public cloud, and connecting to existing services that are traditionally synchronous, asynchronously to support VPN connections.

Session Detail

By Mark Fisher and Thomas Risberg

This session explores how Spring technologies such as Spring Integration can be effectively used on Cloud Foundry to create scalable Spring applications.

The session will discuss execution details of numerous services (MongoDB, RabbitMQ, Redis) from a scalability and ephemeral instance management perspective.It also examines how a group of applications help address scalability constraints in different parts of a system.

By Oliver Gierke

Spring always provided sophisticated support for various data access technologies. The lately coined Spring Data project now takes the next step and introduces support for non-relational data stores like MongoDB, CouchDB, Cassandra, Redis and Riak just to name a few.

Beyond that it helps implementing data access layers in a consistent and easy-to grasp fashion, for both the NoSQL stores as well as more traditional APIs like JPA. The talk introduces the umbrella project, foundational concepts and abstractions and dives down into specialties of particular modules hands-on.

By Oliver Gierke

Domain driven design has become a ubiquitous approach to tackle complex problem domains and build a rich object model. Furthermore JPA has become the standard and widely accepted way of object persistence in the Java world.

The talk introduces the the Spring Data project in general with a focus on the JPA module that allows developers to easily implement JPA based repositories in a sophisticated way. We start with a brief analysis of a plain JPA based repository implementation and outline pain points esp. regarding the domain driven approach (lack of abstraction, tediousness of executing queries, pagination and so on). The main part of the talk then takes a look at how Spring Data JPA provides solutions to those problems.

By Oliver Gierke

If applications grow bigger, modularity becomes a key aspect regarding maintainability. Design decisions made in the early days are hardly discoverable in the codebase, inter-module dependencies grow a lot.

The talk introduces means and approaches to connect logical architecture to the codebase. Beyond that we discuss patterns and best practices around general code organization, package structures to build a solid foundation for Java applications and in how far Spring can help creating loosely coupled components and dedicated points to extend applications.

By Dan Green

Imagine being able to simply and easily provision and control your own databases, tables and schema with the blessing of your company database administrator! "It will never happen!" I hear you say? Well think again. Enabling self-service for developers is a key feature for the vFabric Data Director and vPostgres database as a service products from VMware. Attend this session to see how these new tools provide a new way to implement your solution while keeping IT and database admins happy and out of your way.

Session Detail

By Jeremy Grelle

The web has gone through periods of experimentation, stagnation, revolution, and evolution to bring us to the state we are in today. The browser vendors are once again innovating at breakneck speed while still keeping an aggressive eye towards standardization, and as web developers we have an amazing array of tools at our disposal whether developing for desktop, mobile, or any other of the emerging form factors where a modern performant browser is available. Many things that were once thought "impossible" to build with open web tools are becoming today's reality on the web.

This session will examine the techniques being applied today to create large single-page web applications. Through diving into the architecture of an in-browser IDE and other such "impossible" web applications, topics that will be covered include:

New browser facilities that can be utilized today and effective ways to experiment with what is yet-to-come

Modular approaches to building and maintaining the front-end code for large in-browser applications

Composition of small, specialized, loosely-coupled server-side modules to form a complete system

Taking advantage of the unique benefits of a cloud platform while also working within its constraints.

By Filip Hanik

This session is aimed at users who are considering an upgrade to Tomcat 7 or who have already upgraded and want to make sure they are taking full advantage of the new features available in Tomcat 7. The session will briefly cover the new features provided by the updated specifications (Servlet 3.0, JSP 2.2 & EL 2.2) before spending the bulk of the session examining the new security, authentication, authorization, resource management, reverse proxy, embedding, parallel deployment, stability and management features as well as covering the important changes in the configuration settings. The session will end with a look ahead to future plans, including Tomcat 8.

Session Detail

By Colin Harrington

There an back again: a story of a simple HTTP request's travels through the depths of an ordinary grails application running in tomcat. Grails is an amazing "convention over configuration" framework that makes the complexities of Spring, Hibernate, etc. a breeze to work with, but it is easy to overlook or misunderstand the many levels of abstraction that make this framework so powerful.

In this session we will do a deep dive of just about every layer that a simple HTTP request goes through just to do accomplish few simple tasks. We'll start with the open socket in tomcat and work our way through every layer of code that our HTTP request invokes. We'll look at Security, Url Mappings, Filters, Controllers, data-binding, Services, GORM/Hibernate/JDBC, Views, Layouts, and all of the icing in-between.

By Colin Harrington

Testing is built into grails, but many Grails apps go untested. We'll cover how to test many different artefacts as well cover many principles that have helped lead to succesfully tested Grails application.s

Testing is built into grails, but many Grails apps go untested. We'll cover how to test many different artefacts as well cover many principles that have helped lead to succesfully tested Grails application.

Adapted from a talk called "Testing the Crap out of your Grails application" We'll go beyond the basics and talk about my experiences in the 10+ Grails codebases and tems that I've had the opportunity to work with.

By Rob Harrop

With the increasing popularity of both cloud computing and polyglot programming, more and more developers are working in environments that are both multi-language and multi-platform. Of course, with many languages and many different deployment contexts, communication between system components can be problematic. Efficient communication between components requires agreement on payload formats, communication protocols and, for developer sanity, sophisticated language bindings. Thankfully, messaging systems such as RabbitMQ provide the perfect solution. RabbitMQ is a popular, open-source, multi-protocol messaging broker with bindings for many popular languages.

In this talk, Rob Harrop, a senior RabbitMQ team member, will explore some of the options that RabbitMQ provides for multi-platform messaging. Attendees will learn how to access RabbitMQ from a variety of languages including Java, Python, Ruby and Erlang, using different protocols including AMQP and STOMP, and from different environments, including in-browser messaging using WebSockets.

Session Detail

By Shawn Hartsock

Your awesome application is getting such heavy use it's starting to slow down. Learn how to add rocket fuel to your rocket fuel! I’ll use examples from my real-world experiences working with Grails applications that have been sunk by heavy load and then turned around and learned how to fly.

Discussed will be techniques for identifying what problem areas to refactor and techniques to improve through put of the application once a problem area is identified.

By Shawn Hartsock

You don’t want to have your users tell you about application performance problems. You want to know about them before they do.

vFabric Hyperic can open a window into your running Grails application. You can even use JMX to provide custom visibility to the health and performance of your Grails application.

By Justin Hartung

In this session Justin Hartung will talk with real world customers that have built and migrated legacy applications to App Engine using the Spring framework. This will be an interactive dialog with plenty of opportunity for audience participation.

Session Detail

By Juergen Hoeller

Spring Framework 3.1 continues Spring's mission with a focus on flexible Java-based configuration. This session introduces the foundational Spring 3.1 concepts such as environment profiles for application contexts, feature specifications within configuration classes, and Spring’s new caching abstraction. Finally, we’ll cover Spring’s ongoing support for enterprise Java specifications: in particular our Servlet 3.0 support.

Session Detail

By Michael Hunger

Spring Data Graph is an integration library for the open source graph database Neo4j and has been around for over a year, evolving from its infancy as brainchild of Rod Johnson and Emil Eifrem. It supports transparent AspectJ based POJO to Graph Mapping, a Neo4jTemplate API and extensive support for Spring Data Repositories. It can work with an embedded graph database or with the standalone Neo4j Server.

The session starts with a short introduction to graph databases. Following that, the different approaches using Spring Data Graph are explored in the Cineasts.net web-app, a social movie database which is also the application of the tutorial in the Spring Data Graph Guidebook. The session will also cover creating a green-field project using the Spring Roo Addon for Spring Data Graph and deploying the App to CloudFoundry.

By Mark Johnson

Grails is often considered just a quick simple web application development framework. But the truth is it is much more.

This presentation will take a Grails developer beyond 'grails generate-all' to understand how to create a maintainable, secured and high performance grails application for your enterprise.

By Mark Johnson

The factory patterns and callbacks have been around for a long time as a technique to provide flavor specific code variations. But they are awkward and hard to update. Enter Groovy closures. Imagine having the ability to inject different coding flavors using code closures. If you need a different flavor, then just pass a different code block. Now imagine that all of this works on the JVM!

This session will use hands on examples to explore how to use and create closures. In addition, during the discussion we will also discuss when it is appropriate and inappropriate to use closures in your applications.

By John Kew and Gary Russell

Spring Insight provides trace data for web-container managed threads out of the box. But, what about other application threads? Fortunately, Insight provides a pluggable architecture for enhancing the standard trace capabilities. This session discusses the use of the annotation plugin to immediately obtain valuable trace data without writing any additional code. It goes on to to describe the more advanced technique of creating a custom plugin and takes a deep dive into the new Spring Integration and JMS plugins. Finally, we discuss how you can get involved by contributing your own plugins to the community.

Session Detail

By Paul King

Groovy 1.9 includes a brand new modularisation feature which allows Groovy to be split into smaller pieces. This mechanism allows us to package up Groovy for different contexts (think enterprise servers, desktops, netbooks and phones) but also to evolve Groovy over time. It also allows module writers greater power in terms of being able to leverage many of the Groovy run-time and compile-time internal features.

This talk looks at these modularisation features including defining modules, module metadata, adding meta-programming features, integration hooks and more. We will also build our own "hello world" module from scratch.

By Paul King and Guillaume LaForge

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 writing multi-threaded, concurrent and parallel programs. We'll briefly look at leveraging legacy Java techniques such as multiple processes, multiple threads, the java.util.concurrent APIs and shared-state atomicity.

We'll then look as some useful AST transforms in core Groovy (Lazy, Synchronized, Immutable, WithReadLock and WithWriteLock) before divign headlong into 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, the use of composable asynchronous functions and the use of Agents and Active Objects.

Finally, we'll peek at Multiverse (Software Transactional Memory) and JCSP, two emerging approaches that might appear more prominently in future versions of GPars. Then we'll wrap up with a brief look at testing multi-threaded programs.

By Paul King

Over the years we have seen many debates about how best to write and maintain our programs. Should we use OO or functional? Should we use sequential or concurrent? Should we use static or dynamic typing? What design patterns should we use (or anti-patterns should we avoid)? What can we learn from the strengths and weaknesses of the many languages that are now available for us to program in?

In this talk, we give numerous examples which highlight the different ways to code and test our programs. It looks at the trade-offs that different typing and coding styles give you in terms of a number of features including: ease of reading and writing, tool support, ability to modify, ability to make concurrent, ability to test and a number of other criteria. The talk doesn't attempt to provide a single answer to what is the best one true way to code all programs but gives you many examples to ponder and many context-dependent guidelines for you to factor in to your choices.

By Dave Klein

Grails object relational mapping (GORM) is one of the most powerful features of the Grails framework. Project bootstrapping and CRUD scaffolding are nice things to get you started, but GORM continues to pay off throughout the development of an application. Even maintenance tasks become simpler and more fun with GORM.

In this presentation we’ll discover what GORM is and what it does for us. We’ll cover dynamic domain class methods, dynamic finders, one-to-many and many-to-many relationships, Hibernate Criteria Builders and more. We’ll also take a look at some things to watch out for since, after all, this is Object Relational Mapping we’re talking about.

By Dierk Koenig

Many Java developers have come to appreciate Groovy for its conciseness and scripting capabilities but not many use the language to its full extend.

In this talk we will go through some of Groovy's lesser known features by means of live coding. If you seek to make your life as a Java programmer easier by improving your Groovy Kung-Fu, this talk is for you.

By Dierk Koenig

Learn how to easily write a Grails web application that appears to your users as if it was a desktop application.

To this end, we will use the Grails ULC plugin and the UlcBuilder in a live programming experience.

By Dierk Koenig

You and your team know Java well and you have invested much to get there. But there are places in any Java project where you have to leave your preferred language to get things done: for build automation, modeling complex business domains, smart configuration, user macros, office integration, ad-hoc inspections, and more.

This session presents seven patterns on how you can leverage your Java knowledge in these areas with the help of the Groovy extension language. The seven patterns are easily remembered by their names: Super Glue, Liquid Heart, Lipstick, Keyhole Surgery, Unlimited Openness, Ghost Writer, House Elf. If you love Java and would like to see it used everywhere in your project, you will find new opportunities here.

By Kenneth Kousen

Groovy and the Spring framework are old friends. Spring includes dynamic beans that can be modified while a system is still running, and of course the Grails framework is built on top of Spring MVC. Here we'll illustrate all the ways that Groovy works with Spring, and show how a developer can take advantage of those capabilities right away.

Examples will include using Groovy beans in Spring systems, refreshable beans, inline scripted beans, aspects in Groovy, and even the Grails Spring bean builder.

By Kenneth Kousen

Watch Preview Video

Groovy was never intended to replace Java. Instead, it expands Java capabilities and makes developers' lives easier. In this presentation, we'll survey many ways to make your Java systems easier by adding Groovy.

Among the topics we'll cover are: parsing and generating XML, simplifying your build, making testing easier, quick database access, working with Spring, and mixing Groovy and Java at the code level.

By Guillaume LaForge

The latest major version of Groovy was released a few months ago, and it's time to have a closer look at what's inside!

This session will cover the improved Domain-Specific Language capabilities thanks to the command chain expressions. We'll move on to speak about the continued runtime performance improvement work to make Groovy the fastest dynamic language around. Then we'll see how more functional closures have become in this release, and we'll overview the built-in JSON support. And we'll review the most important AST transformations that have been added for removing even more boilerplate code from your code bases. And we'll finish with miscelanous coverage of improvements to the syntax, of improved and secured Groovy integration in your Java applications, and much more.

By Guillaume LaForge

Guillaume will speak about 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, demonstrating views and templates, URL route definitions, plugins, the many shortcuts to the App Engine APIs, the very readable Query DSL to query the datastore.

By Ramnivas Laddad

Scala is a language that every Java developer needs to pay attention. Its uniquely combines object orientation and static typing with functional programming, which leads to much simpler, yet efficient code. It also has enough new ideas, especially for a Java developer, to make programming fun. Scala can also leverage Java ecosystem effectively, so all the libraries and framework such as Spring that you have come to trust may be used seamlessly.

This session with take you on a tour of the Scala language exploring both object oriented and functional side. It will examine a series of examples that will convince you to go and study Scala further. You will also get a glimpse of how Scala and Spring can play together effectively.

Session Detail

By Costin Leau and James Williams

Many businesses are faced with some new data access challenges for modern applications, such as horizontal scalability of the data tier, heterogeneous data access methods, and extreme transaction processing. This presentation/demo will cover how businesses can overcome these data access challenges with the use of Spring and GemFire technologies. James will build a case for NoSQL, explain how SpringSource is making NoSQL easier via Spring-Gemfire and Spring-Data, explain how GemFire is a modern data access solution that takes a best of breed approach to managing data, and demonstrate GemFire in action the Spring/vFabric way.

Session Detail

By Peter Ledbrook

2011 is turning into a tremendously exciting year for Grails developers. One of the most important developments is the arrival of several new cloud hosting providers that work with Grails applications with minimal effort on your part. No longer do we have to look enviously at our Rails comrades who have Heroku et al.

The new batch of solutions are known as Platforms as a Service (PaaS), so this talk will first explain what this means before delving into the individual providers. You'll be able to compare what each provider offers and see how the Grails integration compares as well.

By Peter Ledbrook

It's very easy to create plugins for Grails, particularly if all you want to do is share some domain classes between projects. But even with the simplest plugins, you still need to know a few things to make integration with applications and other plugins as smooth as possible.

Learn how to make your plugins as flexible as possible, while minimising integration issues with other plugins. For example, find out how Searchable was modified to allow users to add search to domain classes provided by other plugins; and why the Release plugin switched from a DSL for its configuration to simple properties.

By Peter Ledbrook

With all the buzz around rapid web application development frameworks, are enterprise developers left looking on enviously? Not at all. Grails brings RAD to web application development in the Java enterprise and this talk discusses the integration options available to you and where difficulties may arise.

Learn how you can get Maven and Grails working together, what's involved in talking to legacy databases, and why plugins are often an ideal solution to code reuse.

By Josh Long

Spring Batch has a large user base and a good track record in production systems, but what is it all really about, and why does it work? This presentation provides a short bootstrap to get a new user started with the Batch domain, showing the key concepts and explaining the benefits of the framework. Then it goes into a deeper dive and looks at what holds it all together, with a close look at some of the most important but least understood features, including restart, retry and transactions.

Session Detail

By Josh Long

The motivation is to demonstrate how to use some of the numerous extensibility planes in the Spring framework to adapt the framework to your particular needs. Spring provides numerous SPIs for just this sort of thing. Need to handle batch processing against a custom source? Write a Spring Batch ItemSource. Want to listen for events in an external system? Write a Spring Integration adapter. Want to work with a new, transactional resource? Implement a PlatformTransactionManager. Want to render custom Spring MVC views? Implement the Spring MVC View. Want to talk to a custom RESTful endpoint? Implement an HttpMessageConverter. In this talk, Josh explores some of the powerful components that - while useful, were designed to be extended.

Session Detail

By Jeff Markham

VMware vFabric SQLFire is memory-oriented data management software delivering application data at runtime with horizontal scale and lightning-fast performance while providing developers with the well-known SQL interface and tools. Now SQL pros can more easily add a sophisticated, distributed data platform in support of applications that must accommodate shifting user load while maintaining very high performance. In this session developers will learn how to use SQLfire as their persistence layer for Spring applications with the focus on using Spring Roo to build a basic application.

Session Detail

By Dave McCrory

Hands on guide and introduction for Cloud Foundry for novices. This sessions covers the basics of accessing the Cloud Foundry platform as a service, how to use cloudfoundry.com, how to install and use Micro Cloud Foundry on your laptop, and covers the basics vmc commands for the platform. The session will provide hands on troubleshooting for developers that want to install and set-up Cloud Foundry in the session.

Session Detail

By Tom McCuch

Many businesses are faced with some new messaging challenges for modern applications, such as horizontal scalability of the messaging tier, heterogeneous messaging systems and access methods, and extreme transaction processing. This presentation/demo will cover how businesses can overcome these messaging challenges with the use of Spring and RabbitMQ technologies. Tom will build a case for AMQP, explain how SpringSource is providing AMQP support via Spring AMQP and Spring Integration, explain how RabbitMQ is a modern messaging solution that offers a reliable, highly available, scalable and portable messaging system with predictable and consistent throughput and latency, and demonstrate how Spring Integration and RabbitMQ can be progressively introduced into a standard Spring web application deployed on Cloud Foundry.

Session Detail

By Eric Mizell

Today's architects are faced with complex performance and scaling challenges with their applications. Some of the obstacles that must be overcome are overloaded/non-responsive databases, JVM heap constraints, and network I/O to name a few. The problem: how to address these obstacles without rewriting/re-architecting your applications. This talk will explore how Ehcache solves these problems by plugging in a caching layer in your applications.

Additionally, we will dive into Spring's Cache Abstraction layer, Ehcache's Automatic Resource Control (ARC), JSR107, and how these powerful tools help "keep caching simple". Finally, we will look at code examples, discuss different scaling solutions, and explore cache visibility options.

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

The development environment is moving to the cloud. Cloud deployment has changed the game for running your apps. Now cloud-based Application Lifecycle Management (ALM) tools are here to provide a seamless, pre-configured, and scalable ALM stack. In this talk we present Code2Cloud, an upcoming, open-source, cloud-hosted ALM stack developed by Tasktop and VMware. Code2Cloud removes the ALM tool setup and integration pain from your organization to provide an instant-on team collaboration environment including, tasks, source code, wiki, builds, and team management. We will discuss and demonstrate the Code2Cloud service and hosting options, the Code2Cloud architecture, and integration with the IDE.

Session Detail

By Chris Ramsdale

In this session Chris Ramsdale will get you up and running building Spring apps on Google App Engine. He'll go step-by-step building a real Spring app and identify not only the basics of App Engine, but more advanced topics such as integrating with Google's SQL Service and using App Engine's "Always on" feature to ensure high performance.

Session Detail

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 accustomed to. They have different and unfamiliar APIs and a very different and usually limited transaction model. In this presentation, we describe some popular NoSQL databases – Redis, and MongoDB. 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 the Spring Data project simplifies the development of Java applications that use NoSQL databases.

Session Detail

By Thomas Risberg

How do you get started writing an application for the cloud?

This talk will show you how to develop a real application using Spring MVC with Spring Data and MongoDB providing the persistence layer. We'll cover the Repsoitory approach as well as taking advantage of typesafe query building using QueryDSL.

By Graeme Rocher

In this session, Grails project lead Graeme Rocher will deliver an update on the latest and greats features of the Grails framework - a dynamic, web application framework based on the Groovy language and designed for Spring. Graeme will cover all the new features of Grails 2.0 including agent-based reloading, unit testing mixins, and the latest enhancements to support Servlet 3.0.

Attendees will gain key knowledge of the latest techniques for building Grails applications on the Spring platform.

By Graeme Rocher

In this session, Grails project lead Graeme Rocher, will demonstrate how you can deploy Grails applications into the Cloud and take advantage of a new age of polyglot persistence on the Grails platform.

Demonstrating persistence techniques on a variety of data stores, including Redis, MongoDB and an RDBMS, this talk will demonstrate how specific use cases can benefit from a polyglot approach to persistence allowing for scalable, Cloud-based Grails applications.

By Gary Russell and David Turanski

Building robust, cloud ready enterprise systems requires a scalable, highly available, and self-healing architecture. This session presents some real world examples illustrating how these capabilities may be implemented using Spring Integration. Scenarios include competing consumer and HA active-passive configuration using Spring Integration's Control Bus along with various enterprise adapters to implement file polling, database polling, and strict message ordering

Session Detail

By Jim Shingler

By now most everyone in web development has heard of Grails and the productivity gains though its use. But is it ready for a public facing Fortune 500 company website?

In this session we will explore the decision to use Grails, the approach and processes, and the results. We will discuss a variety of topics including:

The deployment architecture

Performance

Caching and Load Balancing

Statics

Tools: TC Server, Insight, Hyperic, STS

JVM settings

By Jim Shingler

You are creating a website and the business wants to change the content on regular basis. What are your options and why a custom CMS solution might be a good answer.

In this session we will look at the problem space requirements: Managing Content, Content Promotion, SEO, and others. We will look at some of the options and why a custom CMS might be the best option. Finally, we will explore how to approach creating a custom CMS solution.

By John Simone

The power of Spring Social and the fast and simple deployment model of Heroku combine to provide a lightning quick way to launch a Facebook application. This session will teach you how to build a Facebook application using Spring Social and deploy it to Heroku in a matter of minutes.

Session Detail

By Glen Smith

There's a lot happening in the view tier these days: layout frameworks, UI frameworks, animation, and lots more. Add Javascript and Ajax to the mix, and your view tier can quickly become an unmaintainable mess. To the rescue comes the new Grails resources infrastructure, less.css, backbone.js, twitter bootstrap, and plenty more! So come along!

This talk presents a practical refactoring of a tangled Grails UI, while exploring strategies for simplifying your view layer giving maximum flexibility and performance. Included in the talk is a discussion of the new Grails resources infrastructure, Less.css framework, Twitter Bootstrap, Backbone.js, Form & Navigation strategies and much more!

By Glen Smith

Grails productivity can be a drug - and the productivity rush can lead to a whole lot of untested, unmaintainable code. If you're written one of these bad boys, or have just take over someone else's messy Grails app, you might not know where to get started in moving your codebase to something that you are actually happy to work with. We'll cover 10 painful but classic hacks/shortcuts in Controllers, Services, Views, Taglibs & Bootstraps and how to fix them!

This hands-on talk introduces you to all the built-in Grails Unit testing infrastructure using Spock - a great new framework for simple expressible tests while we refactor 10 common Grails hacks that need work. We will be covering off 10 classic Grails hacks that affect all the core artifacts in Grails applications. If you've been putting off testing your Grails app, or found it too onerous to make happen, this is the talk for you! It's a fully interactive session, so bring your experiences and your war stories.

By Alan Stewart and James Tyrrell

See all the exciting new features soon to be released in Spring Roo 1.2, including multi-module Maven project support, JSF 2.0/PrimeFaces, and layering support.

Session Detail

By Rossen Stoyanchev

Come to this session to see how to build Java-based web apps and REST web services with Spring MVC 3.1.

Spring 3.1 has been in the making for a year and many of the changes relate to Spring MVC. In this session you'll learn why the new MVC code-based configuration may be the perfect blend between flexibility and simplicity and what makes the fully updated @MVC infrastructure a better foundation for both framework developers and framework users. We'll also cover programming model changes and new features such as flash attributes, the UriComponentsBuilder, the consumes & produces conditions, multipart request updates, and much more.

By Dave Syer

Application and platform security requirements are changing under the influence of standards like OpenID and OAuth2, and the increasing demand for lightweight and multi-language platforms. Everyone used to be happy if they could implement single sign on for their Java web applications. That's still important, but there is a growing demand for more extensive Identity Management services, both in the enterprise and for public web applications. CloudFoundry is a nice use case for this new service model: it has multi-language support and security requiements that go beyond simple single sign on. What does that mean, and what does it mean for Spring Security? Come to this presentation to find out.

Session Detail

By Max Tardiveau

The industry has seen the value of frameworks for persistence, user interface etc. But writing business logic is still a manual coding process - a problem, since it's often a significant portion of the code base. We will introduce and demonstrate a Transaction Logic Engine that plugs into Hibernate/JPA, and can express in 1 rule the equivalent of 100 lines of Java. The plug-in approach means it works out of the box for frameworks such as Spring MVC and Grails - both to be demonstrated in this hands-on talk.

Session Detail

By Gil Tene

Garbage Collection is an integral part of application behavior on Java platforms, yet it is often misunderstood. As such, it is important for Java developers to understand the actions you can take in selecting and tuning collector mechanisms, as well as in your application architecture choices. In this session, Gil Tene (CTO, Azul Systems) will review and classify the various garbage collectors and collection techniques available in JVMs today. Following a quick overview of common garbage collection techniques including generational, parallel, stop-the-world, incremental, concurrent and mostly-concurrent algorithms, we will define terms and metrics common to all collectors. We will classify each major JVM collector's mechanisms and characteristics and discuss the tradeoffs involved in balancing requirements for responsiveness, throughput, space, and available memory across varying scale levels. We will conclude with some pitfalls, common misconceptions, and "myths" around garbage collection behavior, as well as examples of how some good choices can result in impressive application behavior.

Session Detail

By James Ward

Heroku is a Polyglot Cloud Application Platform that makes it easy to deploy Spring Java and Scala apps on the cloud. Deployment is as simple as doing a "git push". This session will teach you how to deploy and scale Spring Java and Scala apps on Heroku.

Session Detail

By James Williams

Ratpack is a micro web framework for Groovy inspired by the Sinatra web framework for Ruby. Running Jetty and Groovy's template engine at its core, Ratpack is very capable and extensible while also enabling you to write single file web apps. It fits the sweet spot for problems too small for Grails, yet too big to start from scratch. Ratpack takes routes, also known as URLMappings in Grails, and makes them the star of the show.

In this session, you'll learn how to create Ratpack apps, manage the application lifecycle, authentication, and persistence, and how to interface with Grails applications. Frankie and Sammy would approve...

By Rob Winch

Spring Security is a framework that focuses on providing both authentication and authorization to Java applications. Like all Spring projects, the real power of Spring Security is found in how easily it can be extended to meet custom requirements. In this presentation Rob will incrementally apply Spring Security to an existing application to demonstrate how it can meet your authentication and authorization needs. It will also answer many of the common "how to" questions that are found on the forums. This will ensure that you can not only secure your application quickly, but ensure you understand Spring Security well enough to extend it to meet your custom requirements.

Session Detail

By Oleg Zhurakousky

Based on questions posted by the community to the Spring Integration forum, this session is focused on providing practical instruction and tips for developing integration applications. This presentation is for the developers who are familiar with Enterprise Integration patterns and some parts of the Spring Integration framework. We will cover some of the advanced and not so familiar topics such as transaction management, error handling, asynchronous processing, advanced aggregator configuration, Message Publisher, advanced configurations for various adapters and other topics.

Session Detail

By Oleg Zhurakousky

Based on questions posted by the community to the Spring Integration forum, this session will continue with the earlier discussion focused on providing practical instruction and tips for developing integration applications. This presentation is for the developers who are familiar with Enterprise Integration patterns and some parts of the Spring Integration framework. We will cover some of the advanced and not so familiar topics such as transaction management, error handling, asynchronous processing, advanced aggregator configuration, Message Publisher, advanced configurations for various adapters and other topics.

Session Detail