Session Schedule

By Adrian Colyer

Adrian Colyer discusses the application architecture emerging these days defined by a departure from server-side apps to a model characterized by smart clients and services.

By Juergen Hoeller, Graeme Rocher, and Mark Pollack

Adrian Colyer, Juergen Hoeller, Mark Pollack and Graeme Rocher present SpringSource’s Unifying Component Model, current developments regarding Big Data, and betting on Grails.

By Juergen Hoeller

In its 3.2 and 3.3 generations, the Spring Framework focuses on core features for asynchronous processing and message-oriented architectures, as well as enhancements to its caching support and its language support. The Spring Framework project also comes with a new Gradle-based build and a new GitHub-based contribution model.

In this session, we'll discuss key features in this year's Spring 3.2 and next year's Spring 3.3, including support for upcoming standards such as JCache, JMS 2.0, and not least of it all Java 8's language features. We'll also explain how we're tracking Java EE 7.

Opting for a shorter release cycle, Spring Framework 3.2 is scheduled for release in December 2012, with Spring Framework 3.3 to follow in Q4 2013. This session presents the current plan for both generations and discusses the motivation behind them.

By Juergen Hoeller and Marius Bogoevici

The continuous evolution of both the Spring Framework and the Java EE platform presents us with new challenges and opportunities for collaboration. Several recent EE services are very commonly used with Spring, e.g. Servlet 3.0, JPA 2.0 and Bean Validation. This session presents an up-to-date analysis: How do recent Spring versions (3.1/3.2) integrate with Java EE 6? How is this going to be affected by Java EE 7 in a year's time?

What kind of services may a Spring application expect from a modern Java EE server, beyond the pre-packaging of common Java APIs? How much effort does it take to add a custom selection of Java EE services to e.g. Tomcat, for use in Spring-based applications? Does it make sense to use Spring and Java EE component models such as EJB 3.1 or CDI together? What are the integration options?

By Ken Sipe

Watch Preview Video

Spock is a groovy based testing framework that leverages all the "best practices" of the last several years taking advantage of many of the development experience of the industry. So combine Junit, BDD, RSpec, Groovy and Vulcans... and you get Spock!

This is a significant advancement in the world of testing.

This session assumes some understanding of testing and junit and builds on it. We will introduce and dig deep into Spock as a test specification and mocking tool.

Prerequisite: junit

By Ken Sipe

Watch Preview Video

Groovy has been around for some time and is generally recognized as a highly productive object-oriented language with a tight association with Java. Groovy seems to be going through a second wave of popularity with a more diverse repertoire of benefits, including building, deploying and testing, in addition to rapid web development. The fastest growth of productivity tools are all powered by Groovy. Discover the Groovy Truth!

This session will start with a short introduction to Groovy and will walk through a number of groovy tools that can increase the speed of delivery of any Java software development shop. We will review the following Groovy Power Tools:

- Spock - the best unit testing and mocking tool available to a Java developer leveraging the value of a testing DSL

- Gradle - the fasting growing build tool for compiling and building Java-eco system projects.

- Geb - A groovy DSL on top of Selenium for driving web testing

- Glu - The groovy way to deploy and manage Java deployments in production

- Grails - The groovy way to develop a web application against a relational database

By Guillaume LaForge

Groovy is a very popular alternative language for the JVM that continues to bring more developer productivity and more performance after each release. In this session, after a quick overview of the key features of Groovy 1.8, we'll dive through the new developments in the recently released Groovy 2.0.

After a quick look at the key features of Groovy 1.8, including more readable Domain­Specific Languages, concurrency capabilities with the GPars library, and built­ in JSON support, we'll dive right into the most important features of Groovy 2.0! A lot of the Groovy users are using the language as a Java scripting language, or sometimes as a better Java. First of all, not all of them need the dynamic capabilities, nor do they need all the library improvements provided by Groovy. For the latter, Groovy becomes more modular with smaller core modules that you can compose. For the former, in addition to its usual dynamic features, Groovy 2.0 adds static type checking, allowing you to ensure the correctness of your code before it ships and quickly spot early errors at compile time. Also, not everybody needs dynamic features at all times, and the natural extension to static type checking is static compilation. With static compilation, Groovy 2.0 generates fast and performant bytecode like Java, and shields key parts of your code base from possible interferences of dynamic features, making critical paths both faster and immune to monkey patching. But when you need fast and performant dynamic logic, Groovy 2.0 also features the integration of the "invoke dynamic" support coming up with JDK 7 and beyond.

By Guillaume LaForge, Andrew Eisenberg, and Paul King

In this presentation, Guillaume, Paul, and Andrew will show you how to leverage Groovy to build a Domain-Specific Language (DSL) used to control a rover on Mars! Various metaprogramming techniques and integration mechanisms will be demonstrated. But the language itself is only the first part of the story. Developers cannot be expected to properly use a DSL without first-class IDE support and documentation.

The presentation will start by building the DSL from scratch, using the power of Groovy to create a concise and readable mini-language, and showing how to secure its integration. The second part of the presentation will demonstrate how to integrate the DSL into Groovy-Eclipse with custom content assist, navigation, searching, and inline documentation.

By Graeme Rocher

In this session, Grails project lead Graeme Rocher will deliver an update on the latest and greatest features of the Grails framework, including all the new features introduced in the 2.x line.

Graeme will cover the recent enhancements to the GORM persistence toolkit, unit test mixins, Maven support and the latest web novelties amongst other topics."

By Graeme Rocher

Want to understand the magic of GORM? Then this session is for you.

Grails project lead Graeme Rocher will go through a detailed presentation on how GORM works. From AST transformations to runtime metaprogramming, the nitty gritty details of GORM will be covered in depth."

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.

This session will cover all of the fundamentals of the framework and will serve as a thorough introduction to developers not familiar with the framework and also include a number of tips and tricks for developers who do have experience with the framework.

By Jeff Brown

In this session, Grails core developer Jeff Brown 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.

Jeff will cover all the new features of Grails 2.0 including agent-based reloading, unit testing mixins, really powerful new ways to express GORM queries and more. Attendees will gain key knowledge of the latest techniques for building Grails applications on the Spring platform.

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, metaclass customizations and Groovy's

Metaobject-Protocol (MOP) to build flexible applications in Groovy including implementing a Domain Specific Language (DSL).

By Venkat Subramaniam

You can program higher order functions in Groovy quite easily using closures. But the benefits of closures go far beyond that. Groovy has a variety of capabilities hidden in closures.

In this presentation, we will unlock that treasure and explore ways in which we can design applications using Groovy closures, to apply different design patterns, to create fluent interfaces, and even program asynchrony.

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

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

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 Craig Walls and Roy Clarkson

The modern web no longer is limited to desktop browsers. Smart phones and tablets have become an integral part of our daily lives. Web sites that may look good on a 22" monitor usually do not format and display well on a much smaller screen. Additionally, network speeds can limit the performance of a web site on mobile devices. Because of these reasons many developers and organizations are considering how to make their web sites accessible to all the various devices and screen sizes for which people are using. In this session, we will explore the functionality provided within the Spring Mobile project, and how you can use it to extend your Spring MVC application onto mobile and tablet devices. We'll then continue the discussion by demonstrating how you can leverage some of the popular mobile JavaScript frameworks in combination with Spring Mobile to provide a first class experience for your users on mobile devices.

Session Detail

By Craig Walls

In the modern web, user interfaces are expected to be rich, highly responsive, and available anytime, anywhere, and on any device. Round-trip server-side HTML rendering doesn't fit the bill any longer and numerous JavaScript frameworks have stepped forward to simplify development of client-side user-interfaces. With so many great options available, we now face a paradox of choice and it can be difficult to decide which UI framework best suits our needs.

In this session we'll explore a handful of the most popular client-side UI frameworks, including Backbone, Knockout, Sammy, and Spine (and others) weighing their strengths and weaknesses and helping decide which framework is most suitable for a given set of UI goals.

By Craig Walls

