SpringOne - Schedule

By Juergen Hoeller

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

Details updated soon.

By Juergen Hoeller

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

Details added soon

By Graeme Rocher

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

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

By Graeme Rocher

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

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

By Ben Alex

Delight your customers and impress your colleagues by delivering enterprise Spring applications faster than ever before. In this session we'll introduce Spring Roo, an open source tool that makes it easy to build applications using the Java language, standards and technologies you already know.

In this demonstration-oriented session, we will show you how Spring Roo delivers: * Support for Java standards including JPA, Servlet Spec, JSP, JavaBean Validation, JavaMail, JMS etc * Transparently reverse engineering and synchronising database schemas * Scaffolded UIs in Google Web Toolkit (GWT), Adobe Flex and Spring MVC * Automatic JUnit tests, Maven builds, JSP pages, toString() methods etc * Deploying to clouds such as Google App Engine * Extending Roo with add-ons * Removing Roo from your project in four clicks This session will also highlight what's new in Spring Roo 1.1 and preview other in-depth sessions at SpringOne that cover Spring Roo.

By Ben Alex

Delight your customers and impress your colleagues by delivering enterprise Spring applications faster than ever before. In this session we'll introduce Spring Roo, an open source tool that makes it easy to build applications using the Java language, standards and technologies you already know.

In this demonstration-oriented session, we will show you how Spring Roo delivers: * Support for Java standards including JPA, Servlet Spec, JSP, JavaBean Validation, JavaMail, JMS etc * Transparently reverse engineering and synchronising database schemas * Scaffolded UIs in Google Web Toolkit (GWT), Adobe Flex and Spring MVC * Automatic JUnit tests, Maven builds, JSP pages, toString() methods etc * Deploying to clouds such as Google App Engine * Extending Roo with add-ons * Removing Roo from your project in four clicks This session will also highlight what's new in Spring Roo 1.1 and preview other in-depth sessions at SpringOne that cover Spring Roo.

By Andres Almiray

Building a desktop application is a hard task, there are some many things to keep track of that many projects simply fail to meet their goals.

Setting up the project structure keeping each artifact on a well identified location given its responsibility and type, defining the base schema for managing the application's life cycle, making sure the build is properly setup, and more. These are recurring tasks that should be handled by a tool or better yet, a framework.

Griffon is such a framework. Inspired by the Grails framework Griffon aims to bring the same productivity gains to desktop development. In this session you will learn how to build a RESTful and rich application in less than 40 minutes, honest!

By Andres Almiray

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

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

By Scott Andrews

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

Session Detail

By Scott Andrews and Jon Travis

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

Session Detail

By Scott Andrews and Jeremy Grelle

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

This session is aimed at experienced Java web developers. It will cover: -Rapidly building lightweight RESTful services with Spring 3.0 and Spring Roo to support rich HTML5 clients -How to carry over the concepts of Java EE APIs such as JPA and Bean Validation to a smart client -Async message-based communication over Web Sockets.

By Jean Barmash

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

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

By Jean Barmash

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

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

By Chris Beams

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

Session Details

By Chris Beams

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

Session Details

By Burt Beckwith

You've used GORM in Grails apps, you've written custom criteria and HQL queries, and now you're ready to take database access in Grails to the next level.

In this talk we'll look at improving performance of Grails apps by avoiding mapped collections, strategies for second-level caching using EhCache, runtime monitoring and graphing, and using a custom Configuration subclass to customize your Hibernate config beyond what GORM mappings provide.

By Burt Beckwith

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

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

By Burt Beckwith

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

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

By Peter Bell

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

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

By Peter Bell

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

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

By Peter Bell

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

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

By Tim Berglund

Grails has enabled your team to achieve productivity levels you never knew possible for web applications on the JVM. Now you’ve carefully crafted a piece of enterprise software to be deployed in a complex environment including a legacy database, monitoring and logging standards, and pushbutton deployment requirements. You’re moving faster than ever, but it still seems harder than the blog-in-15-minutes demo you saw at that user group a couple of months ago. For a framework that sometimes seems biased towards the greenfield installation, this can be a challenge.

In this session, we'll learn the right internal framework details, deployment patterns, and Grails plugins to make your Grails deployment a success for both greenfield and brownfield apps. We'll cover responsible database schema migration, management with JMX, logging, secure remote deployments, and more. Come prepared to have your Grails toolbox loaded up.

By Tim Berglund

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

