Session Schedule

By Mark Fisher and Mark Pollack

Big Data is all the rage, but building real-world big data solutions can fill developers with rage. While Hadoop provides the de-facto foundation for storing and processing data, real-world scenarios require much more. Capabilities like data ingestion and export, real-time analytics, workflow management, and connectivity with existing enterprise systems are essential. Today, solutions for these capabilities are often limited, inconsistent, and hard to use. In this session we introduce Spring XD, a unified and extensible system that drastically reduces the complexity of building big data solutions.

Spring XD builds upon existing ecosystem projects such as Spring for Apache Hadoop and Spring Integration to provide a unified configuration and runtime model across this wide range of capabilities. We will take a demo-driven tour that shows how you can easily create real-world big data solutions using Spring.

By Ben Hale

As REST-ful data services become more widespread, it is becoming clear that they have to change to suit new consumer needs. This evolution is often disruptive to consumers, but it doesn't have to be. This session, a follow up to ‘REST-ful API Design’, discusses various strategies for evolving a REST-ful API and how the strategies can be implemented using Spring.

Session Detail

By Gunnar Hillert and Michael Minella

This talk is for everyone who wants to efficiently use Spring Batch and Spring Integration together. Users of Spring Batch often have the requirements to interact with other systems, to schedule the periodic execution Batch jobs and to monitor the execution of Batch jobs. Conversely, Spring Integration users periodically have Big Data processing requirements, be it for example the handling of large traditional batch files or the execution of Apache Hadoop jobs. For these scenarios, Spring Batch is the ideal solution. This session will introduce Spring Batch Integration, a project that provides support to easily tie Spring Batch and Spring Integration together. We will cover the following scenarios:

• Launch Batch Jobs through Spring Integration Messages
• Generate Informational Messages
• Externalize Batch Process Execution using Spring Integration
• Create Big Data Pipelines with Spring Batch and Spring Integration

Session Detail

By Frederic Simon

Developing freemium which involves OSS is not a trivial task. From one side, you need to prevent premium code from working in your free modules, and do it gracefully - without errors and performance degradation. From other side, your OSS core must be easily accessible to the premium modules.

Partial public availability of the code and unified continuous delivery process for two different versions of the product is also challenging.

In this talk we’ll showcase Artifactory, which successfully combines OSS and Pro versions by heavily relying on flexible dependency injection mechanics, available in Spring. We will talk about developing, building, testing and releasing hybrid freemium application and will review the existing approaches, discussing pros and cons of each of them.

By Jeffrey Sogolov

Relying on network reliability and topology are just a few mistakes most engineers make. Common fallacies of distributed computing are one of the most important factors that engineers need to keep in mind when building enterprise software. We will cover each fallacy while showing mistakes most engineers make.

We will then cover what coupling truly means and how to tell whether your current project is heading the wrong way.

Finally, we will apply aspects of object orientation that held up to this day and learn how to apply them to the new age architectures.

Don't learn from your mistakes, learn from others and come away with techniques that you can apply to your current project right away.

This is the session that I wish I attended when I was a young lad.

By Guillaume LaForge

Let's talk about all the new features of Groovy 2.1!

With 1.7 million downloads last year, Groovy continues leading the pack of alternative languages for the JVM. Groovy 2.0 was released almost a year ago, introducing its modularity, its JDK 7 support with "Project Coin" syntax enhancements and usage of "Invoke Dynamic", and proposing static type checking and static compilation support.

With Groovy 2.1, the "Invoke Dynamic" support was completed for even more performance. A new annotation for helping documenting your Domain-Specific Languages, helping IDEs with auto-completion, and the static type checker to understand the DSL. A meta-annotation facility was created to let you group together and configure several annotations into one to escape from annotation hell. Last but not least, some additional customizations are possible to further configure the Groovy compiler.

Fasten your seat belt, ready for take-off with Groovy 2.1!

By Jeff Scott Brown

Grails brings the powerful "coding by convention" paradigm to Groovy and Java. Grails is not just another flavor in the pool of web development frameworks for Java. Grails leverages the powerful dynamic features of Groovy while taking advantage of best of breed technologies like Hibernate, Spring and Sitemesh to make web application development both fun and easy.

This session will demonstrate how easy it is to get a simple application up and running with very little effort and then evolve that application by adding features to really show off the power of the Grails framework. Topics include:

• Grails Quick Start
• The Grails Command Line Tools
• GORM and Hibernate
• Groovy Server Pages (GSP)
• Spring 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.

We'll also discuss an approach to introducing the language into Java teams that doesn't hit too much resistance and allows time for teams to become comfortable with it. Dictatorial approaches typically don't work well!

By Kenneth Kousen

Watch Preview Video

The Spock framework brings simple, elegant testing to Java and Groovy projects. It integrates cleanly with JUnit, so Spock tests can be integrated as part of an existing test suite. Spock also includes an embedded mocking framework that can be used right away.

In this presentation, we'll look at several examples of Spock tests and review most of its capabilities, including mock objects and integration with Spring.

By Graeme Rocher

In this talk Grails project lead, Graeme Rocher, will talk through the latest and greatest happenings in the world of Grails including a walk through of the features included Grails 2.3 and upcoming in Grails 3.0

Join Us!

By Bobby Warner

APIs open up our application data and functionality to other clients like mobile applications, JavaScript clients and even potentially other companies. The most prominent way of implementing them is by using the REST architectural style and it is now almost expected for all web developers to know how to build good RESTful APIs. As Grails developers, we have a few options readily available to us to simplify this task and Grails 2.3 included lots of new REST support.

This talk will cover these options as well as discuss some of the pros and cons with each approach so you can successfully build APIs using the new REST features in Grails 2.3 for your next project.

By Baruch Sadogursky

Grails is awesome! agreed? Good!

Now, search and testing facilities have become such a basic commodity in applications that it's almost taken for granted.

But as a Grails developer you face limitations and concerns: is the library well maintained? Does it fit the framework's paradigm?

After nominating the winners, we’ll show you the advantages of our tools of choice and take a deep dive into the juicy details.

This talk will provide short overviews and comparisons in the search for 2 pieces of the holy grail - good search and testing facilities.

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

The JAX-RS 2.0 specification is part of Java EE 7, but can be used now. It contains the expected annotations for the HTTP verbs (@GET, @POST, and so on) and mechanisms for retrieving variables, but only a few methods for doing hypermedia. This presentation will review those techniques by adding both structural and transitional links to resource representations. Groovy is used to simplify the code and also to implement a MessageBodyWriter for JSON data.

In addition to simplifying the implementation classes, Groovy also supplies a RESTful client class from the HttpBuilder project. That will be used, as well as the native client implementation classes in JAX-RS 2.0, to build Spock tests for RESTful services.

Prerequisite: Some knowledge of Groovy would be helpful

By Jeff Scott Brown

The dynamic runtime nature of Groovy is one of the things that sets it apart from standard Java and 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. This Part 1 of 2 will cover the runtime metaprogramming capabilities of Groovy. The session will dive deep into Groovy's Meta Object Protocol (MOP) which implements the incredibly dynamic runtime dispatch mechanism. The session will include a lot of live code demonstrating really powerful runtime features of the language.

This session is focused specifically on Groovy's runtime metaprogramming capabilities. Part 2 of 2 will cover Groovy's compile time metaprogramming capabilities.

By John Thompson

Everyone knows controllers can be tricky little buggers to test. Spring MVC Test brought some exciting testing capabilities to Spring 3.2, but it you're left on your own for mocking the service layer in your controllers.

We'll take a look at the Groovy approach of using Spock to unit test your controller interactions with the service layer and Spring MVC Test to unit test controller interactions with the web layer.

By Burt Beckwith

Grails plugins are a great way to reuse and share common code, and to modularize an application. In this talk we'll look at the general process for creating a plugin.

In addition, we'll look at the different types of plugins, how to deploy and release, and options for various testing approaches.

By Burt Beckwith

When you think about securing a Grails application, you probably think of the Spring Security and Shiro plugins. But these plugins only control access to your pages and objects – what about guarding agains cross-site scripting (XSS), cross-site request forgery (CSRF) and SQL injection attacks? The OWASP project maintains a list of the top 10 web application security risks.

In this talk we’ll look at these risks and what libraries and plugins are available to make your applications resistant to these types of attacks.

By Venkat Subramaniam

Everyday coding involves taking care of so many things that much time can get wasted writing over and over code to deal with the basics of programming. Not so in Groovy, thanks to the annotations that transform your code to synthesize the cruft.