The modern web is rich with APIs that can be consumed by other applications, enabling an integrated experience for the users who hold accounts on the websites that front those APIs. Many of these APIs are secured with OAuth, an authorization specification for securing REST APIs. Spring Social is an extension to the Spring Framework that enables Spring applications to establish connections with those APIs on behalf of their users with little or no need to muck about in the intricacies of OAuth.

In this session, we'll explore how Spring Social brings API connectivity to Spring applications. We'll also uncover the newest features of Spring Social that make it easier than ever to link your application's users to the identities they maintain on various sites across the web.

By Hans Dockter and Luke Daley

The Gradle development team have not been taking it easy since the release of Gradle 1.0. New features and innovations are constantly being added, rough edges are being smoothed and the platform continues to expand. In this session we’ll explore the most notable additions to Gradle since the release of 1.0 and preview some of the new and exciting features just over the horizon with Gradle founder and Gradleware CEO Hans Dockter and Gradle core developer Luke Daley.

The 1.0 release was the result of many years of engineering and innovation, and its release signals an increased commitment to stability and backwards compatibility for Gradle. But Gradle will continue to evolve with a high velocity to gain new capabilities, features and increased build performance.

We’ll dig into to some of the features incorporated since the 1.0 release, such as:

Support for Build Migration

Maven import support

Parallel task execution

Improved Dependency Reporting

Improved access to the resolved dependency graph

Gradle Android Support

Improved test execution feedback on the command line

Convenient testing of Gradle upgrades via build comparison

Dependency injection for tasks, plugins and extensions

More flexible error handling (i.e. continuing on failure)

Improvements to the Tooling API (i.e. embedded Gradle)

Better scalability for large scale enterprise builds

And more.

We’ll also take a sneak peak at some of the upcoming features that will soon be available in Gradle and discuss strategies for keeping up to date with the latest Gradle developments to ensure you are getting the most out of your build tool.

By Hans Dockter

We have seen quite a few larger projects for which a naive practice of early integration between the components lead to constant breakages. Thus they were not capable to successfully build a new version of the software stack for days or even weeks. Obviously the problem of that is dramatic as no regular manual testing and capacity testing is taking place. Not only is this a massive waste of testing resources, it also leads to very long and therefore expensive feedback cycles that severely affect your time-to-market of new features. It also a likely source of conflict between the CI team and software development, as with no other means at hand, there is a desire to create stability by not adding new features or doing important refactoring.

We will present patterns on how to integrate as early as possible but at the same time keep the delivery pipeline of new features flowing. Obviously automation can't solve all the problems of software development. But it can for example help to shield against pockets of problematic pieces of software. With a good reporting it can also give valuable insights into potential organizational problems.

By Andres Almiray

Have to renew or spice up a desktop application at work? In need of a rich desktop experience but don't now where to start? If any of these sound familiar to you or you're just curious to know more about Griffon then you've come to the right place.

Griffon Jumpstart is a hands-on, heads-on-code tutorial that explains how to get started using Griffon, from the beginning up to advanced features; with a few tips an tricks sprinkled here and there that are bound to make desktop application development a joyful experience.

By Andres Almiray

Compilers are powerful tools, they pretty much translate your thoughts into machine code. Extensible compilers are even more powerful. It turns out that the Groovy compiler can be extended by means of AST transformations.

Come learn why and how popular Groovy projects like Grails, Griffon and Spock, have reached out to AST transformations and AST manipulation to boost their success. In this talk we'll dive deep into compiler specifics, by all means bring your laptop if you'd like to hack along.

By Scott Andrews

No longer are servers the exclusive holder of smarts, and clients dumb terminals. Modern application leverage the strengths of both the client and server to accomplish their tasks. No longer can a client side developer ignore the server, nor a server side developer ignore the client.

This talk will explore the interconnected world of clients and servers drawing inspiration from emerging frameworks that are pushing the limits of what’s possible. We will look at the history of web development to uncover trends that inform future development paradigms. The strengths and weaknesses of each paradigm will be discussed in order to help determine the best fit for a project.

By Stefan Armbruster

Thanks to the GORM abstraction layer introduced in Grails 2.0, adding new persistence engines is much easier compared to Grails 1.x times. During the last months the Grails Neo4j plugin was established and is now in a phase of stabilization. Despite that it's already used in production.

After introducing the building blocks of grails-data-mapping, the GORM abstraction layer's project name, I will do a live demo session. This covers usage of Neo4j in multiple setup scenarios (embedded, REST). Aside from standard Grails capabilities like rich scaffolding, datastore agnostic domain classes, etc. I want to show how a domain model is decomposed into Neo4j's nodespace and how graph specific capabilities like traversals and cypher queries can be used. Depending on the timeframe, an additional part of the talk could be a case study on our experiences when running the Grails Neo4j combo under high load in a

real production system.

By Chris Beams, Gunnar Hillert, and Rossen Stoyanchev

The WebSockets technology promises to fill a niche in web applications by enabling browsers and servers to exchange messages with high frequency, low latency and low bandwith requirements in full duplex mode. The WebSocket protocol is an IETF standard, the WebSocket API is almost standardized by the W3C, and the JSR-356 will deliver a Java API in Java EE 7. There are already implementations in node.js and in a number of Servlet containers and Java frameworks. The time is as good as ever to start digging into it and there is so much to consider — from getting familiar with the protocol and the API, to sorting through the choices on the browser and on the server side, practical challenges with browser support and network issues, and so on. Furthermore, WebSockets offer a messaging-style architecture that's in sharp contrast to the RESTful architectures that connect the web today, so learning where to draw the line will be essential.

Come to this presentation for a thorough introduction to WebSockets and some practical advice on using it in your applications.

By Burt Beckwith

The Spring framework makes up the core of Grails, providing bean management, dependency injection and transaction support. Grails controllers and the web tier use and extend Spring MVC.

In this talk we'll look at a "configuration over convention" approach to access the full power of Spring in Grails.

By Burt Beckwith

The new Grails cache plugins build on the Spring 3.1 Caching API to provide easy and transparent caching to Grails applications. Using annotations and GSP tags you can quickly configure service method, controller action, and page fragment caching to help your application scale by avoiding regenerating expensive responses and method calls.

This talk will demonstrate usage of the plugins and dig into the implementation details to show you what's available and how you can score quick performance wins.

By Burt Beckwith

Spring Security and the Grails Spring Security Core plugin have many extension points, but it's often not clear where to look when you want to change how things work for your application. In this talk we'll look at customizing behavior, from overriding configuration parameters to creating custom subclasses.

We'll look at the internals of Spring Security and the plugin to become more familiar with how things work and interconnect and what the standard workflows look like.

Some concrete examples will be demonstrated, including adding extra login fields, dynamic post-login redirects, and a custom authentication approach.

By Burt Beckwith

GORM is very powerful and makes it simple to work with databases but there are features and configuration options that aren't available or are inconvenient to work with.

In this talk we'll look at a "configuration over convention" approach to database modeling to access the full power of Hibernate in Grails.

By Emad Benjamin

This session shares many of the production proven methods of running Java on vSphere. Covering how to size JVMs, and VMs for large scale deployments. The session will have a special section on GC tuning and show how a wide range of JVMs can be tuned using a GC recipe developed over the past 15 years of actual field experience in tuning JVMs.

Three key trends and associated tuning techniques are discussed in this session. The key trends are: Consolidation, Elasticity and Flexibility, and Performance

Consolidation

Many of our customers find that their middleware deployments have proliferated and are becoming an administrative challenge associated with higher costs. We see a trend across customers who look to virtualization as a way of reducing the number of server instances. At the same time, customers are taking the consolidation opportunity to rationalize the number of middleware components needed to service a particular load. Middleware components most commonly run within a Java Virtual Machine (JVM) with an observed scale of 100 to 1000s of JVM instances and provide many opportunities for JVM instance consolidation. Hence, middleware virtualization provides an opportunity to consolidate twice – once to consolidate server instances, and, secondly, to consolidate JVM instances. This trend is far-reaching, because every IT shop on the planet is considering the cost savings of consolidation.