Grails provides popular plugins for such NoSQL standbys as Lucene, Voldemort, Cassandra, and MongoDB. In this session, we'll take a quick look at each of those four NoSQL database technologies, how the products function on their own, and how their Grails plugins work. Come prepared to see lots of code and lots of data—in ways you may not have seen it before.

By Jon Brisbin

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

Session Detail

By Jeff Brown

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

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

Prerequisite: Advanced Grails

By Jeff Brown

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

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

By Jeff Brown

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

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

By Jeff Brown

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

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

Prerequisite: Advanced Grails

By Roy Clarkson and Jeremy Grelle

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

Session Detail

By Hamlet D'Arcy

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

Come learn about the principles of Lean, and see how Groovy and the associated ecosystem help eliminate waste, defer commitment, and build quality into your product. Leave with new ideas about collaboration that both developers and business users will embrace. Audience: Team leads looking for low risk but effective ways to increase velocity.

By Hamlet D'Arcy

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

This session reviews these approaches including examples of how and why we'd want to do this. Come see the newest Groovy language tools, look in-depth at production deployed AST Transforms, and view libraries based on these techniques. Audience: developers searching for cutting edge solutions to increasing team velocity.

By Joshua Davis

This session will describe hands-on procedure to use the Grails Portal project as a launching pad for quickly creating web applications.

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

By Joshua Davis

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

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

By Scott Davis

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

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

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

By Scott Davis

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

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

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

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

By Hans Dockter and Ken Sipe

Gradle allows you to describe your build using a rich, easily extendable build language based on Groovy. It provides compelling solutions for many of the big pain points that exist with current build systems. This session will be mostly driven by live demos. You will see how easy and elegant Gradle enables you to solve a broad range of requirements - over the full life cycle of typical and atypical Java builds.

Gradle pushes declarative builds to a new level. It allows users to provide there own declarative elements and to customize the behavior of the build-in ones. Thus enabling concise, expressive and maintainable builds. All this is build on a rich, flexible imperative layer of tasks. With its Deep API Gradle allows you to hook in and customize every aspect of the build, be it configuration or execution behavior. Gradle comes with many optimization strategies for building fast and yet reliable. It has a powerful support for multi-project builds and transitive dependency management. It allows to integrate with your existing Ant/Maven builds and your Ivy/Maven/Custom repositories. The demos wi

By Hans Dockter

The build domain is a complex domain to model. It is special, in that the developers of the build system are also the domain experts. Yet even so, the way to a deep model and a supple design is challenging. In this talk we will look at many examples how Gradle has improved by applying ideas from Domain Driven Design and other best practices for modeling. We will touch many areas of DDD. For example knowledge crunching, breakthroughs, making implicit concepts explicit, DSL's, and more. We will also take a look at the domain model of Ant and Maven in the context of DDD.

The build domain is a complex domain to model. It is special, in that the developers of the build system are also the domain experts. Yet even so, the way to a deep model and a supple design is challenging. In this talk we will look at many examples how Gradle has improved by applying ideas from Domain Driven Design and other best practices for modeling. We will touch many areas of DDD. For example knowledge crunching, breakthroughs, making implicit concepts explicit, DSL's, and more. We will also take a look at the domain model of Ant and Maven in the context of DDD.

By Hans Dockter and Ken Sipe

The project automation requirements of complex enterprise builds are the true stress test for any build system. Gradle has a special focus on enterprise builds. In this session we will talk about and demo on: Multi-project builds, incremental builds, parallel testing, dependency management and concluding with organizing build logic, custom plugins and custom tasks.

The project automation requirements of complex enterprise builds are the true stress test for any build system. Gradle has a special focus on enterprise builds. In this session we will talk about and demo on: Multi-project builds, incremental builds, parallel testing, dependency management and concluding with organizing build logic, custom plugins and custom tasks.

Prerequisite: Introduction to Gradle

By Keith Donald

A look inside the development of Spring Web Flow 3, the next-generation version of Spring's stateful controller framework for orchestrating multi-step user dialogs.

Session Detail

By Keith Donald

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

Session Detail

By Keith Donald

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

Session Detail

By Keith Donald and Stefan Schmidt

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

Session Detail

By Christian Dupuis

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

Session Detail

By Christian Dupuis

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

Session Detail

By Mark Fisher and Mark Pollack

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

Session Detail

By Mark Fisher and Dave Syer

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

Details to be added

By Mark Fisher

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