In this presentation we will explore, using some live examples, various Groovy annotations, their purpose, and take a peek at what they actually do internally.

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

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

Grails is geared towards an MVC architecture with a database back-end and a service layer. But is this the only way to write Grails applications? What other architectures are possible and what is required to implement them?

In this talk we'll answer those questions by looking at several different architectures in the context of Grails. From single-page apps to event based back-ends, you'll get a good overview of just what is possible and you'll be able to make an informed decision on how to implement your next project.

By Joe Sondow

Asgard is a free and open source Grails application built and used by Netflix to deploy code changes and to manage resources in the Amazon cloud at large scale.

In this talk we'll delve into how Asgard works, covering topics such as:

• Open source motivation, presence, and support.
• Tour of the user interface.
• Customizing Asgard for your own company.
• How Netflix philosophies drive Asgard's design.
• The Netflix Cloud Model.
• Easy large deployments and fast rollback.
• Caching the cloud with Groovy.
• Visual language for the cloud.
• Publishing a REST API.
• Mocking AWS for offline testing.
• Comparison with the AWS Management Console.

By Daniel Woods

By improving Grails' convention-over-configuration application design with a message driven architecture, applications can benefit from improved modularity, scalability, and code reusablility.

This presentation will demonstrate and discuss architecture design patterns for implementing a message-driven architecture in Grails to allow for better modularity, scalability, and code reusability. Given that Grails is already a fully loaded Spring application, the content of this presentation will focus on developing message-driven patterns, techniques, and strategies based on Spring Integration.

The core of the presentation will focus on developing an application workflow that is amenable to pluggable components and services at given phases in the workflow's lifecycle using Spring Integration.

By Burt Beckwith

Properly performing multiple data updates requires a transaction, but how do we do this in Grails? Services are the best option, but there are different approaches that can be used.

We'll look at how to effectively use transactions and how to customize transaction attributes such as isolation and propagation levels. We'll also look at using two-phase commit (2PC) when using multiple datasources, or when combining database updates with JMS messaging. And we'll also look at testing to ensure your code is properly transactional.

By Jeff Scott Brown

Getting started building web applications for the Java platform is easy. Following that through to rich interactive applications that solve the business needs is more tricky. Grails 2 goes the whole way to address pain points not only for simple applications but of real enterprise applications with real demands. This session steps through many of the advanced features of Grails 2 that help get your applications through that last 20% that teams often struggle with. This session is not the standard hello world CRUD introduction to Grails.

Grails has long made web application development both fun and easy. This session dives beyond the basics to cover a lot of the advanced features introduced in Grails 2.

By Jeff Scott Brown

The dynamic runtime nature of Groovy is really powerful and really flexible. The runtime capabilities of the language allow for a lot of capabilities that are not possible with less dynamic languages. Those runtime capabilities are really powerful but are not the whole story of Groovy's dynamic capabilities. Groovy also allows for a lot of dynamic behavior to be introduced at compile time. Participating in the compilation process isn't something that application developers are generally used to doing, but Groovy makes it somewhat easy to jump into that process without having to write a whole compiler of your own. This session will dive deep into the features of Groovy that allow for you to participate in the compilation process to control what the compiler emits. You will learn to add methods to classes, modify existing and more, all at compile time.

This session is focused specifically on Groovy's compile time metaprogramming capabilities. Part 1 of 2 will cover Groovy's runtime metaprogramming capabilities.

By Mark Johnson

Real-time analytics is the process of monitoring and often reacting to web based events or machine-to-machine communication and then quickly deliver the appropriate response to an end-user or machine process. The challenge though is how can we modify the analytics algorithms and reference data without shutting down the data feeds.

In this session we will demonstrate architectural and implementation patterns utilizing Spring Integration Framework, HBase, and of course Groovy to illustrate how it is possible to dynamically change your enterprise’s real-time algorithms without a system restart.

By Graeme Rocher

In this talk Grails project lead, Graeme Rocher, will talk through the latest Async features offered by Grails and how they can be used to create elegant non-blocking REST APIs.

Join Us!

By Stephane Maldini

Grails 2.3 is coming with new asynchronous and eventing features, driven by the same usability that shapes the Grails success amid developers. That means the framework now supports the modern definition of "realtime".

In fact, Platform-core plugin currently helps developers at writing Event-Driven Architectures and pushes the boundaries to the Browser with its Events-Push extension. Scalability might also be an outcome of such architecture, since multiple Grails applications can now easily work together. Eventually, with events propagated across server(s) and browsers, a new set of patterns emerges and HTML5 web applications have rarely been so pleasant to write.

We'll see in this session how we address few spotted today's and tomorrow's concerns: Scrolling large data sets without blocking, streaming to the browser, scale Grails in the cloud...

By Clay McCoy

Some of the most difficult problems in applications today involve coordinating and distributing work in a resilient way. Use cases include communicating with unreliable remote services, parallelization, scheduling critical timers, being immune to server failures... Even if you handle these concerns how do you test this sort of orchestration glue-code? Groovy's powerful metaprogramming capabilities and AWS's robust Simple Workflow Service can be used to solve these problems.

In this talk you will see real world pragmatic examples that can be used even if your business logic is not running in the cloud.

By Baruch Sadogursky

It is often beneficial to allow users extend your software with their own logic. With the rise of dynamic languages on the JVM it is also much more easier to do than ever before. In this session we will share our experience in creating Groovy authored user plugins interface.

After a brief introduction to domain specific languages (DSLs), their relevance to user plugins and how they can be easily implemented in Groovy, we’ll look at more user-friendly, but developer-challenging type of DSLs, which support plugins written both in Groovy or Java.

Good public API design is another very important aspect - while the APIs have to be broad enough to allow interesting functionality, internals should stay close to allow changes and further development. Exposing APIs to the world come with great responsibility - once ublished they can’t be changed without a price, so it is important keep backwards compatibility in mind.

Another very important aspect is security - you let strangers into your chambers, and you better be ready. Leveraging security mechanisms is essential to establish proper sandboxing and protect your application from malicious or faulty plugins.

Finally, we will cover another very important and nontrivial aspect of user plugins exposure - the classpath isolation when your plugins require dependencies. We will compare different solutions like establishing classpath hierarchies, OSGi, JBoss modules and the long-awaited Project Jigsaw.

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

The ability to navigate and even alter the abstract syntax tree of your code is very powerful and yet under utilized. Quite a few tools have exploited this capability in Groovy. These techniques can be useful to create fluent syntax and validate DSLs.

In this presentation we will explore the key features and strengths of Groovy AST transformation API and techniques. Learn how to use compile-time metaprogramming with Groovy AST transformation.

By Ryan Vanderwerf

This talk will cover how to get your application running on AWS VPC and related services.

We will go over some related services like RDS, autoscaling, s3, cloudfront, s3fs, ebs, elastic beanstalk, etc and how your Grails application can benefit from using these. The networking can also be confusing with your application so we'll cover the basics here as well.

By Jon Brisbin and Stephane Maldini

Reactor was recently made public after a two-year incubation, evolving slowly alongside frameworks like Storm, Akka, Play, GPars or Vert.x. Integrated with Grails starting with version 2.3, Reactor takes the best ideas from several asynchronous toolsets and synthesizes them into a coherent framework that supports a variety of runtime topologies and makes it easy for developers to efficiently leverage their cloud or traditional hardware assets. Reactor is equally at home inside or outside a Spring ApplicationContext and also provides first-class Groovy support in the form of DSLs and language extensions. Special attention has been given to make Reactor easy enough to use to create single-file node.js-like applications, while maintaining a solid asynchronous toolset that works with Big and Fast Data tools like Gemfire, Spring Integration, and Spring Batch. This talk will give Reactor a proper introduction and show sample code that demonstrates the event-driven and composition-based nature of Reactor applications.

Session Detail

By Emad Benjamin and Guillermo Tantachuco

The session will cover various GC tuning techniques, in particular focus on tuning large scale JVM deployments. Come to this session to learn about GC tuning recipe that can give you the best configuration for latency sensitive applications. While predominantly most enterprise class Java workloads can fit into a scaled-out set of JVM instances of less than 4GB JVM heap, there are workloads in the in memory database space that require fairly large JVMs.