One customer in the hospitality sector went through the process of consolidating their server footprint and at the same time consolidated many smaller JVMs that were less than 1GB heap. They consolidated many of these smaller 1GB JVMs into 2 categories, those that were 4GB, and others that were 6GB. They performed the consolidation in such manner that the net total amount of RAM available to the application was equal to the original amount of RAM, but with fewer JVM instances. They did all of this while improving performance and maintaining good SLAs. They also reduced the cost of administration considerably due to the reduced number of JVM instances they had to manage, and refined environment that helped easily achieve SLA.

Another customer, in the insurance industry, was able to achieve the same as the above customer, but additionally was able to over-commit CPU in development and QA environments in order to save on third party software license costs.

On the other hand, sometimes we come across customers that have a legitimate business requirement to maintain one JVM for an application, and/or one JVM per a line of business. In these cases, you cannot really consolidate the JVM instances, as that would cause intermixing of the lifecycle of one application from one line of business with another. However, while such customers don’t benefit from eliminating additional JVM instances through JVM consolidation, they do benefit from more fully utilizing the available compute resource on the server hardware, that otherwise would have been underutilized in a non virtualized environment

Elasticity and Flexibility

It is increasingly common to find applications with seasonal demands. For example, many of our customers run various marketing campaigns that drive seasonal traffic towards their application. With VMware, you can handle this kind of traffic burst, by automatically provisioning new v

By Sebastian Blanc

Developing applications for mobile devices using web technologies is now well within reach. When the capabilities of HTML5 are combined with CSS3 and JavaScript, web application developers have an opportunity to develop compelling mobile applications using familiar tools.

While the HTML5 specification is still evolving, there is a lot that can be used right now to build mobile web apps. Mobile web apps are now starting to provide many of the features that were once only available to native-language-based apps in Java, Objective-C, etc.

This presentation teaches developers already familiar with web application development, how to code and structure a web app for use on the mobile platform. After explaining the skeleton of a mobile web app, we will introduce JQueryMobile and some nice HTML5 features as Geolocation, Offline caching & Local Storage. And off course, we will see how we can use all these technologies with Grails.

As demo we will built a simple clone of foursquare.

By Nenad Bogojevic

Amadeus is a leading actor in the Travel Industry. Our e-Commerce division, responsible for providing cross-channels (B2B, B2C, Travel or Airline agents) front-ends, has been developing community applications, self-hosted in a SaaS model, for now more than 10 years; they are multi-tenant, as to share the same infrastructure for all our customers.

We therefore built a highly sophisticated model of physical and logical farms, partitioning the traffic and optimizing resources. We operate 700+ JEE nodes, split in 30+ logical clusters, deployed on less than 10 physical server pools. Today, this infrastructure is delivering a billion dynamic pages per month, for more than 5 million bookings, with a 10 times factor growth expected in the coming years.

Even though thousands of parameters are available to tailor our products to any one particular needs, the recent evolution of the IT Industry towards PAAS ecosystems modified customer expectations: they are now looking for the capability to extend our applications, interact with their own IT, influence our business logic or even graphical interface.

To support this vision, we started developing an extensibility framework, based on scripting technologies. Though being language agnostic, we quickly decided to invest on the Groovy language and rely on JSR 223 to embed it into our applications.

However, transforming a multi-tenant & community SAAS ecosystem into a flexible PAAS environment implies to take up multiple challenges, especially around sandboxing – access & resource control – or productivity and production constraints, such as hot-reloading or instantaneous fallback mechanism.

This presentation will therefore focus on how Groovy and its extensibility mechanisms allow us to progress on these topics, what are the limitations faced due to its dynamicity nature, and how we’re thrilled by the new features coming in next releases.

By Stephen Bohlen and Dave Tillman

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. Come and see how you can use your existing Spring Java skills to develop easily testable POCO based .NET applications

Session Detail

By Sam Brannen and Rossen Stoyanchev

This year Sam Brannen and Rossen Stoyanchev are excited to present new developments in Spring 3.2 which include comprehensive support for testing web applications and context hierarchies with the Spring TestContext Framework as well as comprehensive support for out-of-container Spring MVC tests.

Come to this session to see these new Spring Web testing features in action.

By Jon Brisbin

The Spring Data REST project is a library for exposing Spring Data Repositories via the web. Version 1.0 supports JPA Repositories and upcoming versions will support other Spring Data Repository implementations like MongoDB and GemFire. This talk will walk you through the process of exposing JPA entities via the Spring Data Repository abstraction and then exporting them to HTTP using Spring Data REST.

We'll do a bit of live coding to create an HTML 5 application to discover and consume these RESTful endpoints. HTTP also makes a simple and interoperable wire protocol for machine-to-machine communication, so we'll cover a few ways to consume your REST services in other systems by using tools like curl, Ruby, or Node.js.

By Edward Callahan and Derek Henninger

As users become more tech-savvy their ability and desire to build their own applications grows. Gartner predicts that by 2014, business developers will build at least 25% of new business applications. Commonly these applications must access and update corporate data sources.

Increasingly business developers want to deliver mobile solutions. Gone are the days of under the desk Access, Notes and Excel applications. IT needs to enable, manage, and control these applications to ensure standards for security, reliability, and maintainability.

This session will describe the kinds of people who should build applications and the types of applications they can build. We'll demonstrate using real world examples, integrating database and web services. We will build a Dojo and Spring application from scratch. From which, we will build a native iOS and Android app using PhoneGap.

We'll also show how Spring developers can extend WaveMaker applications to meet enterprise requirements.

By Brian Cavalier and John Hann

Thicker web clients and server-side JavaScript create complexity that must be managed through architectural patterns. JavaScript hasn't yet embraced lessons learned from other platforms, like Java+Spring. Existing JavaScript MVC frameworks are too rigid and lack sufficient architectural plumbing. Javascript needs flexible architectural infrastructure for building bigger, better apps.

In this talk, Brian and John will introduce several concepts, including JavaScript Modules and Inversion of Control, and demonstrate how they alleviate many of the dominant problems encountered when building large JavaScript apps. Attendees will gain a firmer understanding of new architectural patterns and witness tangible examples of how these patterns improve testability, refactorability, composability, division of work, and team scalability.

By Cedric Champeau

Choosing a language is often a matter of taste. While a lot of people using Groovy come from a Java background, not every Java developer is willing to use Groovy because of its dynamic nature. Often, those people are disturbed by the lack of error reporting at compile time for code that would be obviously wrong in a static world. Unfortunately, by nature, Groovy cannot catch such errors because program semantics are ensured at runtime.

Well, this was before Groovy 2. In the latest version of the language, we introduced two annotations, @TypeChecked and @CompileStatic, which are precisely aimed at helping Java developers to seal the semantics of the language at compile time.

In this session, we will learn what type checking and static compilation mean and see that Groovy makes a giant step forward for those who want to totally replace Java with Groovy code."

By Roy Clarkson and Gunnar Hillert

Over the last year a number of significant changes have been made to the infrastructure and processes used within the Spring family of projects. In this presentation we will review these process changes and provide valuable insights into the tools that make it all possible. We will begin with providing a brief history, then move on to discuss the new tools being used, such as GitHub, Gradle, and Artifactory. Beyond describing the tools, we'll also illustrate how these new tools help facilitate our processes, including community contributions, release management, defect tracking, and more. Ultimately, this presentation will paint a larger picture of the development process for open source projects at Spring, and the various outlets available for community involvement.

Session Detail

By Andy Clement and Martin Lippert

More and more applications are being built with JavaScript, and not only for the client side but also utilising JavaScript server side. As the complexity of JavaScript applications increases there is a need for the tools to improve – textmate isn’t necessarily the answer! The user shouldn’t need to lower their expectations when stepping out of amazing Java tools and tackling JavaScript development. In this session we will present our vision for tooling for the JavaScript era and demo some early versions and prototypes of what we think the next generation JavaScript tools could look like.

Attendees will see a lot of live demos during the session. At the end we will open-up the session for feedback on what we’ve talked about and demo’d.

By Andy Clement and Martin Lippert