Details to be added

By Mark Fisher

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

Details to be added

By Adam Fitzgerald

Join this round table discussion featuring leading industry analysts who will date the impact of public and private cloud infrastructure on the future of enterprise production systems.

Session Detail

By Jeremy Grelle

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

Session Detail

By Jeremy Grelle

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

Session Detail

By Ben Hale

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

Session Detail

By Ben Hale and Andy Wilkinson

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

Session Detail

By Colin Harrington

In this talk, I'll do a deep dive on how Grails uses Sitemesh and explore integration/customization points as well as some light live-coding examples of how to use the apply layout tag in conjunction with layouts to achieve a very flexible and intuitive approach to developing DRY applications with Grails.

I will also cover material that isn't obvious, widely known or understood in the community.

By Colin Harrington

TBD

TBD

By Ryan Heaton

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

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

Welcome to OAuth for Spring Security!

By Ryan Heaton

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

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

Welcome to OAuth for Spring Security!

By Jennifer Hickey

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

Session Detail

By Jennifer Hickey

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

Session Detail

By Paul King

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

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

By Paul King

There have been many attempts to create languages which allow us to express our problems in higher-level languages: from COBOL to Object-Oriented languages, from Logic processing languages and SQL to rules engines. All have taken us forward in leaps and bounds but have failed to get very close to the language of the subject matter expert.

This talk examines how dynamic languages in general and Groovy in particular take us even further towards this goal. Groovy, is a popular and successful dynamic language for the JVM. It offers many features that allow you to create embedded DSLs: Closures, compile-time and run-time metaprogramming, operator overloading, named arguments, a more concise and expressive syntax and more.

In this talk we illustrate Groovy's DSL capabilities through numerous realistic examples. Throughout the talk, we will also tackle the often forgotten but key aspects of readability vs complexity, testability, evolution, and the various considerations to keep in mind while designing DSLs.

By Paul King

This talk looks at using Groovy for multi-threaded, concurrent and grid computing. It covers everything from using processes, multiple threads, the concurrency libraries ear-marked for Java 7, functional programming, actors including GPars, as well as map/reduce, grid and cloud computing frameworks.

We'll look at leveraging Java techniques as well as Groovy specific approaches. Multiple Processes with Ant, Java and Groovy Multiple threads - Java and Groovy support The java.util.concurrent APIs, Fork/Join, Atomicity and more Useful Java libraries: Google collections and others Useful Groovy AST transforms: Lazy, Synchronized, Immutable Concurrency libraries: Jetlang, Multiverse A brief glimpse at GPars Polyglot solutions with Scala and Clojure Grid computing and cloud solutions Testing multi-threaded programs

By Paul King

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

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

By Dave Klein

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

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

When we’re done, you’ll have learned about: Grails Domain Classes Dynamic scaffolding Grails Controllers Groovy Server Pages GSP Tags Grails Object Relational Mapping (GORM) Dynamically Injected Service Classes Grails’ Javascript and Ajax Support URL Mapping This is an introduction, but it is also a deep dive. So come prepared to code and to learn.

By Dave Klein

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

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

When we’re done, you’ll have learned about: Grails Domain Classes Dynamic scaffolding Grails Controllers Groovy Server Pages GSP Tags Grails Object Relational Mapping (GORM) Dynamically Injected Service Classes Grails’ Javascript and Ajax Support URL Mapping This is an introduction, but it is also a deep dive. So come prepared to code and to learn.

By Dave Klein

It's amazing how quickly one can build web applications with Grails in a greenfield environment, but most of us do not have that luxury. We have existing infrastructure and applications that we have to maintain and extend. We have legacy databases (or legacy database administrators) to deal with. Does this mean we cannot benefit from the magic of Grails? No way! The ease of use and productivity of Grails is matched by its power and flexibility. In this session we will discuss some of the ways that Grails can be integrated with the enterprise; EJB/JSF applications, Spring/Hibernate, legacy databases, and even non-Java applications.

Some of the strategies we will cover include: - Integrating with existing Spring MVC applications - JSF Integration with IceFaces - Communicating enterprise-wide with Web Services - Calling EJB session beans from a Grail application - Using Grails' ORM mapping to access legacy databases - Accessing JNDI resources from Grails - Using AJAX to call Grails' services from any web page

By Kenneth Kousen

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

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

By Kenneth Kousen

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

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

By Guillaume LaForge

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

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

By Guillaume LaForge

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

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