In this session we take a deep dive into the issues and the optimal tuning configurations for tuning large JVMs in the range of 4GB to 128GB. In this session the GC tuning recipe shared is a refinement from 15 years of GC engagements and an adaptation in recent years for tuning some of the largest JVMs in the industry using plain HotSpot and CMS GC policy. You should be able to walk away with the ability to commence a decent GC tuning exercise on your own. The session does summarize the techniques and the necessary JVM options needed to accomplish this task. Naturally when tuning large scale JVM platforms, the underlying hardware tuning cannot be ignored, hence the session will take detour from the traditional GC tuning talks out there and dive into how you optimally size a platform for enhanced memory consumption. Lastly, the session will also cover vfabric reference architecture where a comprehensive performance study was done.

By Colin Harrington

JSON (JavaScript Object Notation) is now the lingua franca of data interchange. Most platforms such as browsers, phones, client and embedded applications have support for consuming/producing JSON. Native Browser compatibility makes it especially convenient for our modern web architecture.

In this session we'll walk through several patterns for delivering JSON to our clients. We'll explore the built-in converters, profiles, and look at creating your own JSON view layer for more in-depth structures.

Grails has some good tooling built-in but we'll explore both the Spring Layer and plugin ecosystem's various tools to find the right tool for your job.

By Colin Harrington

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

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

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

By Ramnivas Laddad and Arjen Poutsma

The Spring Framework is one of the most popular Java frameworks used today. While it is possible to use Spring in Scala, it does feel awkward in certain places, because of the "Javaism" peering through. For instance, using callback interfaces feels strange in Scala; functions would be a better match.

At SpringOne 2GX last year, I introduced the Spring Scala project, which solves this particular issue, and aims to make it easier to use Spring in Scala in general. In this session, we discuss the Spring Scala portfolio project and its feature set.

We will also show a real-world application that combines robustness and maturity of the Spring Framework with coolness of Scala. It features a REST-based architecture with on Spring and Scala backend and AngularJS frontend to offer a modern, single-page experience.

By James Ward

Non-blocking, asynchronous, and reactive are all the rage today. This session will explore why the patterns are important in modern apps and how to apply them to event-driven web, mobile, and RESTful apps. To illustrate the concepts, Java, Scala, Akka, and Play Framework will be used as examples.

By Mike Heath, Shawn Nielsen, and Mike Youngstrom

Cloud Foundry makes managing and deploying applications incredibly simple. However, deploying Cloud Foundry itself can be a challenging task. We will be sharing what we learned deploying Cloud Foundry and what it took to win over our organization.

Learn from our experiences deploying Cloud Foundry with BOSH and integrating with our existing enterprise infrastructure. We will discuss:

Developing and customizing Cloud Foundry while staying in sync with the open source repositories Building custom Cloud Foundry services using Java and Spring Improved gathering application diagnostics by simplifying JMX and remote debugging support in Cloud Foundry Enhanced security and auditability with application level firewalls

Come learn from our successes as well as our mistakes.

Cloud Foundry

By Damien Dallimore

How much visibility do you really have into your Spring applications? How effectively are you capturing,harnessing and correlating the logs, metrics, & messages from your Spring applications that can be used to deliver this visibility ? What tools and techniques are you providing your Spring developers with to better create and utilize this mass of machine data ? In this session I'll answer these questions and show how Splunk can be used to not only provide historical and realtime visibility into your Spring applications , but also as a platform that developers can use to become more "devops effective" & easily create custom big data integrations and standalone solutions.I'll discuss and demonstrate many of Splunk's Java apps,frameworks and SDK and also cover the Spring Integration Adaptors for Splunk.

By Costin Leau

Finding relevant information fast has always been a challenge, even more so in today's growing "oceans" of data. This talk explores the area of real-time full text search, using Elasticsearch, an open-source, distributed search engine built on top of Apache Lucene. The session will showcase how to perform real-time searches on structured and non-structured data alike, how to cope with types and suggestions, do social graph filters and aggregations for efficient analytics. All from a Spring perspective Last but not least, the presentation focuses on the Hadoop platform and how Map/Reduce, Hive, Pig or Cascading jobs can leverage a search engine to significantly speed up execution and enhance their capabilities.

The presentation covers architectural topics such as index scalability, data locality and partitioning, using off and on-premise storages (HDFS, S3, local file-systems) and multi-tenancy.

By Mattias Severson

Is it possible to decrease the turn-around time of your test suite? How can you make sure that your tests execute independently? Is it possible to automatically verify that the database schema is kept in sync with the source code? What are the trade-offs? In this presentation, you will learn how to apply features such as the Spring MVC Test Framework, Spring profiles, and embedded databases, to automate and improve your test suite, thus improving the overall quality of your project. A simplistic Spring web app will be used to show some practical code examples.

Topics include:

• Basic Spring Testing
• Embedded Database
• Transactions
• Profiles
• Controller Tests
• Server Integration Tests

By Brian Cavalier

Loose coupling. Your web front-end has that, right? Your JavaScript is using pubsub, event emitters, and message buses! Guess again, you can do better.

Aspect Oriented Programming (AOP) is a technique for augmenting the behavior of objects, methods, and functions non-invasively. AOP adds new behaviors and modifies existing behaviors "from the outside". Using AOP, it's possible to create connections between components without either having any knowledge of the other and without any extra library dependencies in your code.

While you may be familiar with AOP in Spring, you may not yet have applied it in JavaScript. In this talk, we'll do just that. We'll introduce simple techniques for applying AOP in pure JavaScript using no additional libraries, and then look at meld.js (https://github.com/cujojs/meld), the AOP library that powers Cujo.js (http://cujojs.com). We'll work from simple examples of making connections between components to more sophisticated examples that integrate pubsub, message buses, etc. in a truly loosely coupled way.

By Dave Syer and Phil Webb

Are you an impatient programmer who wishes the keyboard could keep up with you? If you've ever wished Java and Spring could do more to keep up, then this is the place to be. We present Spring Boot, a toolkit and runtime platform that will get you up and running with Spring-powered, production-grade applications and services faster than you believed possible. The goals are:

• Radically faster and widely accessible getting started experience for Spring development
• Be opinionated out of the box, but get out of the way quickly as requirements start to diverge from the defaults
• Provide a range of non-functional features that are common to large classes of projects (e.g. embedded servers, security, metrics, health checks, externalized configuration)
• First class support for REST-ful services, modern web applications, batch jobs, and enterprise integration
• Applications that adapt their behavior or configuration to their environment
• Optionally use Groovy features like DSLs and AST transformations to accelerate the implementation of basic business requirements We illustrate how these goals can be achieved through a series of demonstrations, and in-depth reviews of the design principles and codebase of new features in Spring Framework 4.0 and in the wider Spring Ecosystem .

Session Detail

By Paul King

Groovy has excellent support for the creation of Domain Specific Languages (DSLs). Such DSLs can be particularly useful when writing business rules. Rules can be written in English-like phrases which are straight-forward to read or write (by non-developers) yet can be fully executable code corresponding to a layer over the top of a traditional logic solving API. This talk illustrates various DSLs, highlights several logic solving APIs and looks at the pros and cons of the various approaches (including tool support, flexibility, lock-in).

Whilst Groovy is the language of choice for this talk, the techniques and principles are not specific to Groovy and apply readily to your favourite modern scripting language. The "logic solving" APIs being highlighted are primarily Choco, Drools Expert and Drools Planner but again these are just illustrative of the logic APIs that you can use when writing a DSL layer. We look at the benefits and costs when writing such DSL layers, numerous real-world examples and the all-important aspects of tooling; covering what non-developer, developer and cloud tooling is available with this kind of approach.

To give a flavour of the talk, here is a snippet from one of the code examples (Einstein’s riddle):

the Briton has a red house the owner of the green house drinks coffee the owner of the yellow house plays baseball the person known to play football keeps birds the man known to play tennis drinks beer the green house is on the left side of the white house the man known to play volleyball lives next to the one who keeps cats the Norwegian lives next to the blue house

When discussing this example, we look at how you create and debug such code, illustrate how several APIs can be used underneath this DSL layer, discuss the costs involved in creating the above DSL in its basic form and in more complex forms that allow type checking, code completion etc. and options for parallelism and cloud deployment.

By Gil Tene

Time is Money. Understanding application responsiveness and latency is critical not only for delivering good application behavior. It is critical for maintaining profitability and containing risk. But good characterization of bad data is useless. When measurements of response time present false or misleading latency information, even the best analysis can lead to wrong operational decisions and poor application experience. In this presentation, Gil Tene (CTO, Azul Systems) discusses some common pitfalls encountered in measuring and characterizing latency. Gil demonstrates and discusses some false assumptions and measurement techniques that lead to dramatically incorrect reporting results, and covers simple ways to sanity check and correct these situations. He discusses the fallacy of using standard deviation measurements, the strongly multi-modal nature of latency, common discontinuities found in most computing platforms, and how back pressure and coordinated data omission issues can literally skew measurement results by orders of magnitude. Gil introduces and demonstrates how simple and recently open sourced tools can be used to improve and gain higher confidence in both latency measurement and reporting.

Session Detail

By Paul King

This talk reviews the features in Groovy which make it easy to work with databases. It reviews the features of Groovy SQL including Groovy's LINQ-like lazy evaluation technology called datasets. In addition, it looks at working with a couple of NoSQL databases: MongoDB (using GMongo) and Neo4J (using it's Java api and via Gremlin support).