In this talk we will give an overview of the recently open-sourced and newly organized tooling landscape for Spring, Groovy/Grails and Cloud Foundry (we’ll touch on Gradle too). We will introduce the new open-sourced tooling projects and how they fit together to form our new distributions: the Spring Tool Suite and the Groovy/Grails Tool Suite. In addition to that we will demo the latest feature additions to the tools that enable you to be even more productive.

The first part of this talk will focus on Spring whilst the second part focuses on Groovy/Grails. Attend one (or both!) parts of the session.

Session Detail

By Emiliano Conde

Using any framework wrong will result in poor results, including performance. Grails can deliver excellent performance to those that ask nicely, but there are many pitfalls and landmines scattered. In this session you will learn how to architect a new application to start on the right foot when it comes to performance, avoiding costly future refactoring. For existing applications, there will be well defined processes to find out the pieces that are slowing your Grails application.

Emiliano Conde is the Founder and Lead Developer of a large open source project, jBilling, a billing system used by telcos to process millions of events a day. He will show concrete examples and techniques to isolate problematic code and fix it, all in the context of Spring and Grails.

By Emiliano Conde

Are you in the process of evaluating adopting Grails? Are you 'too comfortable' with you current Jsf/struts application but you don't want to be left behind? In this session, you will learn how to migrate a pure Java application to Grails with and emphasis of getting the least code redone while aiming to maximize those areas where Grails delivers a big productivity boost.

Emiliano Conde is the Founder and Lead Developer of a large open source project, jBilling, which recently migrated from Struts to Grails. He will share the process, tools, triks and lessons learned from this migration.

By Benjamin Corrie

Customer interest in virtualizing Java workloads has been growing exponentially year on year. For the last few years, the focus has been largely around looking for best practice guidance to mitigate concerns around virtualizing Java workloads, particularly in the area of performance. Since joining VMware, SpringSource has been investing in providing first class support for the Java runtime on vSphere with products such as EM4J. Combined with the industry-leading capabilities of the vSphere platform and the growing product portfolio around the Java ecosystem, there are many great reasons to virtualize Java.

So rather than continuing to ask the question, is it OK to virtualize Java, this session boldly aims to suggest that you would be crazy not to!

By Ellery Crane

This session will present a case study focusing on the development of a robust, horizontally scalable, enterprise CRM system at Dealer.com built primarily upon a Spring technology stack. Using a foundation of Groovy, Grails, and Spring Integration, our application has also incorporated elements of Spring AMQP, Spring Data, and a highly customized extension of Spring MVC's validation layer. In addition to these Spring staples, we've incorporated the cutting edge of other web application technology, such as MongoDB, ElasticSearch, and RabbitMQ. Furthermore, our CRM has been developed as part of a company-wide software platform powered by Grails and Spring Security.

This session will present a case study focusing on the development of a robust, horizontally scalable, enterprise CRM system at Dealer.com built primarily upon a Spring technology stack. Using a foundation of Groovy, Grails, and Spring Integration, our application has also incorporated elements of Spring AMQP, Spring Data, and a highly customized extension of Spring MVC's validation layer. In addition to these Spring staples, we've incorporated the cutting edge of other web application technology, such as MongoDB, ElasticSearch, and RabbitMQ. Furthermore, our CRM has been developed as part of a company-wide software platform powered by Grails and Spring Security.

By Luke Daley

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.

Spock has many hidden gems which we'll be going through in this session. We'll also be looking at some of the upcoming features in Spock 0.7 including; functionality and contract mixins, improved configurability, and several new lumps of syntax sugar.

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 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 your functional test suite run against multiple browsers and architectures.

By Luke Daley

The larger and more diverse your technology organization, the greater the value you can realize in standardizing your build and delivery process. Internal build standards make it easier for people to switch between teams, allowing you to more readily adjust your staffing to meet changing business needs. In this session we’ll walk through examples of leveraging Gradle’s extensibility and plugin mechanisms to develop standards, enforce compliance and deliver tailored out of the box functionality. We will also discuss how to provision such customisations throughout your enterprise in a controllable way.

Standards help establish the software development practices developed by your best engineers and communicate them to the rest of the company. Perhaps most importantly, they keep your developers from wasting time endlessly re-creating commodity portions of the build infrastructure that do not create value unique to the project they are building. Standardizing the right parts of the build makes for a lower-friction software development organization full of higher quality builds and happier engineers.

You have many company-specific standards that you would like to model across your teams.

You have a large number of projects with different languages, runtime platforms, and build systems. You would like to model a standard across all those projects.

You have tried imposing too rigid a build standard across your organization and found that it didn't work, but you still want the benefits of standardization for new and established projects alike.

Gradle Core Developer Luke Daley will show you how the Gradle build tool gives you a powerful, developer-friendly, toolkit for defining your enterprise build standards across the organization in a way that they are automatically applied to all developers without the need on their side to configure anything. Gradle adopts Maven's innovation by providing the same out-of-the-box standards for typical project types--but it doesn't stop there. The more you automate the process of software delivery, then more you end up defining your own company-specific build standards. These standards must find expression in the build tool in a native way, not as ad-hoc additions. At its heart, Gradle is not a mere provider of build standards, but a toolkit for defining your own standards as a body of tested, executable code that finds expression in a concise and idiomatic domain-specific language.

Another important aspect of an enterprise build infrastructure is provisioning the build environment. With Gradle you can avoid many scenarios where developers have to read wiki pages how to configure their local build environment. Things will just work. Furthermore the specification of the build environment is version controlled, thus making historical builds much more reproducible.

By Luke Daley

One of Gradle's attractive features is that plugins are extremely simple to write and can do anything. Gradle plugins can add new functionality, enhance existing functionality or even remove undesired functionality. If you've ever wanted to write a Gradle plugin, or are interested in the deep details of plugins, then this session is for you.

In this session we'll explore some fundamental concepts that can be used as guidelines when developing plugins and new Gradle functionality, and the role of plugins and how they can be used.

We'll look at issues such as; how to implement flexible tasks, how to support convention over configuration while maintaining flexibility, how to structure plugin stacks, building and distributing plugins and testing your plugins. We'll be developing a sample plugin during the session and discussing other real world example plugins.

By Damien Dallimore

Splunk is a Big Data platform that transforms the massive amount of heterogeneous and often totally unstructured machine data being generated across the enterprise into valuable insights and realtime operational intelligence.

Splunk exposes a rich REST API that covers every feature in the product, and we have several language SDKS to enable developers to leverage the power of the Splunk platform.

In this session I'll demonstrate how developers can use the Splunk Java SDK to :

1) easily and rapidly create big data applications without the need to write Map Reduce jobs

2) integrate Splunk search results with your existing applications

3) augment the operational visibility of the JVM apps you are building via the variety of data sources you can send to Splunk

4) use Splunk as a powerful tool throughout your development process to enhance the quality of the software you are pushing into production

Session Detail

By Manuel David

In this session we will analyze the architecture and optimization for creating a multi-site in-memory database that provides high availability for a prominent consumer service . The session will cover the use of Spring Gemfire to significantly simplify deployment in a Gemfire cluster connected together using a WAN gateway . The same approach can be used to solve other high availability, low latency problems.

Session Detail

By John Davies

Few companies have been quite at the forefront of implementing Spring Integration (Batch & Data etc.) as Incept5, this year's VMWare EMEA cloud partner. John will cover a few of the more interesting implementations from an architectural point of view, looking at the choices, the reasoning, design and some of the issues behind the implementations. From projects with no SI skills ramping up to teams of several dozen programmers to experienced teams just looking for training, best practices and better data services integration.

A number of large banks are already in production with Scala-based SI workflows, is this still leading edge or have it moved into main-stream? What next for spring Integration and the tooling, what are the clients using and asking for? John will be joined by some of the Spring Integration team so an excellent opportunity to look at the present and future of Spring Integration and tooling.

By Brian Dussault and David Winterfeldt

This session will focus on deploying and managing your Spring Application in the cloud using VMware vFabric Application Director. A series of Spring applications, increasing in complexity, will be deployed. The deployments will cover generating property files and activating Spring profiles. Some other highlights of the presentation will be deploying to VMWare vCloud & EC2, updating an existing deployment, and some general tips & tricks.

