Real Time Event Processing and Decision Making

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.

AngularJS, Backbone.js and Client-Centric Design

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.

Building WebSocket Browser Applications with Spring

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.

Real life use of Spring Integration with RabbitMQ

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.

In-memory data and compute on top of Hadoop

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.

IO, IO, it’s off to work we go

Opening keynote

spring.io inside and out

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.

Grails Plugin Best Practices

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.

Grails Transactions

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.

Securing Grails Applications

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.

Spring Data Community Lightning Talks

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.

Virtualizing and Tuning Large Scale Java Platforms

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.

Prerequisite: In addition to technical deep dive content, an interactive design workshop is planned to be solved in a group discussion. Finally and depending on interest and time an optional hands on lab (on your laptop) will be given. An opportunity to build, tune, and monitor the effects of tuning for the SpringTrader application.

AngularJS, Backbone.js and Client-Centric Design

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.

Reactor - a foundation for asynchronous applications on the JVM

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.

Metaprogramming With The Groovy Runtime - Part 1 of 2

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.

Metaprogramming With The Groovy Compiler - Part 2 of 2

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.

Polyglot Web Development With Grails 2

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.

An Introduction To Web Development With Grails 2

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.

Advanced Web Development Techniques With Grails 2

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.

AOP-ing your JavaScript

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.

Embedding Groovy in your Java applications

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.

Type checking your DSLs

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.

Becoming Productive Groovy/Grails and Spring Developer with IntelliJ IDEA

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.

Multi client Development with Spring

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.

Tooling for Spring's next generation

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.

Space Exploration: APIs for Secure Interconnected HTML5 Applications with Sencha Space

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.

IO, IO, it’s off to work we go

Opening keynote

Spring and Sencha - A Match Made In Heaven (or at least the cloud)

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.

Integrating Splunk into your Spring Applications

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.

Spring Data Repositories - Best Practices

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.

Distributed rules engines and CEP

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.

Extending Cloud Foundry with Custom Integration

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.

The Art of Builds - An in-depth comparison of build tools

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.

Gradle - the Innovation continues

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.

Performance-tuning the Spring Petclinic sample application

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

Spring and Sencha - A Match Made In Heaven (or at least the cloud)

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.

Tackling Big Data Complexity with Spring

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.

The rest of the dwarves…

keynote

Extending Cloud Foundry with Custom Integration

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.

Spring RESTBucks - A hypermedia-driven REST webservice

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.

Spring Data Repositories - Best Practices

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.

Building For Speed - Tips and Tricks for Client-Side Performance

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

Researching Cancer In the Cloud - Using Spring,Neo4J,Mongo and Redis In the Cloud

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.

REST-ful API Evolution

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.

REST-ful API Design

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.

Pragmatic JavaScript

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!

Patterns delivering JSON with Grails

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.

Testing Grails: Experiencies from the field

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

Running Spring in Amazon Web Services

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.

Free Yourself with CloudFoundry: A Private Cloud Experience

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.

Integrating Spring Batch and Spring Integration

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

Spring on Java 8

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.

IO, IO, it’s off to work we go

Opening keynote

Modern Component Design with Spring

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.

Real World Applications with Spring Data Neo4j

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.

Utilizing Groovy based closures for flexible real-time analytics

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.

Researching Cancer In the Cloud - Using Spring,Neo4J,Mongo and Redis In the Cloud

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.

Leveraging Groovy for Capturing Business Rules

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

Creating Groovy DSLs that Developers can Actually Use

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.

Working with Databases and Groovy

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

Functional Groovy

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.

Grails-Powered HTML RIAs

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.

Advanced Groovy Tips and Tricks

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.

Prerequisite: Some Groovy knowledge

Making Spring Groovy

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.

RESTful Groovy

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.

Prerequisite: Some knowledge of Groovy would be helpful

A Groovy Mullet: JavaScript in the front, Groovy in the back

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.

Spock: Logical Testing for Enterprise Applications

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.

Making Java Groovy

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.

Spring Scala

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.

Lift-off with Groovy 2.1

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.

Creating Groovy DSLs that Developers can Actually Use

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.

Spring Data Community Lightning Talks

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.

Your Data, Your Search, Elasticsearch

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.

Application Architectures with Grails

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?

Groovy for Spring/Java developers

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.

Inside Cloud Foundry: An Architectural Review

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.