This talk looks at accessing relational databases using raw JDBC, Groovy's lazy LINQ-like datasets and briefly using hibernate, caching, and spring-data technologies. It also looks at the approaches that can be used to access NOSQL databases.

The talk covers Groovy-SQL in some depth and then briefly examines the other technologies mentioned to give you a feel for your options. For Groovy SQL, we look at how to do the basic CRUD operations and then examine a few more advanced features like working with transactions, batches, chunking, stored procedures and database metadata. Example code will be provided on github (under development) so that attendees can dive deeper into the examples if they wish.

By Guillaume LaForge 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 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 Ashley Puls

Operations teams tend to get nervous when debugging tools are installed on production systems. This is understandable as most people have had at least one debugging tool crash a system. However, are there tools that can be run in a production environment?

This talk will cover methods and tools that can be used to uncover and resolve performance problems arising in Java web applications that use the Spring Framework. This talk will touch on a few common problems such as slow SQL, slow web page load times, blocked threads, and exceptions in the code. It will use a variety of diagnostic tools to examine these problems including log files, jmap, jvisualvm, and New Relic. Finally, the talk will evaluate the use of these tools in a production environment, separating them into what can and cannot be realistically used in live production web applications

By Durai Arasan

ETRADE has revamped their SOA platform with RabbitMQ as a core messaging system and Spring Integration as a light weight ESB layer with services written in Java, C and Python based languages. This new container show cases how legacy system can be migrated at the same time introducing more modern frameworks and languages without comprising on performance and scalability factor of new platform.

Presentation will cover some history behind the requirements and how the platform was built.

It will be followed by live demo with an example of running web services with RabbitMQ and Spring Integration. This platform highlights why RabbitMQ works best for such a need compare to other options.

By Ben Hale

As data-driven applications become more widespread, the services that provide the data are becoming more critical. Most commonly these data services are exposed via REST-ful APIs. This session describes what exactly makes a service REST-ful, how to implement a REST-ful API using Spring, and how to test that API.

Session Detail

By Rob Harrop

Running applications in the cloud presents a set of interesting new problems, constraints and opportunities. In this talk, attendees will learn how best to deploy, run and manage their Spring applications in the Amazon cloud.

Covering everything from basic applications in Amazon Beanstalk to large-scale applications that span multiple regions and interact closely with on-premise resources, this talk will equip attendees with the knowledge they need to be successful running Spring in the cloud.

By Thomas Risberg and Janne Valkealahti

Big data and Hadoop is widely considered to be the next generation data platform. Hadoop is notoriously difficult to work with and just diving in and starting coding can easily lead to frustration. A better way is to leverage your existing Java and Spring skills to take advantage of these new technologies. In this presentation we will introduce Spring Data for Apache Hadoop and see how it can make working with Hadoop easier. We will also cover several ways to install a small Hadoop cluster that can be used to test your new Hadoop applications.

By Anthony Baker and Jags Ramnarayan

Hadoop gives us dramatic volume scalability at a cheap price. But core Hadoop is designed for sequential access - write once and read many times; making it impossible to use hadoop from a real-time/online application. Add a distributed in-memory tier in front and you could get the best of two worlds - very high speed, concurrency and the ability to scale to very large volume. We present the seamless integration of in-memory data grids with hadoop to achieve interesting new design patterns - ingesting raw or processed data into hadoop, random read-writes on operational data in memory or massive historical data in Hadoop with O(1) lookup times, zero ETL Map-reduce processing, enabling deep-scale SQL processing on data in Hadoop or the ability to easily output analytic models from hadoop into memory. We introduce and present the ideas and code samples through Pivotal in-memory real-time and the Hadoop platform.

By Dave Syer

The OAuth2 specification (wisely) leaves a lot of areas open to interpretation and implementation details, so there are a lot of opportunities to impose interpretations on the flows and the underlying data. This presentation starts with a basic guide to the main features of OAuth2 and then goes on to show, with examples, how they can be exploited to support business and application use cases. For instance, should you encode access decision data directly in the access token, or make the token completely opaque? Should you be signing requests? What naming convention should you use for OAuth2 scopes? How do you go about registering users and clients? There are some obvious patterns in existing OAuth2 implementations, and Spring Security OAuth provides plenty of hooks and extension points should you wish to copy one of those, or make your own rules.

Examples will use Spring and Spring Security to show how to take advantage of the inherent flexibility, both in the spec and in the libraries.

By Matt Stine

This session will focus on how you can build your very own Cloud Foundry private PaaS running in your own data center or on AWS or even on OpenStack on your own Mac mini. You will learn how the Cloud Foundry BOSH tool constructs a full Cloud Foundry instance from a bare bones virtual machine and continues to coordinate and manage the entire PaaS cloud once it is operational. If you want the convenience of developing against your own private custom PaaS within your company, then this session will give you all the steps you need to get started.

Session Detail

By Christophe Levesque, Scott Motte, and Dekel Tankel

Cloud Foundry makes it easy to push an app, bind services to it, and scale it. Cloud Foundry takes care of the all the infrastructure and network plumbing that you need to run your applications and can do this while patching and updating systems and services without any downtime. This session will provide a deep technical tour of the architecture behind the latest vesion of Cloud Foundry that makes all this possible and will provide insights for anyone interested in large scale distributed systems.

Session Detail

By Luke Taylor and David Turanski

Today's solutions must provide the ability to interpret related events and understand trends that are happening right now. This session will cover some of the out of the box capabilities of Spring XD to tap into big data streams and generate metrics such as simple counters, aggregate counters, moving averages, rates of change, and histograms. Hands-on demos will show you how Spring XD uses Redis and GemFire's Continuous Query and Function Execution to incorporate real-time analytics into event-driven applications.

Session Detail

By Lou Crocker and John Ferguson

Much like Spring burst onto the scene and became a defacto standard for Java, Sencha is vying for a similar role in the world of HTML5. From Ext JS for desktop development, Sencha Touch for mobile, and Sencha Architect as a design tool, it has become a pervasive technology in the new paradigm of multi-client development.

In this session we will use our own SpringTrader reference application to illustrate integration techniques of Spring with Sencha. We will go beyond the basic wiring of a REST call with binding results to UI components, and look at mapping the Spring MVC and Sencha MVC architectures, along with other tips and tricks to streamline your mobile application development efforts.

By Chris Richardson

A modular, polyglot architecture has many advantages but it also adds complexity since each incoming request typically fans out to multiple distributed services. For example, in an online store application the information on a product details page - description, price, recommendations, etc - comes from numerous services. To minimize response time and improve scalability, these services must be invoked concurrently. However, traditional concurrency mechanisms are low-level, painful to use and error-prone.

In this talk you will learn about some powerful yet easy to use abstractions for consuming web services asynchronously. We will compare the various implementations of futures that are available in Java, Scala and JavaScript. You will learn how to use reactive observables, which are asynchronous data streams, to access web services from both Java and JavaScript. We will describe how these mechanisms let you write asynchronous code in a very straightforward, declarative fashion.

By Julien Dubois

This talk is a live version of my blog posts on performance-tuning the Spring Petclinic application: http://blog.ippon.fr/tag/spring-petclinic/

We will talk about JVM locks, Web application performance best practices, JDBC vs JPA, and caching We will see how to use effectively tools such as JMeter, Yourkit and Intellij IDEA to quickly solve performance issues We will also explain the methodology used, so you can follow the same steps on your own applications

In this session we will talk about :

• Stress tests
• Memory leaks
• Garbage Collection
• Profiling tools
• Application Server tuning
• JVM tuning
• Locks
• JDBC vs JPA
• Lazy loading
• Caching
• And much more !