The session will begin by using a simple contact application to be deployed as a standalone webapp with an in memory DB on single node, then it will continue with a more advanced example using PostgreSQL DB on a separate node, and finally demonstrate the use and configuration of an external DB & an Apache proxy. The session will conclude with the deployment and discussion of Nanotrader, a sample trading application, with complex requirements.

Session Detail

By Emil Eifrem and Michael Hunger

Graphs are everywhere. From websites adding social capabilities to Telcos providing personalized customer services, to innovative bioinformatics research, organizations are adopting graph databases as the best way to model and query connected data. If you can whiteboard, you can model your domain in a graph database.

In this session Emil Eifrem provides a close look at the graph model and offers best use cases for effective, cost-efficient data storage and accessibility.

Take Aways: Understand the model of a graph database and how it compares to document and relational databases Understand why graph databases are best suited for the storage, mapping and querying of connected data

Emil's presentation will be followed by a Hands-on Guide to Spring Data Neo4j. Spring Data Neo4j provides straightforward object persistence into the Neo4j graph database. Conceived by Rod Johnson and Neo Technology CEO Emil Eifrem, it is the founding project of the Spring Data effort. The library leverages a tight integration with the Spring Framework and the Spring Data infrastructure. Besides the easy to use object graph mapping it offers the powerful graph manipulation and query capabilities of Neo4j with a convenient API.

The talk introduces the different aspects of Spring Data Neo4j and shows applications in several example domains.

During the session we walk through the creation of a engaging sample application that starts with the setup and annotating the domain objects. We see the usage of Neo4jTemplate and the powerful repository abstraction. After deploying the application to a cloud PaaS we execute some interesting query use-cases on the collected data.

Session Detail

By Todd Ellermann

Java/J2EE looking for something better but not sure if you can sell paying the price of a new language/framework? Not sure if Grails will work in YOUR environment?

In this session we will talk about real world application of grails in an enterprise, lessons learned and best practices.

By Andrew Elmore

Spring Integration & Spring Batch greatly simplify the process of developing enterprise integration architectures and messaging systems. This session covers architectural patterns and real world examples showing how comprehensive the capabilities of Spring Integration & Batch are, while being lightweight enough to be suitable for very high performance environments.

At C24 we work closely with a large number of major financial institutions to help them architect high volume, low latency, scalable messaging systems. It's always great fun showing a client how a handful of Spring Integration configuration files can replace large chunks of their existing codebase, typically closing dozens of bugs in the process. Moreover, the resulting design is cleaner with a consistent approach to monitoring, error handling & processing. Spring Batch allows large file processing to be wired into the same flows usually with substantial improvements in throughput.

We'll review how to maximise performance while ensuring application robustness for mission critical usage.

By Lee Faus

In this episode we look at an old worn out application that has migrated from 3 different teams and 15 team lead changes. The poor application is now showing its years and doesn't perform like it did when it was first architected. Now through the help of a new platform, this application has an opportunity to shine again. Taking a look at past projects that have gone through similar transformations we will look at patterns and processes that can be leveraged to redesign traditional JEE applications into lightweight applications using Spring, CXF, SpringMVC, and SOA. Finally, we will walk through code examples to show how quickly applications can be developed using this new stack.

Session Detail

By Mark Fisher and Mark Pollack

Join the hosts Mark Fisher and Mark Pollack for a series of 10 lightning talks by leading contributors to the Spring Integration, Batch, and Data projects. Learn all the inside tips and tricks about using these projects in exciting edge cases and get a preview of current experimental work being conducted by the R&D team.

The use-cases will cover the domains of traditional enterprise integration, SaaS integration, and Big Data workflows.

By Jonathan Fullam and Wayne Lund

Java Batch JSR-352 is an initiative chaired by Chris Vignola from IBM and includes members from RedHat, Oracle, VMware, Industry leaders, and independent consultants involved in the Enterprise Java Batch.

This presentation will cover: The influence of Spring Batch on the Java Batch spec (the Batch DSL). The evolution of requirements on Java Batch in terms of concurrency, data and application modernization, and data grids. Key design decisions for coming to a common language (JCL) of batch in terms of Jobs, Steps, Partitioning, Concurrency, Parallelization, etc. State of Java Batch; Roadmap, specification, and public access to discussions and hot topics.Influences of Java Batch on Spring Batch and the implications for the future.

By Talya Gendler and Lyor Goldstein

Spring Insight is a technology that gives visibility into an application's runtime performance and behavior. Originally intended to be used by developers and designed to be integrated with the VMware vFabric tc Server, it has long developed beyond that point. Presently, it is already used for real-live applications monitoring and is integrated with most of the current application servers in the market – such as Tomcat, JBoss and WebLogic – via a command line Java installer. As part of the development process, a lot of experience has been gained by the Spring Insight development team regarding the process of integrating an application server with the instrumentation and monitoring framework.

The purpose of this session is to describe the basic requirements from such integration and provide some insight into how one would approach such a task for a new application server

By Oliver Gierke

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

Session Detail

By Oliver Gierke

The repository abstraction layer is one of the core pieces of the Spring Data projects. It provides a consistent, interface-based programming model to allow implementing data access layers easily. The talk will start with a brief introduction and dive into best practices and implementation patterns later one.

We will conclude the session with an overview over what can actually be built on top of this generic repository abstraction and discuss integration hooks into Spring MVC and REST webservices.

By Jeremy Grelle

Web and mobile clients are getting continually more sophisticated as client processing power continues to increase and much richer APIs are provided by the given platform. One of the most mind-bending shifts that is occurring is in transitioning from a world of purely request-response, to the world of client-server full duplex communication that is enabled by the latest smart client platforms.

This session will explore the new patterns of interaction that are enabled by the latest communication methods such as WebSockets and Push-to-Device services, as well as the practical concerns of actually implementing such patterns in an application using tools such as SockJS, RabbitMQ and Spring.

By Ben Hale

In the course of creating VAS, we did a lot of work to design a useful REST API. REST is generally a very loose collection of principals that can be interpreted in many ways, so this talk would describe a more concrete idea of what a REST-ful API should look like.

In addition, the implementation of this API was done with many of the new features in Spring 3 and are a good demonstration of the power it provides.

By Colin Harrington

We will cover techniques for providing resources not contstrained to typical request/response boundaries.

This talk will cover the Servlet 3.0 Async support in Grails, message queues, and application events to a provide seamless application experience. We will also look into server push technologies, ajax long-polling, and websockets taking a look at the tools already available in the Grails community.

By Colin Harrington

Since Grails 2.0 the Resources Plugin has been included by default on new apps. The Resources Plugin provides a powerful streamlined asset pipeline that you can configure and extend. These technologies are essential for providing a performant web experience and is also under appreciated in the community.

We will be taking a deep dive into the Resources plugin, taking a look at several other configurable resource plugins and exploring how to build your own resource aware applications and plugins.

By Chris Harris

This talk will introduce the Spring Data MongoDB project. Spring Data MongoDB provides a feature rich library for writing MongoDB applications in Java. It builds upon the Spring Framework and as such promotes a POJO programming model with a strong emphasis on productivity.

The Spring MongoDB Project provides a rich object mapper, a MongoTemplate helper class to simplify common document access operations using query, criteria, and update DSLs, automatic repository interface implementations, QueryDSL integration, and cross-store persistence.

By Jennifer Hickey and Ramnivas Laddad

We've been busy making improvements and adding features since Cloud Foundry's first birthday! Come to this session to get an in-depth view of the latest and greatest in Cloud Foundry. It's easier than ever before to build and deploy your distributed polyglot applications. You will see some exciting new options, including new Java and Node runtimes and support for background workers and container-less web apps. These features allow you to create distributed apps comprised of many smaller, focused apps each written in the framework that fits its purpose best. We will also explore the latest in tooling, including new features in the STS plugin and the brand new "next gen" VMC client. We will peek under the hood to see what's new in the Cloud Foundry architecture. You may even get a sneak preview of some upcoming features! From Cloud Foundry beginner to expert, this session has something for everyone.