Migrating SAS® Institute, Inc. Java EE Applications from WLS/WAS/JBoss to Pivotal tc Server™

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.

Spring and Web Content Management

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.

Tooling for Spring's next generation

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.

Building Your Java Configuration Muscle Memory

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.

Building Spring Applications on Cloud Foundry

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.

Multi client Development with Spring

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.

Multi Environment Spring Applications

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.

RabbitMQ is the new king

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.

Grails and the Realtime Web

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.

Reactor - a foundation for asynchronous applications on the JVM

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.

Spring and Web Content Management

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.

Orchestrating Tasks from the Cloud with Groovy and AWS SWF

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.

Apache Tomcat 8 Preview

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.

Integrating Spring Batch and Spring Integration

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

JSR-352, Spring Batch and You

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.

Inside Cloud Foundry: An Architectural Review

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.

Building a Continuous Delivery pipeline with Gradle and Jenkins

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.

Next Level Spock

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.

Free Yourself with CloudFoundry: A Private Cloud Experience

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.

AngularJS, Backbone.js and Client-Centric Design

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.

Multi Environment Spring Applications

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.

Spring Data Community Lightning Talks

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.

Building Spring Applications on Cloud Foundry

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.

Tackling Big Data Complexity with Spring

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.

The rest of the dwarves…

keynote

Spring Scala

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.

Troubleshooting Live Java Web Applications

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

Thymeleaf: improving your Spring view layer with natural templates

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.

In-memory data and compute on top of Hadoop

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.

Taming Coupling & Cohesive Beasts with Modularity Patterns and Spring

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.

Futures and Rx Observables: powerful abstractions for consuming web services asynchronously

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.

Uncle Sam's Guide to Grails Security

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.

Bootstrap Your App

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.

Getting started with Spring Data and Apache Hadoop

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.

Road to Grails 3.0

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

The rest of the dwarves…

keynote

RESTfully Async with Grails 2.3

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.

Spring Integration Internals

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

Search for the Holy Grail (and test it once found)

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.

Plugging the users in - extend your application with pluggable Groovy DSL

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.

Going Beyond Dependency Injection

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

Spring Testing

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.

Hadoop - Just the Basics for Big Data Rookies

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.

Open/Closed Software - Developing freemium application using Spring Framework

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.

The Pitfalls Of Building Large Scale Applications

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.

Asgard, the Grails App that Deploys Netflix to the Cloud

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.

Spring with Immutability

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.

Build Your Very Own Private Cloud Foundry

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.

Building WebSocket Browser Applications with Spring

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.

Intro To WebSocket Applications with Spring Framework 4.0

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.

Spring Data Community Lightning Talks

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.

Integrating Groovy and JVM Languages

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.

Compile Time metaprogramming with Groovy AST Transformation

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.

Exploring Groovy Annotations

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.

Applying Groovy Closures for fun and productivity

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.

Design Patterns in Groovy

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.

Data Modelling and Identity Management with OAuth2

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.

IO, IO, it’s off to work we go

Opening keynote

Zero Effort Spring

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 .

Inside Cloud Foundry: An Architectural Review

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.

Virtualizing and Tuning Large Scale Java Platforms

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.

Prerequisite: In addition to technical deep dive content, an interactive design workshop is planned to be solved in a group discussion. Finally and depending on interest and time an optional hands on lab (on your laptop) will be given. An opportunity to build, tune, and monitor the effects of tuning for the SpringTrader application.

Real Time Analytics with Spring

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.

How Not to Measure Latency

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.

Testing Controllers with Spring MVC Test and Spock

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.

Real Time Analytics with Spring

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.

Case Study - Using Grails in the Real World

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.

Getting started with Spring Data and Apache Hadoop

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.

Deploying, Scaling, and Running Grails on AWS and VPC

This talk will cover how to get your application running on AWS VPC and related services and various Grails plugins to help you along the way.

RabbitMQ is the new king

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.

Making Connections with Spring Social

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.

Building Reactive Apps

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.

Building APIs with Grails

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.

Building Your Java Configuration Muscle Memory

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.

Zero Effort Spring

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 .

Application Security Pitfalls

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.

Apache Tomcat 8 Preview

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.

Getting Started with Spring Security 3.2

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.

Message Driven Architecture in Grails

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

Application Architecture in Groovy

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.

Free Yourself with CloudFoundry: A Private Cloud Experience

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.