By Matt Stine

Readers of Josh Bloch's "Effective Java" are sometimes perplexed when they reach Item #15: "Minimize Mutability." If we are to minimize mutability, then obviously we must maximize immutability. While all Java programmers utilize immutable objects every day (e.g. java.lang.String), when asked to create our own immutable classes, we often hesitate. However, if we push through this hesitation, we'll reap the benefits of simpler reasoning about program correctness, free thread safety, and other benefits.

One of the primary issues faced by enterprise Java programmers seeking to utilize immutable classes are framework issues. Enterprise frameworks from Spring to Hibernate have varying levels of support for immutability, ranging from decent to nonexistent. However, there several practical solutions available to the Spring developer, and this session will illuminate what's available.

By Mark Secrist

Many developers who are learning the Spring Framework think of it as simply another mechanism for centralized dependency injection. While the framework does handle that responsibility quite well, the framework is so much more. In this session, we'll explore some of the building blocks and patterns used by the core framework as well as many of the other Spring projects. The result is that attendees will gain a better understanding of how to use the Spring Framework and learn how to build their own components that can leverage these same patterns. Topics we'll explore: - What is the benefit of centralized lifecycle management - Programming to interfaces - Leveraging the power of proxies - Using annotations - Understanding the template pattern

Dependency injection is one very important part of what the Spring Framework does. However, it is also a collection of very key patterns that we'll explore. - Centralized lifecycle management - Examining the BeanFactoryPostProcessor - Examining the BeanPostProcessor - How to write your own BeanPostProcessor - Programming to interfaces - Benefits of programming to interfaces - loose coupling - Examples of how Spring leverages this mechanism - How to leverage in your own Spring applications - Leveraging the power of proxies - How proxies work in Spring - How Spring uses them - Writing your own proxy-based solution - Using annotations - Examples of how Spring uses annotations - Using your own annotations - Understanding the template pattern - Purpose of template pattern - How Spring uses templates - Creating your own template

By Andy Clement and Martin Lippert

The Spring Tool Suite (STS) is constantly evolving to keep pace with developments in Spring as well as the larger world of enterprise application development. This talk focuses on Eclipse-based tooling for the latest features throughout the Spring ecosystem. With plenty of live demos, we'll show you how to get productive quickly with Spring and STS. We''ll start with reviewing areas including XML-free Spring development and then look at early support for specific Spring's next generation features. We'll also demo the Eclipse support for Java 8 (also AspectJ support for Java 8) and spend some time looking at how this enhances your Spring development experience.

In addition to the pure Java-based Spring programming, we will also cover the integration of the Groovy language tooling and show you how to program Spring apps in Groovy using the Spring Tool Suite.

We will then dive into the details of the tooling to demonstrate a number of hidden gems that help you improve your productivity every day, like the built-in validations and best practices, quick-fixes, auto-completions, and automated refactorings.

Last, but not least, we will review some of the performance improvements made recently in Spring Tool Suite.

Session Detail

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 the new features found in Spring Security 3.2 to an existing application to demonstrate how it can meet your authentication and authorization needs.

By Oliver Gierke

Spring MVC forms a solid foundation to implement REST based web-services in Java. However, in real-world projects developers still face challenges when it comes to advanced questions of REST. How to really leverage hypermedia? How to model more complex business functionality with REST. The talk introduces the Spring RESTBucks sample implementation of a hypermedia-driven REST web service and explains how it is using hypermedia elements to implement business processes and how Spring technologies (Spring Data REST, Spring Data JPA and Spring HATEOAS) help developers building the system.

By Emanuel Rabina

With the disconnect between the languages of the web (HTML, CSS, Javascript) and the languages of the server (Java, Groovy, Scala, etc), many libraries and frameworks have been invented over the years to fill this void, often resulting in views filled with back-end code, views filled with specialized syntaxes, or even the invention of completely new view languages abstractions; all for the purpose of transforming our server-side ideas into HTML, and few of which actually look like the HTML that it ends up as.

Enter Thymeleaf - a templating framework that uses HTML to create good old HTML.

In this presentation, you'll be introduced to Thymeleaf, some of its features, how you can use it in your Spring web projects, the growing ecosystem being developed around it, and how it uses natural templates to keep the web designer on your team, and inside each and every one of us, happy.

By Joshua Long and Andy Piper

Let's face it, the cloud is here to stay. The cloud's potential can seem sometimes overwhelming, but it doesn't have to if you use Spring. Spring - and the various Spring projects - already embrace the architecture characteristics that make for great, cloud-centric applications in any environment. While Spring works well on any cloud platform, it enjoys a special place in the sun on Cloud Foundry, the open source PaaS from Pivotal.

In this talk, join Andy Piper as he introduces how to build Spring applications that work well in the cloud and on Cloud Foundry in particular. We'll cover how to consume services with Spring on Cloud Foundry, how to scale out using RabbitMQ and Spring Integration, how to use standalone processes and RabbitMQ for better batch processing, and discuss strategies for exposing and consuming services in a RESTful service-based cloud architecture.

By Michael Hunger

Spring Data Neo4j in its 2.x version is a mature implementation of an object graph mapping framework, that both closely integrates with the Spring Framework and also offers unique modeling and querying opportunities by having chosen the property graph data model. This talk presents how several Neo Technology customers already put Spring Data Neo4j into production. They stem from a variety of domains – gaming, server center monitoring, education, appliance management, energy market simulation and more. Based on those use-cases we discuss how to implement real-world applications with Spring Data Neo4j and the Spring Framework. First we want to discuss the business problems they had to solve and why a graph database was a good fit for them. After a quick intro to Spring Data Neo4j and Neo4j, we will talk about modeling choices and the benefits and implications of choosing a rich data model. We'll follow the example domains into code, from annotated domain entities, to the usage of the powerful repository abstractions. Showing how to use Neo4jTemplate to implement some lower level functionality will round off the core library usage. Building on this, we look into the integration aspects, how Spring Data Neo4j can be combined with other Spring projects, like Spring Data MongoDB, Spring Data REST, and Spring Batch. A quick demonstration shows on how to access Spring Data Neo4j from the (Web)-UI layer. The talk will close of with a glimpse into the future: Neo4j added some very interesting features in its 2.0 release. From node labels, automatic indexes and constraints to a transactional http endpoint for Cypher. These changes make it possible to rethink some aspects of Spring Data Neo4j, like type representation and indexing. But also some bigger ideas for changes ahead like basing the object graph mapping completely on Neo4j's Cypher Graph Query Language will be touched.

Session Detail

By Rossen Stoyanchev

Last year's Intro to WebSocket presentation was as much about introducing WebSocket -- including specs, browser availability, server support -- as it was about summarizing short and long term challenges surrounding its use and leaving many open questions. What a world of difference a year can make!

This update to last year's presentation, covers the new standard Java WebSocket API (JSR-356) including a discussion of positives and limitations, an update on the current status of WebSocket support across Servlet containers, and of course the Spring Framework 4.0 WebSocket support -- how to configure and use it and what additional benefits it provides. A central part of this is Spring's support for SockJS, the protocol for transparent WebSocket fallback options for use in applications that for example need to run in IE < 10.

This presentation is for you if you want a comprehensive introduction to WebSocket including standard Java EE 7 and Spring Framework 4.0 support. For a more practical take on how to actually build WebSocket-style applications that skips the introduction, please attend the next presentation Building WebSocket Browser Applications with Spring by Rossen Stoyanchev and Scott Andrews, or attend both presentations. They are intended to be complementary.

Session Detail

By Thomas Darimont and 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 for relational and NoSQL databases. We will have a look at the lessons learned from the application of it in various customer projects and summarize best practices for you to apply in your projects. The session will also discuss advanced features like the Querydsl integration, the integration of custom implementation code as well as hooks into Spring MVC and Spring HATEOAS.

Session Detail

By Rossen Stoyanchev and Scott Andrews

This is a higher level presentation on how to build browser-based, WebSocket-style applications. If you prefer a proper introduction to WebSocket including RFC specs, browser support, JSR 356, Spring support, and more, attend the previous presentation Intro To WebSocket Applications with Spring Framework 4.0 or attend both sessions. They are meant to be complementary.