Session Detail

By Jennifer Hickey

Some applications simply cannot be contained. Perhaps you want to write a worker that periodically polls for updates or performs a maintenance task. Perhaps you would like to use a new lightweight web framework. You don’t necessarily want to build a WAR for these types of apps. With Cloud Foundry, you don’t have to! In this session, we will build and deploy several types of standalone applications, from distributed workers built with Spring Integration and Akka, to container-less web applications built with vert.x and spray, to bring-your-own-container apps that embed Jetty. If you’re a Java or Scala developer who likes to “think outside the container”, this talk is for you!

Session Detail

By Gunnar Hillert and Gary Russell

In this session you will learn what Spring Integration and Spring Batch are all about, how they differ, their commonalities, and how you can use Spring Batch and Spring Integration together.

We will provide a short overview of the Enterprise Integration Patterns (EIP) as described in the highly influential book of the same name. Based on these patterns, we will then see how Spring Integration enables the development of Message-driven applications. This allows you to not only modularize new or existing applications but also makes it easy to integrate with external systems.

This session will also introduce Spring Batch. Spring Batch addresses the needs of any batch process, be it complex calculations in large financial institutions or simple data migration tasks as they exist in many software development projects. We will cover what Spring Batch is, how Spring approaches the concepts of batch and how Spring handles scaling batch processes to be able to handle any volume of data.

You will also see how Spring Integration and Spring Batch maximize the reuse of the integration support provided by the core Spring Framework. In addition to providing a robust, proven foundation, this also flattens the learning curve considerably to all developers already familiar with Spring.

Session Detail

By Gunnar Hillert, Gary Russell, and Oleg Zhurakousky

Spring Integration 2.2 introduces many exciting new features including among other things new adapters supporting MongoDB, Redis and JPA. Furthermore, the transaction synchronization support was expanded, allowing for the synchronization of inherently non-transactional resources with existing transactions.

Another noteworthy addition is the ability to add behavior to individual endpoints using advice chains. For example, Spring Integration 2.2 now provides out-of-the-box support for various retry strategies.

Attend this session to learn about these and many other new features and improvements. We will also take a look at some of the things planned for Spring Integration 3.0.

By Brian Jimerson

Today's modern applications have much different requirements than traditional enterprise applications from a decade ago. Today's applications require things like multiple client channels, integration with big, unstructured data, rapid time to market, and unparalleled scalability. And most traditional enterprise development frameworks aren't well suited to meet these needs.

This session will show how application architectures have changed, and how frameworks like Grails and Spring can be used to implement modern architectures to support today's applications. Patterns such as idempotent services, horizontal and vertical scalability, and agile releases will be described, as well as how Grails and Spring are well suited for these patterns and architectures.

By Brian Jimerson

GETn2it is social marketing platform designed to sell the maximum number of live music event tickets, as well as high-margin on-night food, libation and merchandise in venue and the surrounding concert neighborhood.

There were a number of technical challenges that needed to be met by the platform, and using Grails and the Spring framework to build the platform met those challenges. Key factors like rapid prototyping, agile requirements to meet changing stakeholder needs, and aggregating and processing massive amounts of 3rd party data were all quickly met with Grails and Spring.

The innovative solution and platform was awarded the highest level of funding from the Innovation Fund as well as several rounds of investment capital. The ongoing success is due in no small part to the speed, agility and capabilities of Grails and Spring.

By Mark Johnson and David Turanski

Alternative data persistence approaches are all the rage these days. Transitioning our skill sets and legacy applications to these new and promising technologies though can be problematic. Spring Data is an exciting solution to persistence proliferation. It brings the flexibility and familiarity of the Spring Framework and adds the concepts of Repositories which allow developers to write their programs to using familiar methods such as save, update, delete, and dynamic finders.

In this presentation we will introduce Spring Data for GemFire and how it leverages your existing Spring Framework skills to create generic Spring style interfaces which will make it more efficient to transition to distributed data grids such as GemFire.

By Paul King

Groovy doesn't claim to be a fully-fledged functional programming language but it does provide the Java or Groovy developer with a whole toolbox of features for doing functional style programs. This talk looks at the key Groovy features which support a functional style. Topics covered include using closures, currying and partial evaluation, closure composition, useful functional-centric AST macros, useful functional-centric runtime meta-programming tricks, trampolining, using Java functional libraries, immutable data structures, lazy and infinite lists, using Groovy 2's static typing and approaches for moving beyond Java's type system.

There are many advantages to using a functional style in your programs. Learn what can be done to leverage functional style while retaining many of the productivity gains of the Groovy programming language.

By Paul King

Learn about the modularization features in Groovy 2.0 including everything you need to know to write and use your own modules.

Provides an overview of the modularization (m12n) mechanism in Groovy 2.0 including:

* The different parts of m12n.

* The use of m12n features within the standard distribution.

* Turning standard features on and off.

* How to write and use your own module (illustrated by making modules for some existing open source libraries).

* m12n futures (what other features are planned in future releases)

By Paul King

This talk explores how to write a TicTacToe API satisfying some interesting static typing constraints. Specifically, programs using the API may fail to compile depending on the state of play in the game, e.g. trying to call move() with an already completed game board. The real theme behind the talk is not so much in solving the TicTacToe problem but in pushing static typing to its limits (and some might argue beyond its useful limits - you will have to judge for yourself).

Various solutions to this problem are given using the Groovy programming language. The solutions range from very dynamic ones which only fail at runtime (and hence fail the original criteria) and rely on unit tests to gain confidence in their correct behavior through to several solutions which meet and exceed the problem criteria. Pointers to solutions of the problem in other languages are also given.

The API has several methods including move(), takeBack(), whoWon() which allow players to place moves onto a playing board. Programs using the API should fail compilation if players play out of turn, if takeBack is called on an empty board or if whoWon is called on a board still in play. This is a standard challenge that has been proposed to test the power of typing systems in various languages.

By Kenneth Kousen

Watch Preview Video

Groovy isn't designed to replace Java -- it just makes Java cleaner and easier to develop. This presentation will look at various tasks Java developers need to do and demonstrate ways Groovy can help.

Topics will include building and testing applications, accessing both relational and NoSQL databases, working with web services, and more.

By Kenneth Kousen

Watch Preview Video

Grails comes with extensive testing support, ranging from unit to integration to functional tests. This session will demonstrate the range of options available both natively and through testing plugins.

Topics will include testing constraints, the mock libraries for testing controllers, generating test data, the available testing annotations, and more.

Prerequisite: Some knowledge of Grails would be helpful but not assumed

By Kenneth Kousen

Watch Preview Video

Languages that support both dynamic typing and closures radically simplify the standard design patterns. This presentation will demonstrate how many of the common patterns in Java simply vanish in Groovy, and how much simpler they are even when they remain.

Patterns will include Adapter, Factory Method and Abstract Factory, Builder, Decorator, Singleton, Proxy, Visitor, and as many more as time allows.

By Kenneth Kousen

Watch Preview Video

The Spring framework has always had a friendly relationship with dynamic languages. In this presentation, we'll look at all the ways you can add Groovy to Spring to make development easier, ranging from simplifying your configuration files to deploying refreshable beans to using Spock tests in the Spring test context and more.

Groovy works comfortably with existing Java infrastructure, and Spring has special capabilities designed specifically for scripting languages. The combination is very powerful and is an easy way to take advantage of Groovy code simplification.

By Kenneth Kousen

Watch Preview Video

The Grails Object Relational Mapping (GORM) API is an elegant domain specific language on top of Hibernate. To really understand how it works, you need to understand how Hibernate sees the world. This workshop will explore the behavior of GORM, from following object state transitions to managing the session to fetching lazy associations and more.

While the focus will be Grails and understanding how it works, code samples will also be provided using plain Hibernate with the Spring Framework to manage the session factory and transactions. All examples will be built with Gradle and tested with both JUnit and Spock.

By Ramnivas Laddad

