You've read that the relational model is old and busted, and there are newer, faster, web-scale ways to store your application's data. You've heard that NoSQL databases are the future! Well, what is all this NoSQL stuff about? Is it time to ditch Oracle, MySQL, and SQL Server in favor of the new guard? To be able to make that call, there's a lot you'll have to learn.

�

In this session, we'll take a whirlwind tour of five representative non-relational data stores: Cassandra, MongoDB, Voldemort, Redis, and Neo4J. We'll learn the very different ways they represent data, and we'll see their unique strengths and weaknesses in various kinds of applications. Along the way, we'll learn why new technologies must be introduced to address today's scaling challenges, and what compromises we'll have to make if we want to abandon the databases of our youth. We'll review what ACID means, role-play a two-phase commit, and even talk a little bit about file system semantics. It's an exciting time to be storing and retrieving data, and the opportunity is now before us to learn things we could ignore just a few years ago. Come to this session for a solid introduction to a growing field.

�

Every time a new software project is launched everybody aims for a high-level of technical quality. But more often than not we see the code quality deteriorating over time and it becomes harder and harder to understand and maintain the code. On the other hand a reasonable level of technical quality can be easily achieved in any software project, if it is kept in mind as a goal from the beginning. Of course it is necessary to measure it on a regular base, ideally at least in the nightly build.

Doug's presentation will delve into three internal parts of Java

- Class File Format and Byte Code

- Garbage Collection

- JIT Optimizations

In the Class File Format and Byte Code section, the basic structure of the class file format will be explained with examples of Java files compiled to class files.

Additionally, attendees will be introduced to tools for viewing and writing byte code.

Traditional enterprise integration deployments are based on the "centralized server" physical deployment model. This deployment model all started with the success of big Relational Database Management Systems (RDBMS) for centralized management of data, extended into the application server tier with big Java EE Application Servers for centralized management of applications, and finally into the integration tier with big Business Process Management Server / Enterprise Services Bus Servers for centralized management of the integration tier.

The cloud (whether it be private, public, or hybrid) allows for massively parallel, horizontal scale-out architectures. This is radically different from the centralized, vertical scale-up architectures that have evolved from the original success of big-RDBMS on physical hardware. In putting together its Cloud Application Platform, named vFabric, VMware has made two key acquisitions over the past year to enable Spring Applications deployed on tc Server to be scaled elastically within the cloud:

• , an in-memory data fabric that goes well beyond typical caching of data allowing for fast read/write of globally distributed data across a heterogeneous environment; and
• , a lightweight message broker, based on the AMQP standard, allowing for fast asynchronous, reliable messaging over the TCP protocol within a globally distributed, heterogeneous environment

Spring Integration is an embedded message bus that runs within any Spring application context and an application integration framework that connects to other systems via adapters. It is built on the Core Spring programming model and provides a couple of key abstractions that can enable systems integrators even greater flexibility to continually evolve their solutions as technology and business requirements change:

• Message: a payload can be any object, and header values are stored in a simple map

• Message Channel: a portable abstraction over the messaging transport being used that allows the application developer to change between multiple channel adapters (i.e. JMS, AMQP, REST) as a matter of configuration, not code

• Message Endpoint: delegate a received message to any Spring-managed object for handling

• Message Store: a portable abstraction over the data store (i.e. RDBMS, Cache) being used to track a message as it passes through the loosely coupled messaging system

In this discussion, we'll talk about the newest support for Caching and AMQP within Spring Integration and how application developers are building a new class of enterprise integration applications that are purpose-built for elastic scalability within the cloud.

In this session we will take a deep dive at few cloud computing examples and participants will be able to know how to use cloud computing for Google App Engine and Amazon EC2.

The Google App Engine is a platform for developing and hosting web applications in Google-managed data centers. The Google App Engine is an example of cloud computing technology as it virtualizes applications across multiple servers and data centers. It is, at its heart, a powerful cloud computing platform designed to help you more easily create and manage scalable, JVM-based web applications. If you're developing a Java application on App Engine you probably already know that you can use JPA and JDO Java persistence APIs to interact with the data store. Now learn how to take full advantage of these powerful APIs. We will explore few examples from Amazon EC2 like how to deploy groovy on grails application. We will also look at development tools to make your life easier while working with Amazon EC2, Amazon S3 and Simple db.

Scala is a static fully object-oriented, functional language on the JVM. While taking advantage of the functional aspects, you can continue to make full use of the powerful JVM and Java libraries. In this presentation we will take a in depth look at what Scala is, its strengths, weaknesses, and why, when, and where you'd use it on your applications.

Apache Pivot (http://pivot.apache.org) is a platform for building rich Internet applications (RIAs) in Java. It combines the enhanced productivity and usability features of a modern RIA toolkit with the robustness of the industry-standard Java platform. Pivot includes a number of features that significantly simplify development of modern GUI applications, including an XML markup language for declaring the structure of a user interface, data binding, animated effects and transitions, and Web services integration.

�

In this session, Pivot founders Greg Brown and Todd Volkert provide an overview of the Pivot platform and walk through the implementation of a simple but practical application that highlights key platform features and development best practices.

The ESB concept emerges from integration requirements that have remained mostly stable and pervasive over the years. Yet many developers feel like they are run over by the bus, especially when an ESB is foisted onto their projects. Open source ESBs offer a flexibility and transparency that is hard to match without access to the source code. In the first half of this talk, we will detail the architectural considerations behind ESBs and how they are realized in JBoss ESB. With this understanding, the audience should be well prepared to use and customize ESBs to meet their specific project needs.

Once we understand the motivations for ESBs we will next turn our attention to the relationship between ESB, REST and Cloud. We will see that in many ways each complements the other, opening possibilities that are hard to achieve in isolation. In particular, the growing prevalence of clouds will place new demands on ESBs, and we will see how REST patterns serve to integrate these ideas.

You've heard about agile: it's the best thing since sliced bread -- it's hacking. It will save your project -- it will drown you in minutiae. You can't control the process--you can see exactly what's work and what's not working. You've heard agile described as all of the above.

Agile is a real way to see your projects make progress. And while it works, it's not for everyone. In this experiential session, Johanna will guide you through a 30-minute agile project. You'll have a chance to work on a cross-functional team, in timeboxes, have the conversation about what "done" means, and explore some facets of agile.

If you've never experienced Agile, you can't tell fact from fiction. This is your chance to experience Agile and see what it might take for you to get from where you are to Agile. Bring your questions, and plan on having a little fun with your learning.