So, you've written a "Hello world!" WebSocket application or perhaps even a chat sample. You're able to exchange messages even in pre-Servlet 3.1 containers and pre-IE 10 browsers (that don't yet support WebSocket) thanks to the SockJS protocol and Spring's support for it. However a message is a blank page that can have any content. Whatever message format you choose, proprietary or standard, both client and server need to understand it as well as distinguish different kinds of messages. You need support for the publish-subscribe pattern, central to messaging applications so you can broadcast messages to a single subscriber, to a subset, or to all subscribers. You need to incorporate security, validation, and so on. In short you need to build a real-world application.

If you're used to web applications (and Spring MVC annotated controllers) you are familiar with the foundation that HTTP provides including URLs (nouns), HTTP methods (verbs), headers, parameters, and others. Imagine building an application without HTTP, just a socket. WebSocket gives you this brand new, exciting capability -- full duplex, two-way communication -- yet you no longer have an application-level protocol. Can an entire application be built around a single Endpoint class processing all messages, assuming a single WebSocket connection between browser and server?

Thankfully the WebSocket protocol has a built-in sub-protocol (i.e. higher level protocol) mechanism. In this presentation we'll introduce STOMP, an HTTP inspired simple messaging protocol, and Spring's support for building WebSocket-style messaging applications with it. We'll discuss the new spring-messaging module. We'll show how to map controller methods to client messages through annotations. We'll show how to back your application with a simple in-memory STOMP broker, or a full-scale one (Rabbit, ActiveMQ, etc). How to broadcast to connected clients including broadcasts from stateless HTTP requests. We'll show how to build client-side code using existing libraries such as stomp.js and also cujoJS msgs.js.

Session Detail

By Jan Machacek and Alvaro Videla

Jan will show how to use RabbitMQ to connect components on different platforms. After a few introductory slides explaining the main concepts, the rest of the talk will be live code. The coding will begin by showing Spring Integration code to connect to RabbitMQ to send and receive messages--think byte[] values back and forth to start with. Jan will then show the real power of RabbitMQ by replacing the RPC server component by native code in C++: we will write image processing component. To make matters even better--faster--we will then use CUDA to perform the image processing. Come to Jan's talk and demo if you want to find out how to use RabbitMQ in the core of your application, especially if your application needs to tie together code on completely different platforms and if it performs heavy number crunching or image processing. You do not need to have deep knowledge of Spring Integration, AMQP or OpenCV, …; all that you will need is your inner geek.

Session Detail

By John Hann

So you've been toying around with JavaScript. You have a basic feel for the language but don't quiet feel productive, yet. If so, this talk is for you. We'll peel away the abstractions, libraries, and frameworks to uncover the more interesting fundamentals of JavaScript. Specifically, we'll delve into the following:

• Prototypal inheritance (and alternatives to classical inheritance)
• Closures
• Scope versus context and this
• Public vs privileged vs private variables
• Modules
• Promises / Futures
• Recent improvements from EcmaScript 5 and 6
• Functional programming strategies
• Documentation using JSDoc
• Testing strategies
• and more!

Session Detail

By Cedric Champeau

Since Groovy 2.0, the Groovy language offers the ability to type check your code at compile time. Type checking is a nice feature for people who come from a strongly typed language world and do not feel comfortable with dynamic typing. On the other hand, Groovy is also a perfect match when it comes to writing DSLs. It becomes even more interesting if you know that you can combine strategies in order to provide the user with a statically checked DSLs.

In this session, we will introduce the type checking mechanism of Groovy and demonstrate some techniques that you can use to make your DSL compatible with the type checker.

By Cedric Champeau

The Groovy language has always been promoted as an excellent companion to the Java language, but also as a lightweight platform for building DSLs on the JVM. In practice, Groovy offers a wide range of options to integrate with Java: plain application then use it as a jar dependency, cross-compilation, GroovyScriptEngine, GroovyShell, ... Furthermore, each of those solutions have benefits or disavantages that you might not be aware of.

In this talk, we will discuss those options, show examples of integration and demonstrate how you can leverage the rich configuration options of Groovy to make the experience very smooth. If you ever dreamt of sneaky throwing Groovy into your heavyweight application, you may end up with new ideas to do so!

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 Daniel Mikusa and Stuart Williams

Apache Tomcat 8 will implement new versions of the Servlet, JSP and EL specifications as well as adding support for the new WebSocket specification. Work is also planned for internal refactoring in a number of areas that will impact a number of Tomcat specific features. This presentation will provide an overview of the changes and new features introduced by both the updated specifications and the Tomcat specific changes. With the first stable Tomcat 8 release expected towards the middle of 2013 (once the Java EE 7 specifications are finalised) this session will enable attendees to identify the Tomcat 8 features of greatest interest to them and provide them with the information required to start planning their migration to Tomcat 8.

Session Detail

By Juergen Hoeller

Spring has a track record of providing dedicated support for new Java generations in a timely fashion, and now it's right about time to go Java 8: With Spring Framework 4.0, we're providing in-depth support for all relevant OpenJDK 8 features, including lambda expressions, JSR-310 Date and Time, parameter name discovery, and java.util.concurrent enhancements. This talk will illustrate selected Java 8 features within Spring's programming model and explore the impact on application architectures.

Session Detail

By Brian Kotek

Page-based web applications were once the norm, but times have changed. Users increasingly expect rich, desktop-like experiences from their browser-based applications. They demand apps that adhere to common standards, without the need for special plugins. Finally, they want to use them on any device, from smartphone to flat-screen.

It's a daunting task, but help is on the way. Grails provides an awesome foundation for HTML-based Rich Internet Applications. In this session, we'll see how Grails can make HTML RIAs a snap.

JavaScript is the language of the web, but it has its warts. Grails plugins allow us to easily leverage intermediary languages like CoffeeScript or TypeScript to help create large-scale client-side code. Libraries like ExtJS or Dojo offer expansive UI toolkits that hook perfectly into Grails REST APIs. JSON and GSON are excellent data exchange formats, as long as you properly plan out their structure. And GORM is incredibly powerful, but without careful thought you can inadvertently send huge amounts of unnecessary data to the client.

We'll dig into each of these areas, and more. Come see just how much power and productivity Grails brings to the HTML RIA table.

By Joe Rinehart

Grails makes it easy to dive right in and build an application, but that's the tip of a very large iceberg. Joe Rinehart's spent years working in highly secured environments and been the subject of many top-to-bottom, OS-to-Web audits. Join him as he introduces publicly available security guidelines for Java/Grails applications made available by some of the strictest clients in the world, showing how Grails can often make life much easier.

"STIGing." It's a phrase that makes even seasoned secured application developers wince.

What's a STIG? It's a "Security Technical Implementation Guide" - a grammar fail only the U.S. Government could manage. It's usually a product-specific, hundred-plus page PDF or XML document describing applicable security controls.

These are not thrilling reads.

Their content, however, is fantastic: from obvious XSS issues to nuances of running Tomcat within an application security manager, they present a holistic approach to technical application security.

Join Joe as he walks through the essential security topics for Grails (and Java) Web applications, showing how Grails can often lighten your load and the pitfalls of attempting to secure highly dynamic code.

By Kenneth Kousen

Watch Preview Video

Groovy has a very easy learning curve for Java developers, so many people become Groovy users without realizing all it can do. This presentation will examine features of Groovy that can make your life easier once you're past the initial adoption stage.

Examples will include closure coercion, mixins, simple runtime metaprogramming, operator overloading, drop and take, a tour through some of the overlooked methods in the Groovy JDK, and more.

Prerequisite: Some Groovy knowledge

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

We all know how to code various patterns of behavior. But when your app needs to be used in the Real World(tm), there are certain things that are key.

In this talk, we'll walk through a production-grade Grails application that includes the following characteristics:

By Joe Rinehart

Somehow I've gained a reputation for applications that users think look good and are easy to use. I think my code's sometimes pretty, but please don't ask me to center something in CSS or Photoshop my way to fame and fortune. Recently, all the credit really goes to Twitter's Bootstrap UI library.

Join me for a bit as I take you through the basics of integrating Bootstrap into a Grails application, its semantics, the "whoa, that just works!" controls it provides, where to find nice add-ons such as Bootstrappish icons, and how you can leverage the Grails framework to make your Bootstrapped life even easier.

By Cornelia Davis and Scott Frederick

As you find it in the open-source codebase, Cloud Foundry includes a set of prepackaged services (Postgres, MySQL, Redis, MongoDB and RabbitMQ) and a number of application runtimes (Java, Ruby and Node.js). In addition, CloudFoundry.com integrates with a number of external service providers through a services gateway. When you are deploying your own Cloud Foundry you can extend the existing open-source features by adding additional services and runtime support. In fact, you can bring your own runtime to any Cloud Foundry (including CloudFoundry.com) via buildpacks. In this session we will show you how to build and deploy, or broker custom services. We will also introduce you to buildpacks, show you how to create your own, and how to get your apps to use them.

Session Detail

By Jeremy Grelle

As the complexity of web and mobile apps increases, so does the importance of ensuring that your client-side resources load and execute in an optimal and efficient manner. Differences in resource loading techniques can have a dramatic impact on how fast an application feels to your users, and can be the catalyst for whether they have a joyful or frustrating experience. This talk will discuss performance techniques aimed at keeping your users on the joyful end of this user experience spectrum.

We'll take a look at:

• Pragmatic tools for measuring client-side performance

• Techniques for optimizing resources and their resulting impact

• Approaches to maximizing dev-time happiness and production performance

• Easy incorporation of these techniques into your everyday tool-chain

Session Detail

By Gary Russell

Spring Integration Internals

A comprehensive review of message routing within a flow - including

• exactly how and when replyChannel and errorChannel headers are used

• how and when these headers apply in an error flow

• differences between synchronous and asynchronous processing (with task executors and pollers)

• Use of SpEL (for messagemethod mapping as well as certain "dynamic" config attributes)

• Type conversion (via SpEL, datatype channels, etc)

• Implicitly created channels

• How chains work

• How messages are mapped to methods when a message arrives at a component

• How gateway methods are mapped to messages (and a first look at some enhancements we are considering)

• Options for synchronous and asynchronous flows

  • simple multi-threading
  • aggregation
  • aggregating messages from different sources

• How to debug Spring Integration applications

• Advanced configuration techniques

and more...

This presentation will be mainly demonstration and code walkthroughs.

By Daniel Lipp and Tobias Mattsson

Want Spring seamlessly available inside a CMS? How about being able to integrate existing Spring apps into your CMS without rewriting a bunch of code? What about a robust CMS solution for Grails? Meet Magnolia, a mature open source CMS written in Java on the best of the Java stack (including Spring and Groovy.)

This session will introduce Magnolia's Spring integration and give you a tour of its architecture, key features and use. Along the way, you'll also get insights into the development of Magnolia's Spring integration, an overview of Magnolia's key features (like workflows, innovative multi-channel support and a damn fine user experience that includes touch devices), and brief tutorials on solving some key content management challenges faced by Spring developers. There will also be a quick detour into Magnolia's Groovy shell and MagLev, a Grails plugin for Magnolia.

Session Detail

By Daniel Woods

Groovy provides flexible and dynamic capabilities for developing modular, maintainable code. With Groovy's extension framework, developers can modularize common application utility functions. Leveraging Groovy's dynamic nature can allow developers to create powerful, easy-to-follow business components. Employing Groovy categories and mixins can help localize and simplify transformation and adaptation logic that would otherwise be verbose and difficult to maintain.

This talk will focus on leveraging the strengths and flexibilities in Groovy to employ a powerful, maintainable, and simple application architecture.

By Peter Niederwieser

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

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

Getting software from a developer's machine to a production environment without a fully automated process is time-consuming and error-prone. Continuous Delivery enables building, testing and deploying of software through build pipelines with well-defined quality gates.

In this session, we will discuss how to build an exemplary pipeline with the help of Gradle and Jenkins.

By Hans Dockter

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

Gradle continues 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:

• Maven import and archetype support
• Parallel task execution
• Improved Dependency Reporting
• Dependency management improvements that make Grade the best dependency system out there.
• Additions to the task model like soft dependencies and finalizer tasks.
• Gradle Android and C/C++ Support
• Improvements to the Tooling API (i.e. embedded Gradle)
• Better scalability for large scale enterprise builds
• Using Jenkins slaves for distributed test execution.
• Deep integration with Arquillian for deploying to web and JEE servers.

We’ll also take a sneak peak at some of the upcoming features that will soon be available in Gradle.

By Hans Dockter

Discussions around Builds and Buildsystems haven't been treated for many years with the conceptual depth and principles they deserve and require. The lack of this is even more painful today as modern builds form a crucial part of a continuous delivery pipeline far away from the simple copy, compile and archive of the past. We will discuss the concepts of declarative and imperative builds, standardization of your build process, the executional model of a build system and dependency management. We will shed a lot of light into the dark with surprising results that are crucial to understand when deciding for a build system.

You will learn in this session :

• What are declarative and imperative build and build systems? Followed by an in-depth discussion about advantages and dangers of their approaches.
• Why Maven is more imperative than you might think.
• The sweet spot in between standardization, declarativeness and necessary flexibility.
• Gradle’s state of the art declarative approach shown by example of the new Gradle based Android build system.
• Why and what it means that builds should focus as much on developer productivity as on enforcing the software factory.
• Why also smaller projects should care about build system concepts (the larger ones don’t really have a choice.)
• The importance of a rich execution model for build systems.
• The problems with POM based dependency management and solutions to this.

This talk is driven by many examples from Gradle, Maven and Ant builds.

By Juergen Hoeller

In recent years, the Spring Framework focuses on flexible and powerful Java-based configuration. This talk presents Spring as an annotation-oriented application framework, illustrating the rich set of features that Spring has to offer for modern component design. General component model trends will be discussed along with selected Spring feature highlights, such as standardized annotations for dependency injection, stereotypes, and declarative services such as validation and scheduling.

Session Detail

By Josh Long and Kevin Nilson

It’d be nice to assume everything remains the same from one environment to another, but the realities of today’s deployment targets (clouds, app servers, etc.) make this difficult. An application may target one in-memory database in development and target a traditional database in production. A/B testing is a common practice that lets you incrementally expose potentially high risk features. Feature switches can be invaluable; should something go wrong, you can revert to a known state. All of these use cases, and more, can be handled using the Spring framework.

Join JavaOne Rock Star and Java Champion Kevin Nilson and Spring Developer Advocate Josh Long for a look at how you can run your application in differing environments using the Spring Framework.

By Roy Clarkson and Joshua Long

No application is an island and this is more obvious today than ever as applications extend their reach into people's pockets, desktops, tablets, TVs, Blu-ray players and cars. What's a modern developer to do to support these many platforms? In this talk, join Josh Long to learn how Spring can extend your reach through (sometimes Spring Security OAuth-secured) RESTful services exposed through Spring MVC, HTML5 and client-specific rendering thanks to Spring Mobile, and powerful, native support for Android with Spring Android.

By Adam Shook

This session assumes absolutely no knowledge of Apache Hadoop and will provide a complete introduction to all the major aspects of the Hadoop ecosystem of projects and tools. If you are looking to get up to speed on Hadoop, trying to work out what all the Big Data fuss is about, or just interested in brushing up your understanding of MapReduce, then this is the session for you. We will cover all the basics with detailed discussion about HDFS, MapReduce, YARN (MRv2), and a broad overview of the Hadoop ecosystem including Hive, Pig, HBase, ZooKeeper and more.

Hadoop Ecosystem Overview

HDFS Architecture

Hadoop MapReduce -- MRv1 and YARN (MRv2)

MapReduce Primer -- Components and Code Example

By Peter Bell, Costin Leau, Michael Nitschinger, and Christoph Strobl

Spring Data has stared as an umbrella project consisting of many individual modules - per supported data store. While some of these data store modules - like the JPA and MongoDB ones - are maintained by Pivotal engineers a lot of community implementations have popped up lately. They build on the foundations of the Spring Data Core module and expose the Spring Data programming model for others stores.

The session will feature maintainers and contributors of the community modules for Solr (Christoph Strobl), Elasticsearch (Costin Leau), Couchbase (Michael Nitschinger) and MongoDB (Peter Bell), who will talk about the latest and greatest features of the upcoming releases and give an impression of how they used the APIs of Spring Data Core to build the module.

session detail

By Mike Wiesner

Creating a secure application involves more then just applying Spring Security to it. This is of course not a new topic, but with the increased popularity of much more dynamic configurations for Servlet Containers and various Spring Projects, like Spring MVC and Spring Integration, it becomes more important to know about the Security tradeoffs we might get with that, and how to tackle them.

By Scott Andrews, Tim Branyen, and Matias niemela

As clients have become more capable, developers are revisiting the server-centric page rendering approach and moving the MVC layer, in part or sometimes in whole, onto the client. When building a rich front-end there are an increasing number of choices available. This talk will dive into two emerging choices that are taking the web by storm: AngularJS and Backbone.js. Leaders from both communities will provide an introduction to each technology followed by a round table discussing front-end technology, answering questions from the audience. Special guests from Sencha and cujoJS will join the panel for Q&A.

session detail

By Andrey Cheptsov

When it comes to productivity, what counts is reliable and smart support from your IDE for the frameworks in your project. IntelliJ IDEA’s support for Groovy, Grails and Spring has been going strong for the last few years, expanding and refining its features with each new release.

Let’s explore the most tricky features of the IDE that help developers to be more productive.

By Josh Long and Phil Webb

Using a module that provides a Spring XML namespace and integration API is muscle memory for most people: add the .xsd to the imported XML schemas for the configuration file, maybe enable a annotation-driven variant if it's available, autocomplete some XML stanzas, and then you're set! But what about Java configuration? Java configuration has been around in some form since at least 2005. It was merged into the core framework in 2009 and since then we've seen a slew of new Java configuration-powered DSLs pop up. 2013, in particular, has seen alpha-or-better cuts of Java configuration support for Spring MVC, Spring Security (and Spring Security OAuth), Spring Batch, Spring Social, Spring Data (including all the modules under it: REST, MongoDB, JPA, Neo4j, Redis, etc), Spring HATEOAS, and more all provide milestone-or-better cuts of a Java configuration integration. Tomcat 7 (and all Servlet 3-compatible containers) offer a programmatic alternative to web.xml. This provides another great integration hook for modules that wish to integrate with the web container, removing the configuration burden from the user. There's a lot of power here and it's easy to get started if you know what to look for. In this talk, join Spring Developer Advocate Josh Long and Spring-core commmitter, all-around nice guy, and Spring Boot ninja Phil Webb as they introduce the Java configuration support in the various Spring projects, show how to approach them when integrating them into your code, and - if the situation demands - how to write your own Java configuration DSL.

Session detail

By Chris Beams

Join Chris Beams as he dives into http://spring.io - the new spring website. It's chock full of amazing new resources that you can share with your co-workers who might be new to Spring, or simply helping to introduce Spring to those who might not be familiar with it - people coding in other languages, frameworks, or platforms. You've asked us to help make it easier to win the comparisons, and we've listened. Attend this session to get the ammo you need to win that internal bake off.

Session detail

By Michael Minella

JSR-352 is billed as bringing a standardized batch programming model to Java. What does the spec provide, what does it not, and what does it mean for Spring Batch applications? We will address all of these questions as well as provide insight into how Spring Batch will work with the JSR in a real world example.

Session Detail

By Lyndon Adams

As Information Technology evolves and improves, the demands of industry and the internet continue to challenge its capabilities. Today's 'Internet of Things', with millions of devices reporting their status on the network every second, produces massive streams of events. Getting the information in these events consumed and correlated so that it can be used to make routing and processing decisions on related events is particularly challenging. As the data demands of these processes increases, traditional client-server architectures begin to fail. Combining event processing with patterns and knowledge gleamed from Big Data models enables whole new kinds of real-time applications. Spring Integration and other Spring projects play a big role in this new paradigm, adding developer productivity and ease of integration into the mix. Lyndon will discuss and demonstrate the architectural decisions and use cases that occur when Fast Data meets Big Data.

Session detail

By Zhiyong Li

SAS® Institute has a large portfolio of Java EE applications. SAS had previously provided support to deploy and run all of these applications in WebLogic, WebSphere and JBoss. Beginning with SAS 9.4, which was released in July 2013, SAS updated its infrastructure and middle tier platform to deliver and run on Pivotal tc Server. In this talk, we will discuss the motivation, technology selection, architecture, system administration, automated installation and configuration, etc., that SAS used to improve value for its customers.

Specifically, we will discuss the following areas in detail:

• Technology selection: To make tc Server viable, we include the messaging, caching and the transaction management system.
• Architecture: To leverage tc Server scalability and reliability in SAS products, we support clustering by using the vFabric Web Server and the mod_proxy.
• Application migration: We provide guidance to our Java developers and configuration developers on how to migrate their applications to the tc Server environment.
• Security: We support SSL, single sign-on and other enterprise security protocols such as Integrated Windows Authentication, CA Site Minder, IBM Web Seal, SAML, etc.
• System administration: We provide a single entry point to manage all SAS application stacks including all web applications by leveraging the VMware Hyperic product.
  
• Automated installation / configuration: We provide the automated process to install and configure all vFabric products (tc Server, vFWS, Hyperic and GemFire) and SAS web applications.
• Delivery and support: SAS delivers embedded tc Server as the SAS Web Application Server for use with all our offerings with a midtier on all our supported host platforms. This enables SAS to provide complete supported application architecture with more complete visibility and control of the critical software.
  
• Cloud deployment: This approach also provides advantages for our customers leveraging virtualization and cloud deployment strategies.

By Jason Cline

The proliferation of mobile devices poses challenges for corporate IT departments. End users want to choose their own device, but also want to access corporate web applications, but the need for security often means that they have to surrender management of their device to their IT department. With this in mind, we've created Sencha Space -- a secure and managed environment for deploying HTML5 business applications that run on multiple devices. During this session, Sencha's Sr. Developer Evangelist, Greg Rewis, will discuss the Sencha Space SDK’s device-level options for secure data storage, as well as show you how to implement the Invoke API to connect web applications with one another. You’ll also experience how easily applications can be centrally managed without the need to access the device.

Session Detail

By John Davies

We've had powerful Rules Engines and Complex Event Processing for a good decade now and there are several powerful ones on the market, some even open source. Many of these engines though have been build around single albeit efficient applications running on a single machine. As we take Big Data head on we start to see the need to rules that we can distribute and complex events processing across our distributed system. Combining Pivotal's GemFire and C24's Integration Objects, naturally glued together with a little Spring, we can process millions of complex events in seconds. John will walk through some of the design and use-cases of these powerful system.

Session Detail

By Param Rengaiah

By now you should have heard about coupling and cohesiveness. These concepts, and their third cousin, polymorphism, is what we as developers chase day-in and day-out. They tease us with reusability and the promise of comprehensiveness of our code. They entice us with promises of code quality and testability. They came in the form of "Object Oriented' design, followed by GoF and SOLID Design Patterns, DDD, BDD.. but none of them delivered what they promised. Now, the new kids on the block are Functional Programming and Modularity Patterns.

What happens when you choose to go through large refactoring exercise on the back of Modularity Patterns, in a large, complex enterprise project? The journey was long, arduous and gruesome. On the way, I made many enemies and found some new friends. This talk will highlight the issues, both technical and otherwise, and how it was overcome; where did Spring help and where did it hurt. In the end, was it worth it? Come to this session and you will find out.

tbd

By Kenneth Kousen

Grails 2.3 makes it much easier to build RESTful web services from your domain classes, and even includes hypermedia capabilities. This presentation will demonstrate those capabilities and then add a JavaScript client-side framework like AngularJS. The Ratpack framework will also be used as an alternative server-side implementation.

Tests and build files will be included in a GitHub repository.

By Jeff Scott Brown

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

Part of what makes Grails so compelling is its really powerful plugin system. The Grails plugin system allows capabilities to be bolted on to applications, including adding support for a variety of programming languages. All of the major programming languages available on the JVM are supported by The Grails Framework. These include Java, Groovy, Scala, Clojure and others.

This session will dive in to that aspect of the framework with a focus on Scala and Clojure and will demonstrate what is involved in adding support for new languages.

By Smitha Gudur and Manoj Joshi

Cancer/life science drug research models are very rich in relationships, relationship heterogeneity and entity inter-dependencies. Most entity metadata is dynamic and unpredictable making it difficult to fit such models in traditional relational landscape. Redbasin Networks uses a hybrid Nosql strategy that supports composite and rich document metadata that is interconnected pervasively. Cancer and life science data is excessively nested. You will find this useful if you are building complex engineering and/or scientific applications, and need insights on how to merge data from many diverse data-sets and map it to an intuitive and effective graph database model.

We will show using code examples how complex metadata can be engineered using Spring, Neo4J and Mongo, to create useful drug insights for the drug researcher, and also provide a platform for technologists to build sophisticated life science applications.

Session Detail

By Adrian Colyer, Juergen Hoeller, Dave Syer, and Chris Beams

Opening keynote

By Mark Fisher, Graeme Rocher, and Mark Pollack

keynote