If you have deployed applications on Cloud Foundry, you know how easy it is to push an app, bind services to it, and scale it. There are more magical things behind the scenes. Did you know, for example, that cloudfoundry.com is updated approximately twice a week? Each update included small changes such as a bug fix or a new feature, but often large changes such as updating the underlying operating system. Yet, we can do all this without any downtime for user apps. Come to this talk to understand what makes this possible. Even if you aren't going to ever implement a PaaS on your own (and why should you? we already give you a good one!), the architectural ideas apply to your distributed apps quite well.

Session Detail

By Costin Leau

Hadoop is not an island. To deliver a complete Big Data solution, a data pipeline needs to be developed that incorporates and orchestrates many diverse technologies. A Hadoop focused data pipeline not only needs to coordinate the running of multiple Hadoop jobs (MapReduce, Hive, Pig or Cascading), but also encompass real-time data acquisition and the analysis of reduced data sets extracted into relational/NoSQL databases or dedicated analytical engines.

This session looks at the architecture of Big Data pipelines, the challenges ahead and how to build manageable and robust solutions using Open Source software such as Apache Hadoop, Hive, Pig, Spring Hadoop, Batch and Integration.

By Peter Ledbrook

Java is a good all-purpose programming language, but does that mean it's the best tool for all jobs? In this talk, you'll see how Groovy can scratch itches you didn't even know you had. From scripts, to writing unit tests, to building projects, we'll take you through use cases that highlight the advantages of having a second language in your toolbox.

In the second part of the talk, you'll find out how Grails simplifies web application development without sacrificing flexibility and power. Built on Spring, it eliminates the need to write a lot of plumbing for your application while still allowing you the full power of the Spring framework. You'll see how quick it is to get started with a fresh application and also how you can leverage plugins to quickly enhance your applications with power features.

By Peter Ledbrook

It's an interesting time in the world of application development. We're in the middle of a perfect storm in which cloud deployments, alternative data stores, and rich, multi-device client UIs are emerging as the future standards. What does this mean for Grails developers and what does the framework offer in this very different world?

We'll look at potential changes to the way applications are designed and how you can leverage the current and future features of Grails to take advantage of those changes.

By Kenneth Liu

This talk will cover the most underrated feature of Grails -- the plugin system. Grails plugins are usually thought of as a way to add useful features to a new Grails application, but the plugin system also provides a powerful mechanism for reuse by breaking up a large application into reusable vertical slices.

I'll start with a brief overview of Grails plugin development and expand on this to show how to create private plugins to break apart a monolithic Grails application into reusable application components. I'll show how to implement default functionality in these plugins that you can override in different applications.

The talk will be presented in the context of a real-world case study, looking at how our team launched a new website by first extracting core parts of our existing Grails application into a private plugin. I'll also discuss some lessons learned.

I will also cover related practical considerations such as dependency management, release management, CI builds, testing, and application configuration.

By Josh Long

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

Spring Integration is a lightweight integration framework from the makers of Spring. Integration of data and services between applications is not easy – and often requires adaptation from one system to another. Spring Integration also promotes loosely coupled, event-driven applications. Spring Batch is a batch processing framework – providing a simple, idiomatic way to crunch large amounts of data across in a sustainable way. Spring Batch even allows you to distribute processing across multiple machines in a cluster. Naturally, both of these frameworks play very nicely on top of Cloud Foundry, which lets you scale up and out as demand requires.

In this talk, Josh Long introduces how to use Spring Batch and Spring Integration on Cloud Foundry, the open source PaaS from VMware.

By Jan Machacek

Where did my controllers, services and repositories go?--Learn about Akka and Scala from a seasoned Spring developer's point of view. Discover how to design and implement Akka applications using typical Spring terminology.

Jan's Akka eye for the Spring guy (or gal) is the live & human-delivered version of the favourite blog post (at http://www.cakesolutions.net/teamblogs/2012/06/18/akka-eye-for-the-spring-guy-or-gal/): Jan will show how the typical Spring application components translate to similar Akka components. The talk will not only show how to "translate" the code, but most importantly, how to take advantage of all the new features of Akka & Spray applications in Scala. Throughout the talk, there will be plenty of code examples, no bullet points and plenty of inspiration.

Jan will show how to make most of your Spring expertise and how to take it up a notch and build asynchronous and scalable applications.

By Tom McCuch and Oleg Zhurakousky

For Modern Applications 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.

By Paco Nathan

Introduction to Cascading, an application framework for Java developers to deploy robust, enterprise-grade applications on Apache Hadoop. We'll start with the simplest Cascading program possible (file copy in a distributed file system) and progress in small steps to show a Java-based social recommender system based on Twitter feeds.

Introduction to Cascading, an application framework for Java developers to deploy robust, enterprise-grade applications on Apache Hadoop. We'll start with the simplest Cascading program possible (file copy in a distributed file system) and progress in small steps to show a Java-based social recommender system based on Twitter feeds.

The objective is to show how to work with “Big Data”, starting on a laptop with sample data sets, to generate JAR-based apps which can be deployed on very large clusters.

We'll show best practices for scalable apps in Cascading, how to leverage TDD features, etc.

By Mark Pollack

The Spring Data project is an umbrella project that provides a familiar and consistent Spring-based programming model for a wide range of data access technologies. Motivated by the rise of new NoSQL databases and Big Data solutions, there is support for Redis, MongoDB, HBase, Neo4j, Gemfire, Hadoop and Splunk. There is also a “refresh” of Spring’s traditional support for JDBC and JPA. In this session, we will provide a guided tour of the Spring Data feature set, showing how you can quickly increase your productivity when creating applications that use these new data access technologies. Use cases unique to each technology will be discussed and demonstrated as well as where Spring Data provides some level of portability between different databases.

Session Detail

By Arjen Poutsma and Oleg Zhurakousky

In this session, we will discuss the Scala programming language, and what it has to offer to Spring developers. We will show how to use the framework you know and love in Scala, and also share some tricks to make this even easier.

In recent years, Scala has been gaining traction amongst Java developers. They choose Scala as a compelling alternative for the Java language itself. Amongst its many qualities, Scala runs on the JVM, introduces many interesting new language concepts, and makes it relatively easy to reuse existing Java code. None of the qualities are unique to Scala per se, but the fact remains that Scala is getting more and more interest, perhaps because of its type-safe nature (as opposed to the many dynamic language alternatives available on the JVM).

Topics that we cover in this session are:

Configuring a Scala bean in Spring XML

Using Scala collections in Spring

Using Spring templates in Scala

Using Spring transactions

And a big surprise!

By Jags Ramnarayan and Guillermo Tantachuco

NewSQL is a term that describes the next generation of highly distributed, scalable, memory oriented SQL databases. In this session, we will explore some basic concepts in NewSQL (VMWare SQLFire), translate a traditional “Star” schema to a partitioned schema(scale out design), walk through various SQL usage patterns – simple queries, complex joins, aggregations, stored procedures and explain how they can be more effectively realized in SQLFire through replicated tables, partitioned tables, in-memory or disk resident tables, parallel procedure execution, distributed transactions, etc.

We will also compare and contrast various NewSQL features with traditional SQL.

By Nilanjan Raychaudhuri and Josh Suereth

Actor based concurrency model is a paradigm shift. What is paradigm shift?

A change in the basic assumptions, or paradigms, within the ruling theory of science. A paradigm shift makes simple ideas hard to grok. Even though Actor model is a simple and revolutionary idea it becomes hard for programmers to see practical benefits and usage. Similarly, the Scala programming language brings a lot to the table in simplifying actor-based design, but comes with a new style of coding. One possible solution to this problem is to evaluate the new paradigm in terms of old paradigm. In this presentation we will take a working Spring based web application and gradually implement it using actors and Scala. We will be skeptical and suspicious of new ideas but at the same time we will be open minded. We will learn about actor based concurrency model using the knowledge of spring. At the same time, we'll learn best practices behind Actors, Scala and combining these with the Spring Framework.

Session Detail

By Chris Richardson