By Costin Leau

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

Session Detail

By Costin Leau

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

Session Detail

By Peter Ledbrook

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

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

By Peter Ledbrook

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

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

By Peter Ledbrook

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

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

By Charles Lee and Colin Sampaleanu

This special technical session will analyze and describe common private cloud deployment configuration and control.

Session Detail

By Charles Lee and Colin Sampaleanu

Following from session I, this special technical session will continue with practical considerations when implementing common private cloud deployments.

Session Detail

By Steve Mayzak

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

Session Detail

By Steve Mayzak

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

Session Detail

By Tom McCuch

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

Session Details

By Tom McCuch

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

Session Details

By Richard McDougall

This talk is aimed at Spring and Java developers who are interested in getting a deeper technical understanding of hypervisors and virtualization technology. We will explain the architecture of desktop and server virtualization, discuss the impacts to performance, and walk through the key tools and metrics that are available to monitor system performance. We take a whole stack view from the Java application, servlet container through and all layers of operating system and virtualization software. We will study several Java and Database workloads and observe measured performance in virtualized environments.

Session Detail

By Richard McDougall

This talk is aimed at Spring and Java developers who are interested in getting a deeper technical understanding of hypervisors and virtualization technology. We will explain the architecture of desktop and server virtualization, discuss the impacts to performance, and walk through the key tools and metrics that are available to monitor system performance. We take a whole stack view from the Java application, servlet container through and all layers of operating system and virtualization software. We will study several Java and Database workloads and observe measured performance in virtualized environments.

Session Detail

By Sudhir Menon and Jags Ramnarayan

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

Session Detail

By Marty Messer

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

Session Detail

By Marty Messer

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

Session Detail

By Justin Murray

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

Session Detail

By Justin Murray

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

Session Detail

By Peter Niederwieser

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

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

By Peter Niederwieser

Out of the box, programming languages can be a poor fit for the problems we are trying to solve. What if, instead of suffering from impedance mismatch, we could truly extend our language, moving it closer to the problem domain and allowing for new forms of abstractions that could not be expressed before?

This session demonstrates how to achieve this goal with Groovy's AST transforms, Scala's compiler plugins, and Clojure's macros. We cover the theory, write a simple extension, and discuss real-world applications.

By Arjen Poutsma

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

Details to be added.

By Arjen Poutsma

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

Details to be added

By Arjen Poutsma

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

Details to be added

By Jags Ramnarayan

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

Session Detail

By Chris Richardson

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

Session Details

By Chris Richardson

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

Session Detail

By Chris Richardson

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

Session Detail

By Colin Sampaleanu

This special technical session will analyze and describe common private cloud deployment configuration and control.

Session Detail

By Stefan Schmidt

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

Session Detail

By Stefan Schmidt

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

Session Detail

By Brian Sletten

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

Groovy raises the bar on what is possible with Semantic Technologies on the JVM. A rich dynamic language that interacts with a rich dynamic data model is all kinds of cool. We will combine Groovy metaprogramming and its expressive syntax to extend several existing Java-based Semantic Web technologies. We will also see how to produce machine-processable web pages using Grails and RDFa. This talk should be accessible to anyone familiar with Groovy. No Semantic Web knowledge will be assumed.

By Brian Sletten

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

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

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

We will start with an introduction to NetKernel and then steadily apply some Metaprogramming Fu to build up from there. You do not need to know anything about NetKernel, but this will be a challenging (and fun) talk.

By Matt Stine

When it comes to building Rich Internet Applications (RIA's), Groovy, Grails, and Griffon provide a synergistic combination that will make you extremely productive.

This talk will cover the use of Grails to provide a RESTful web services layer to a business system, Groovy's HTTP Builder to interact with those services, and wrapping that interaction with a responsive, master-detail front-end written in Griffon.

By Venkat Subramaniam

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

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

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

By Venkat Subramaniam

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

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

By Venkat Subramaniam

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

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

By Venkat Subramaniam

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

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

By Dave Syer

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

Session Detail

By Dave Syer

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

Session Detail

By Mark Thomas

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

Session Detail

By Mark Thomas

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

Session Detail

By Mark Thomas

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

Session Detail

By Craig Walls

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

Session Detail

By Craig Walls

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

Session Detail

By Mike Wiesner

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

Session Detail

By Mike Wiesner

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

Session Detail

By James Williams

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

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

By David Winterfeldt

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

Session Detail