Today, there are several trends that are forcing application architectures to evolve. Users expect a rich, interactive and dynamic user experience on a wide variety of clients including mobile devices. Applications must be highly scalable, highly available and run on cloud environments. Organizations often want to frequently roll out updates, even multiple times a day. Consequently, it’s no longer adequate to develop simple, monolithic web applications that serve up HTML to desktop browsers.

In this talk we describe the limitations of a monolithic architecture. You will learn how to use the scale cube to decompose your application into a set of narrowly focused, independently deployable back-end services and an HTML 5 client. We will also discuss the role of technologies such as NodeJS and AMQP brokers. You will learn how a modern PaaS such as Cloud Foundry simplifies the development and deployment of this style of application.

By Ken Rimple

Learn how to write Spring Roo commands and features using the OSGi-based add-on API. You'll learn how to extend the Roo shell to provide commands specific to your development shop, how to configure various architectures and frameworks using various Roo objects such as the FileManager and the ProjectManager, and how to write and update class and ITD definitions. A must if you need a tool to help you configure applications quickly or contribute to open-source recipes in Spring.

After this talk, you will leave with a better understanding about how to customize Roo to improve developer productivity for your organization.

Come see Ken Rimple, co-author of Spring Roo in Action and long-time Spring trainer, mentor and consultant, discuss how Roo can be customized by writing add-ons. You'll learn how to develop add-ons for internal use or to publish and contribute them to the wider community of Roo tool users. Ken will:

expose internals of the OSGi-based add-on platform and APIs

show you how to write your configuration changes safely, access XML and other files from your existing builds

show you how to expose commands and options, and

demonstrate how to generate AspectJ ITDs and Java classes.

Some familiarity with Roo is suggested but not necessary. You can visit the Roo project home page or read the free introductory chapter of Spring Roo in Action for background.

By Gary Russell

In this presentation we will discuss the options for managing and monitoring applications that use Spring Integration. It will provide a comprehensive overview of the extensive support for JMX provided by Spring Integration, both in terms of providing access to Spring Integration internals, as well as creating a JMX client to interact with local and remote MBeanServers.

In addition, we will show how to use the Spring Integration plugin for Spring Insight to drill down into Spring Integration flow processing to examine application performance.

Topics include:

Using the Integration MBean Exporter, and the MBeans it registers, for analyzing Messaging Endpoints and Channels.

Exporting the Integration MBean Exporter itself as an MBean, to gain access to it's attributes and operations.

Using the Control Bus to start and stop endpoints.

Using the Spring Integration plugin for Spring Insight to get a real-time view of your application and its performance.

Enabling and using Message History

Using the orderly shutdown mechanism available in Spring Integration 2.2.

Using JMX endpoints (with local and remote MBeanServers) to monitor attributes. invoke operations, publish notifications, and receive notifications.

By Brian Saville

Due to increasing demand for a common interface as well as extensibility for our core software at Adaptive Computing, we have developed a single point of integration using Grails and Gradle in the form of a RESTful web application called Moab Web Services (MWS). As a part of these efforts, we developed a plugin platform that allows us to dynamically modify the behavior of MWS, even after being deployed on a client system and without restarting the application. We tackled numerous obstacles and questions during the development of the platform including JVM classloading, plugin services, plugin conventions, inter-plugin communication, plugin development, configuration and metadata, testing using the Spock framework, exposing plugin web services, and management via a web interface and RESTful API.

In this presentation, we will discuss these problems, how we overcame them, and how the solutions could be applied in more general cases.

By Mark Spritzler

In this talk we will show you how to use JPA effectively in your Spring Application making sure it is easy to maintain while being very fast.

We will cover the concepts of JPA that are THE most important for writing a successful JPA application. Fetching strategies, Cascade Options, Cache Modes and Flush modes must be fully understood if you want to be a JPA expert. How you define your queries and mapping make a huge impact on the performance of your application. You can make an application run faster with JPA than JDBC, and in this talk we will show you how.

By Rossen Stoyanchev

Following on Juergen's talk on the upcoming Spring 3.2 release, this presentation will focus on what's new specifically in the area of Spring MVC. The presentation will explain all noteworthy features and, as is usual with every new release, there will be a lot to discuss including Servlet-based async request support, content negotiation enhancements, REST error handling, @MVC test support, and much more.

The talk does not provide an overview of Spring MVC but rather assumes a level of experience and focuses on covering what's new.

By Dave Syer

One of the questions we get asked the most by developers and architects is: when and why would I use OAuth2? The answer, as often with such questions, is “it depends”, but there are some features of OAuth2 that make it compelling in some situations, especially in systems composed of many lightweight web services, which becoming a very common architectural pattern.

This presentation will not go into a lot of detail about the OAuth2 protocol and related specifications, but will attempt to show some of the key features of a system secured with OAuth2 and the decision points when choosing to build such a system.

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

Broadleaf Commerce is a feature rich, highly customizable, open source eCommerce framework built on top of The Spring Framework. Spring provides a huge number of container services such as dependency injection, AOP, transaction management, MVC, JPA support, security, etc. Broadleaf leveraged Spring's features to provide a highly functional and extensible eCommerce framework. Where Spring is a technical development framework, Broadleaf is an eCommerce domain-specific development framework. Broadleaf Commerce has extended Spring with a unique application context merge process to allow implementors to extend, override, and control every component of the Broadleaf Framework. Kelly will provide an overview of the Broadleaf features, along with a deeper dive into some of the more advanced technical capabilities of Broadleaf Commerce and how they are made possible by Broadleaf's use and extension of The Spring Framework.

Session Detail

By Ryan Vanderwerf

This talk will demonstrate and show how the grails video plugin works by allowing pseudo-streaming to the browser and using ffmpeg to transcode all videos into a common format on the server. Clients ask many times for functionality like this for their sites, and you will learn a easy and simple and free way to fulfill the need.

This plugin also uses quartz for the asynchronous video processing.

By Ryan Vanderwerf

Terracotta has a free open source edition which provides excellent functionality for clustering in Grails and Java, and I will show use to set up Terracotta and cluster your application using its main features Ehcache, HTTP Session in Tomcat, and Quartz.

I will cover the Ehcache and Tomcat aspect of integrating Grails with it and show a demonstration interacting with a Grails application and the Terracotta console. This talk will also cover how to configure Tomcat Terracotta for HTTP session clustering, hot spare, and Ehcache, and Quartz support.

By Vaughn Vernon and Wesley Williams

Sponsored by EMC Consulting, this presentation highlights the use of Domain-Driven Design in a cloud-based, distributed architecture. There are several working examples of highly scalable DDD models featuring the NYSE Nanotrader system.

NanoTrader is a VMWare working reference implementation featuring SpringSource best-practices throughout the application stack. The functioning high-performance trading application includes Spring MVC with both web and mobile UI’s, Spring Integration, RabbitMQ, GemFire, Hibernate using SQLFire and/or Postgres. Domain-Driven Design (DDD) is a set of software development tools and best practices for crafting a business strategic initiative in a core domain model. How does NanoTrader apply DDD? This powerful approach to modeling a trading system will be showcased from the DDD strategic and tactical modeling perspectives.

By Abdul Wajid

This session will focus on transforming legacy Java EE apps to Tomcat and tcServer. We will provide complete application transformation right from analysis of the app for migration, re-factoring code/configuration through to deployment & testing of the transformed application on private or public Paas platform.

Session Detail

By Phil Webb

Drawn from practical experience migrating production Java to Cloud Foundry, this session will present detailed tips along with a library of code that you can reuse with your own projects.

Topics covered include: how to refactor existing code for the cloud, alternatives to the file system, compiling without the JDK, dealing with gateway timeouts and how to run Tomcat 7. Along the way there will be plenty of real code and demos as well as the gotchas that can catch you out.

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

Tired of the limitations of writing your presentation layer in older technologies? Eager to discover what other alternatives there are for rendering your UI? In this presentation we will take a tour of some of the modern templating frameworks and demonstrate how to integrate them with a Spring MVC sample application.

I am an expert with Spring and Spring MVC. I also have experience integrating an array of presentation technologies with Spring MVC in production applications.