Sessions at TSSJS-Europe

TheServerSide Java Symposium-Europe is an intensive educational experience that will catch you up on essential development technologies, give you expert insight into today's most relevant frameworks, and teach you practical, real world ways to architect, develop, and maintain effective Java-based applications and systems. 

Browse all Sessions, Expert Panels and Fireside Chats

Sessions:

Expert Panels:

Fireside Chats:

Session Descriptions:

• Keynote: Supporting the RIA Space with Stephan Janssen, Founder/Chairman, Belgian Java User Group

Rich Internet Applications (RIA) has become a mainstream buzzword - But what does it mean for Enterprise Java developers? Based on a practical case study of Parleys.com (a next generation RIA e-learning platform) this presentation takes a closer look at which Java technology-based APIs and frameworks are available for developing such a project, addressing the technical opportunities on both the server- and client-side.

In this technical keynote presentation, Stephan will walk you through the RIA landscape: Companies like Sun Microsystems, Google and Adobe offer you all kinds of solutions, but how do you stitch them together? Which communication strategy should you use? How do you prepare your Java server code so it can address different multi-channel clients? These, and more RIA-related questions, will get answered during this technical keynote.

• A Groovier Way to Work with your Databases: A Quick Trip from Simple to Advanced Techniques with Alexandru Popescu,

All scripting languages, including Ruby, Python and Perl, offer nice and simple, but non-standard, access to relational databases. On the other side, Java provides the JDBC API as a standard for accessing RDBMS. Unfortunately, it is neither nice nor simple.

Groovy addresses relational database access in its core (plus some modules) and is bringing JDBC to the level of user-friendliness and simplicity that makes it better than what you can usually find in other scripting languages.

In this session, you will learn:

• How to simplify relational database access;

• How Groovy makes working with JDBC and SQL nice and simple again;

• Advanced techniques like database versioning and migrations.

• Ajax Gone Wild: Making Sense of Server-side Ajax Frameworks with Ric Smith, Open Ajax Alliance representative

In May 2007, Ajaxian.com counted over 210 Ajax frameworks - 130+ of which are server-side frameworks. That is a lot of frameworks to evaluate! Has our exuberance about the potential of Ajax inundated the market with too many options?

In this session, we will compare and contrast some the server-side frameworks that are currently available.

In this session, you will learn:

• How to choose the right framework for your next project;

• A big picture perspective of the Ajax market.

• Asynchronous Messaging using XMLBeans and JMS with Werner Keil, Principal Architect, T-Mobile

In this session, Werner demonstrates how to use XMLBeans and Java Messaging Service (based on BEA or other servers like ActiveMQ) to exchange messages between different Portal or Enterprise environments and Operating Systems in a distributed, heterogeneous web application landscape. Messages are used to maintain and update a customer facing extranet portal from an Intranet web application including security management such as user accounts and roles. Data is persisted using Entity Beans or a JPA compliant DAO (including EJB 3.1).

Some of these technologies will be part of Java EE 6, so everybody who intends to use Enterprise Java or Portal technologies in the next couple of years should know about those today.  

In this session, you will learn:

• How to integrate 2 or more different systems via standard technologies like JMS and XML;

• Portal know-how;

• Java EE 6 changes, especially Security Standards (like JSR-196);

• Principles of XMLBeans;

• Alternatives for Persistence and Presentations like WebBeans.

Recommended general knowledge: Basic understanding of JMSl, and Entity and Message Driven EJBs.

• Better Enterprise Software with the Spring Portfolio! with Eberhard Wolff, Co-author, Server Component Patterns

The Spring Framework is the most popular platform for developing Java applications and has become a de facto standard, especially for enterprise and mission-critical applications. This talk will show how the Spring Framework has evolved into a Platform and demonstrate how to make the best use of it.

As Spring and the Spring Portfolio will be used for a lot of projects in the future, it is essential to get an understanding of this today. This talk provides an example and gives a very direct and practical introduction to this field.           

Using a concrete project as an example, this talk shows how the technologies from the Spring Portfolio can be used to solve common problems in the development of enterprise applications. This includes Batch Processing, Web Services and Enterprise Application Integration.

In this session, you will learn:

• When to use which parts of the Spring Portfolio in the projects at hand;

• The main concepts of the technologies, to allow an easy adoption of them;

• The direction Spring and the Spring Portfolio are taking;

• Typical challenges in developing enterprise software;

• How to address enterprise software development challenges, including batch processing, Web services and Enterprise Application Integration.

• Beyond a DataGrid with Shay Banon, Founder, Compass open source project

In this session, we will discuss DataGrid usage and integration patterns that go beyond the typical Cache#put and Cache#get. Attendees will share their own experiences and we will discuss:

• How DataGrid can be used with ESB to provide a reliable and fault tolerant SEDA implementation (based on Mule);

• How a DataGrid can be used to execute dynamic jobs ala MapReduce using scripting languages;

• How a DataGrid can be used to scale Lucene index storage, as well as use Compass to index the DataGrid.

• Boldly Go Where the Java Language Has Never Gone Before with Geert Bevin, Sun Java Champion; Creator, RIFE Application Framework

Developers don't have to learn a new language to touch other application domains. A new development trend focuses on achieving functionalities not provided by the JVM with the standard Java programming language. 

We're only just experiencing the advent of new creative uses for the Java programming language. Judging from the wide range of new areas that have already opened up, the future holds a lot of promise for this approach. This presentation will highlight several radically different approaches that all use the Java programming language as their foundation.

In this session, you will learn how:

• Terracotta brings clustering to any Java application by distributing the characteristics of the Java Memory Model;

• Google Web Toolkit allows you to write and debug Ajax Web 2.0 applications in Java that still execute as DHTML and JavaScript on the client-side; 

• Google Android converts Java byte code to an instruction set that is optimized for mobile phones;

• RIFE turns method calls into continuations so that stateful Web applications and event based systems are safer and easier to create. 

Each of these technologies will be introduced with characteristic examples. We will step through demos to show the benefits of each approach. You will see how your current knowledge of the Java language allows you to enter new application domains with a minimal of effort.

• Building Enterprise Applications Using Glassfish with Antonio Goncalves, JCP Group Member, Java EE 6, EJB 3.1 and JPA 2.0

Depending on your requirements, Web and enterprise applications are sized differently and need different resources. Their commonality is that they run within an application server which must adapt to their needs: little or advanced administration, one instance or a cluster, run for few hours embedded in an IDE or 24/7 under heavy load. GlassFish V2 is a rich and powerful Java EE 5 application server that responds to these needs.

In this session, you will learn how to deploy Web and enterprise applications in different configurations and administer them through the UI console or command line. GlassFish also has tools to help you test your components and analyze a call flow.

Antonio will also show you some features of the upcoming GlassFish V3.

In this session, you will learn to:

• Understand the main features of GlassFish V;

• Install, configure and administer the server;

• Deploy, tune and test different application components;

• Deploy GlassFish as a cluster and monitor it;

• Discover some cool features of GlassFish V3.

• Case Study: Performance Tuning a Web Shop with Open Source Tools with Jeroen Borgers, Instructor, Java performance tuning

Today, people are ordering more and more books, TVs, jeans, sofas, etc. online. Web shops have increasing revenues, but also increasing competition. To survive, they must provide a good user experience because, with just one click, users can order from a competitor. Not having to wait is crucial for user experience.

This session will cover a case study of performance tuning the largest web shop of The Netherlands by using open source Java tools. Jeroen will share how they achieved their biggest performance gains by using these tools. You’ll also hear best practices and lessons learned from these experiences.

In this session, you will learn how to:

• Use Apache JMeter to performance test continuously in order to prevent problems;

• Monitor in production with JAMon to react to incidents quickly;

• Report with JARep to see Top 10 time consumers and discover trends.

• Choosing a Synchronization Model for Multithreaded Applications with Mike Aizatsky, Software Engineer, Google

When writing multithreaded applications, developers soon realize that synchronization APIs and memory model knowledge is not enough - There are just too many possibilities to organize data access from numerous threads, and a comprehensive plan is needed.

In this session, you’ll be given an overview of common practices to organize data access in complex, multithreaded applications. Topics covered include single/multiple/coarse mutexes, separating read/write access, introducing software transactions and many more. We’ll take a look at practical considerations, performance, productivity gains/losses and deadlock protection of each way.

In this session, you will learn:

• How to better organize data access in complex, multi-threaded applications;

• The ins and outs of different approaches to data access, including single/multiple/coarse mutexes, separating read/write access and introducing software transactions;

• The implications of these approaches on performance and productivity.

• Combining JSF, Spring and JPA with MyFaces Orchestra with Martin Marinschek, JSF Expert Group Member

More and more applications are switching over to using long sessions instead of the open-session-in-view paradigm. This makes application development a lot easier.

In this session, you will learn how to optimally combine JavaServer Faces, Spring and the JPA standard for persistence. We will discuss why a long session instead of the open-session-in-view paradigm is of advantage in many situations, and how you can achieve this easily with Orchestra. The conversation scopes of Orchestra will also be introduced. Furthermore, we will discuss the ViewController-architecture of Orchestra and how this can be applied to JSF projects.

In this session, you will learn:

• How to build low-overhead Web-applications with JSF and the JPA;

• How to apply Long Sessions and conversations to Web applications;

• How to use Orchestra to develop a long session, instead of the open-session-in view paradigm.

• Comparing Dependency Injection Frameworks with Erik Hellman, Java consultant

Many Java developers have used a Dependency Injection framework - or at least heard about Spring or JBoss Seam. Every now and then a new framework appears, claiming to do Dependency Injection in a better way. Today you can choose between Spring, Java EE5/EJB 3, JBoss Seam or Google Guice, to name a few. This session will explain what Dependency Injection really is, why we should use it, how the frameworks work and when to use each specific framework.

This session will include live coding to demonstrate the work required for each framework.

In this session, you will learn:

• What Dependency Injection can add to your applications;

• How various frameworks, including Spring, Java EE5/EJB 3, JBoss Seam and Google Guice, work;

• Tips on when to use each specific framework.

• Concurrency & High Performance with Kirk Pepperdine, CTO, JavaPerformanceTuning.com, Sun Java Champion and co-author, ANT Developer's Handbook

Both Intel and Microsoft have recently said that we, as developers, need to start delivering more concurrency in our applications. What does this mean? How did we get to this point?

In this talk, we will look at the trend towards more and more cores and and what this means for Java programmers. Can we expect that our Java applications will automatically take advantage of the extra processors, or will we need to become more aware of the hardware aspects of our system?

In this session, you will learn:

• What's behind the trend towards concurrency;

• What developers must be prepared for with concurrency moving forward;

• What concurrency looked like in earlier JDKs, and how it's evolved today;

• How you can tell if you have a performance bottleneck because of concurrency.

• Distributed Computing and MapReduce: Technology Selection, Implementation and Deployment Made Easy with Eugene Ciurana, Director of Systems Infrastructure, LeapFrog Enterprises

MapReduce is a distributed computing technology that processes large jobs across many systems running on cheap commodity hardware.  MapReduce breaks the job into discrete sub-tasks that are refined to arrive at intermediate results, which in turn are progressively mapped or reduced to arrive at an optimal result. Described by Google in 2004, MapReduce is being applied for solving massive data set indexing and processing problems that would otherwise take much longer to process if resolved through traditional methods, or that would otherwise be prohibitively expensive. This presentation is an overview of MapReduce concepts and how to implement it by either leveraging existing technology like SOA/ROC infrastructure and skill sets, by introducing a distributed computing system like Hadoop, Dioscuri, GridGain or GigaSpaces, or by combining both approaches.

MapReduce techniques help organizations implement inexpensive distributed computing systems and makes it easy to manage development because it separates job coordination/synchronization/dispatching from the business logic implementation. MapReduce also empowers problem domain experts with no concurrent processing experience to successfully develop business logic that will run on the grid. These systems may be built on top of the existing enterprise infrastructure and reuse foundational components like ESBs, or on top of dedicated grid computing platforms.

In this session, you will learn:

• How to determine if a job is well-suited for distributed processing through MapReduce;

• How to select the optimal MapReduce software infrastructure for the distributed system;

• How MapReduce indexing systems integrate well with SOA and ROA deployments;

• How to choose the best approach between developing a homegrown system, or introducing a third-party MapReduce system like the open-source Dioscuri and Hadoop, or a commercial framework like GigaSpaces or GridGain;

• A deployment strategy for such a system;

• How to deal with disaster recovery and node malfunction issues in production systems;

• The criteria for evaluating MapReduce vs. traditional data mining technology, development cost, and implementation time;

• From real world case studies of MapReduce techniques that were applied to resolve educational data mining problems;

• How to combine functional programming tools like the Scala language with a Java-based MapReduce system.

Recommended general knowledge:

• Event-driven distributed programming basics;

• Intermediate concurrent programming skills;

• Familiarity with the Java concurrency packages;

• Enterprise integration patterns and SOA;

• Basic server administration and optimization.

• Enterprise Comet: Building a Richer, More Interactive Web Application with Ric Smith, Open Ajax Alliance representative

Get acquainted with Ajax's second coming. Comet is a revolutionary development technique that rids the Web of the traditional request-response paradigm by eliminating the traditional "pull" for updates. With this new client-server communication technique, the tried and true "click" will no longer drive content delivery in your applications - Instead content will be both server- and user-initiated, enabling an event-driven model for development that opens the doors to delivery of real-time applications over the Web without the need for third-party plug-ins.

In this session, Ric will dispel many of the mysteries behind Comet, and introduce you to the core concepts necessary to understand this revolutionary development technique.

In this session, you will learn:

• The basics behind client-side techniques;

• Key concepts necessary to scale real-time Web applications.

• Extreme Transaction Processing, Low Latency and Performance with John Davies, Technical Director and Head of Research, IONA

Like C++, CORBA, Java and Spring before them, the technologies that banks are using today will become common place across industries in years to come. In this session, John, who has over 30 years of experience in investment banking and integration technology, will give you a head-start on the rest of the world.

Investment banking, online gambling, credit card payment processing and telecommunication companies all push the limits of what electrons can do for us. Can today’s generic ESBs and products aimed at a SOA really cover the extreme needs of many of leading edge industries? In this session, John will cover several case studies of XTP, low latency and high performance systems and offer insight into what we might expect to see in main-stream in the near future. 

In this session, you will learn:

• How to choose or evaluate an ESB;

• How to service-enable complex systems;

• How to cut through buzzword-heavy marketing and get down to solving real development problems;

• When to do XML and when not to;

• When Java works, what it’s best for and when it’s not so good;

• That there IS a life after relational databases.

• Groovy & Grails: Changing the Landscape of Java EE Patterns with Graeme Rocher, Project Lead, Grails; CTO, G2One

Throughout the history of enterprise software, the industry has striven to write code at increasingly higher levels of abstraction. Groovy, a dynamic language for the Java Virtual Machine, contains at its core support for metaprogramming, which brings declarative programming to the imperative world of the Java platform. Through metaprogramming techniques, you can construct intuitive Domain Specific Languages (DSLs) that express complex business rules in an easy-to-interpret manner. Groovy represents the next level of abstraction for developers on the Java platform, thanks to its support for metaprogramming.

Grails is a Web application stack that leverages the power of metaprogramming to the full and - by building on top of Java EE, Spring and Hibernate - provides an environment that is changing the way we see patterns on the Java EE platform. Gone are the days of the business delegate, the data access object (DAO) and the service locator. Even recent patterns such as dependency injection (also known as Inversion of Control (IoC) become less of an issue, thanks to the power of Groovy and Grails.

In this session, Grails project lead Graeme Rocher gives a tour of the prominent patterns on the Java EE platform and presents a Groovy solution to problems. In the process, he demonstrates metaprogramming techniques that show how you can enhance your application by dynamically registering new methods that hook into enterprise services at runtime, for more elegant, maintainable code.

In this session, you will learn:

• How to utilize metaprogramming techniques with Groovy to achieve higher level abstractions and DSLs;

• Details on Groovy’s Meta Object Protocol, which eliminates much of the need for aspect-oriented (AOP) frameworks that intercept cross-cutting concerns;

• Metaprogramming basics and patterns;

• Different ways to look at prominent Java EE patterns.

• Groovy in the Enterprise: Case Studies with Guillaume Laforge, Groovy Project Manager

Clearly, this past year, dynamic languages have come back under the spotlight. Groovy is leading this trend on the Java platform. This session will provide insight on how attendees can benefit from Groovy today.

In this session, attendees will hear success stories of companies who have integrated Groovy in their applications to make their projects more dynamic, able to cope with ever-changing requirements, and more customizable. Attendees will gain a better understanding of when, where and how to use Groovy in their projects and how it can be integrated.  You will hear how Groovy has allowed these companies to gain a competitive advantage.

Decision makers, architects, project leads and developers interested in integrating Groovy in their projects will benefit from this session by better understanding when, where and how to use Groovy in their projects, how it can be integrated, and how Groovy allowed them to gain a competitive advantage by making their projects more modular, able to cope with requirements changes and to be customizable at will.  Attendees will learn about the various use cases for Groovy, and how they can integrate Groovy in their projects.

In this session, you will learn:

• Groovy usage scenarios;

• How to integrate Groovy in a Java project;

• How to apply lessons from real-world success stories to your own projects;

• To understand the maturity, the importance, and usefulness of Groovy in an enterprise environment.

• How to Choose Your Java Web Framework with Shashank Tiwari, Chief Technologist, Saven Technologies

With RIA adoption increasing and the Web interaction model evolving, the Java Web frameworks are being directly impacted - and it’s becoming complicated to choose the correct framework today.

In this session, we will indulge in an interesting but controversial discussion of how to choose the appropriate Java Web framework. There is too much to choose from and each framework proposes a new and unique proposition that leaves developers and architects confused and perplexed. The session will be initiated around a bunch of questions and the discussion will be facilitated with the help of viable answers to these leading questions.

In this session, you will learn:

• To evaluate and choose appropriate Web frameworks for your next Web application;

• How to cut through the hype and understand what the features of a Web framework are;

• How to estimate the potential downsides of adopting a particular framework;

• Whether to choose one framework for the entire stack or cherry pick;

• Whether to keep changing frameworks as the landscape evolves or keep using one for a long time.

• Integrating JPA and Hibernate with Rich Internet Applications with Shashank Tiwari, Chief Technologist, Saven Technologies

In this session, a case study of JPA and Hibernate integration with Rich Internet Applications (RIA) will be explained and described in detail. The underlying mechanics of the approach and the issues and benefits around such an implementation will be brought forward. Attendees will leave this session with real lessons that teach them how to integrate JPA and Hibernate with RIA.

In this session, you will learn:

• The benefits and challenges in integrating JPA/Hibernate with Rich Internet Applications (RIA);

• How real world RIAs may utilize the persistence architectures;

• Lazy loading in RIA scenarios;

• How integrating JPA/Hibernate and RIA may be beneficial over traditional request response web frameworks

Recommended general knowledge:

• Java Persistence API or Hibernate;

• Concepts of remoting and messaging in rich Internet applications.

• Introduction to Spring Dynamic Modules with Costin Leau, Senior Software Engineer, Spring Source

Maintaining and evolving deployed applications is a hard task, as the Java platform provides no support for versioning or dynamic updates. In most cases, fixing a bug (no matter how small) requires a system shutdown while running multiple versions of the same applications inside the same VM is no-go. This session will show developers how to address these problems and simplify the impacts on deployment procedures as software evolves.

The session will focus on modularizing Java applications by using an OSGi platform which, used today, can simplify tomorrow’s application deployments. What exactly is OSGi and how can you use it? What’s all the fuss about it? What are the benefits and where does the Spring framework fit it? This session will provide a quick, practical introduction to the OSGi platform, review how it is currently used in the industry, and provide guidance on how Spring Dynamic Modules can be leveraged in today's projects.

In this session, you will learn:

• How to simplify your application lifecycle management;

• What the OSGi specification is all about;

• How Java applications can be modularized;

• How to use OSGi right now, inside your application;

• How to minimize upgrade impacts.

Recommended general knowledge:

• Inversion of Control containers.

• Java Performance Tooling with Holly Cummins, Tool Developer, IBM Java Technology Centre

No one writing Java applications should be without an understanding of how to fix things when they go wrong.  Diagnosing performance problems can be difficult; sometimes even knowing where to start is hard. In this session, Holly will introduce a number of tools for identifying and fixing common Java performance problems.

These tools can demystify the JVM - shedding light on why it pauses, slows down or just stops responding. For example, the GC and Memory Visualizer can be used to size the heap, detect memory leaks (even in native memory), and optimize garbage collection. The Lock Analyzer can highlight poorly written concurrency. Sophisticated dump triggering and method-level tracing can give deep insight into application behavior. All of these tools enable powerful understanding of a system and the interaction between applications and the JVM. Almost all of the tools discussed are new releases within the past year and incorporate significant new technology.

Wise developers will use them to preempt problems before they happen as well as identify root causes once performance problems strike.

• JRuby on Rails: Web Development Evolved with Ola Bini, JRuby core developer

Rails has already changed the way most Web development is done - The combination of JRuby and Rails allows developers access to rapid development while retaining the benefits of the Java platform, making applications easier to get started with, quicker to get off the ground and easier to maintain. From the first day you will have a complete run-able application, with tests, development server and fancy Ajax functionality.

Rails utilizes code generators to create configuration, skeletons and tests to create a full MVC project from the start. And the generated code is really just a tenth of the size of your Spring MVC project. JRuby on Rails handles everything from the smallest application to the largest enterprise system - You get agility and a framework that lets you change everything up until the last minute. Going from nothing to a fully featured website that can handle fifty thousand visitors is not only doable with Rails, but common. And best of all, this is accomplished with Ruby, one of the most powerful languages available.

Rails has been available on the Java platform for a year now - this presentation will show you how to use it to take your Web development to the next level. Create your application from scratch, and get best practices for handling enormous loads.

In this session, you will learn:

• How the next generation of Web development looks;

• What makes JRuby on Rails different from Ruby on Rails;

• How to deploy JRuby on Rails applications;

• How to use JDBC with Rails.

• JSF in Large-Scale Projects with Martin Marinschek, JSF Expert Group Member

In this session, we will discuss how JavaServer Faces can be used effectively in large-scale projects in corporate environments. We will cover a lot of ground: First, we will discuss how session-handling should be optimized to ensure that the lowest possible amount of memory is used. Then, we will discuss how global exception handling can be implemented in JSF. We will talk further about modularization, and how effective modules (in contrast to components) can be built with JSF. Finally, we will discuss how to integrate JSF applications in a portal environment.

In this session, you will learn:

• How to integrate JSF in a corporate environment;

• How to optimize session-handling to use the lowest amount of memory possible;

• How to implement global exception handling in JSF;

• How to build effective modules with JSF;

• How to integrate a JSF application in a portal environment. 

• JVM Clustering in the Real World with Geert Bevin, Sun Java Champion; Creator, RIFE Application Framework

Terracotta provides open source clustering for Java with Network Attached Memory. Instead of having to design and code against a specific API, the characteristics of the Java Memory Model (wait, lock, notify) are automatically translated towards a multiple node architecture. This clustering solution guarantees proper handling of concurrency, fail-over, distributed method invocation and efficient state propagation by simply instrumenting your Java bytecode and providing you with Network Attached Memory. However, sometimes this is so generic that it's difficult to realize which use-cases can benefit from it.

This presentation introduces the basic principles of Terracotta and explains how to configure and integrate it into your application. We'll go through a collection of real-world examples that all benefit from JVM-level clustering so that you can get a feel for the possibilities. 

In this session, you will learn:

• How Terracotta provides open source clustering for Java with Network Attached Memory;

• How to use Terracotta's open source clustering solution to properly handle concurrency, fail-over, distributed method invocation and efficient state propagation;

• Real-world examples of JVM-level clustering benefits, including: serialization-less HTTP session clustering, fine-grained distributed caches, workload distribution through master-worker, shared state and events between server and desktop tiers, clustered Spring and other OSS frameworks.

• Kickstarting JCR: TheServerSide.com as a Content Application with David Nuescheler, CTO, Day Software AG

Both Content Repository applications and Web 2.0 applications are emerging very quickly. This session will offer a unique opportunity to understand how to address the needs of dealing with more complex back end requirements on the content repository side and the growing demand for highly interactive web applications in a simple and straighforward manner.

This session gives a brief introduction to JCR (Content Repository API for Java Technology) and shows how applications can be developed in a very agile fashion and can leverage the rapid prototyping aspects and flexibility of Web 2.0 and at the same time operate completely in a secure and reliable environment that is provided by a standardized content repository.

During the course of this session, with only Ajax technologies and a bare Content Repository as the tools, we will turn the existing TheServerSide.com website into a  Content Repository-based application.  The TSS example application will show how both the actual TSS website and the content editing process work. This highly interactive Web 2.0 application will be developed in a very quick and efficient manner and at the same time will benefit from the content repository features like Versioning, Access Control, Fulltext Search Indexing etc.

This session also explains how every application is a “Content Application” and how you can accellerate your development cycles by leveraging the facilities that a content repository exposes.

In this session, you will learn:

• How to get started with your first standardized content repository application;

• Why Content Repositories are the better choice for your applications;

• Efficient ways to build agile content based web applications.

• Micro Design Patterns with Mike Aizatsky, Software Engineer, Google

Design patterns are standard solutions to common software design problems. Since the original Gang of Four book on Design Patterns was released in 1995, design patterns have been well understood, but still a hot topic. To understand the essence of good software design, researchers, architects and designers discovered a concept of "Micro Design Patterns." Micro patterns are similar to design patterns, except that micro patterns stand at a lower level of abstraction - closer to the implementation. 

This session will present a whole set of non-trivial Java class-level idioms, which are already widely used in many large successful projects.

In this session, you will learn how to use Micro Design Patterns to:

• Ease documentation, conveying a knowledge base and setting a vocabulary for communication among and between coders and designers;

• Make the design and implementation stages of your projects more efficient.

• Monitoring, Management and Troubleshooting in the Java SE 6 Platform with Jean-François Denise, Lead Engineer, JSR 262

The aim of this session is to describe the out-of-the-box monitoring and management features of the Java SE 6 Platform as well as the set of troubleshooting and diagnostic utilities in JDK 6.  The Java SE Platform defines a set of monitoring and management APIs in the form of JMX MXBeans that can be accessed through the JMX-based out-of-the-box management agent by remote JMX clients.

The serviceability tools in the JDK allow you to provide information on performance and resource consumption of applications running on the HotSpot JVM, print thread dumps, detect deadlocks, print heap summaries, and generate and analyze heap dumps.

VisualVM is a visual tool that integrates several existing monitoring and management JDK tools and technologies (based on jvmstat, Attach API, JMX) together with lightweight memory and CPU profiling capabilities. This tool is designed for both production and development time use and further enhances the capability of local and remote monitoring, management and performance analysis for the Java Platform. VisualVM's API allows developers to easily create their custom tools for solving monitoring, management and performance problems and share them with the entire Java community through the VisualVM's plugins center.

In this session, you will get details on:

• JDK 6 monitoring and troubleshooting tools;

• Monitoring and management architecture of the Java SE 6 Platform;

• How to add management capabilities to their Java applications;

• VisualVM tool, including an introduction to the VisualVM plugin API.

• Patterns in Mule with Antoine Borg, Contributor, Mule open source project

Mule is a light-weight ESB and integration framework. In this session, we look at Mule’s implementation of some common enterprise integration patterns and will see how Mule lets us combine these patterns intelligently to create super patterns.

Pattern analysis is one of the key skills in architecting intelligent enterprise solutions in the modern world. The ability to leverage a tool to implement those patterns successfully using simple patterns as building blocks is crucial to a successful solution.

In this session, you will learn:

• How to combine integration patterns to make business patterns with Mule;

• Which patterns are available in Mule;

• How Mule provides you with a platform to develop business patterns.

• Portlets 2.0: Next Generation Portlet Applications with Steve Millidge, JSR 286 Expert Group Member

JSR 168 defined the API for first generation portlets that could be surfaced into any vendor portal. Unfortunately, portlets built based on JSR 168 are islands of functionality unable to communicate with their neighbors or collaborate to produce rich portal experiences. The latest Portlet 2.0 specification (JSR 286) enables 2nd generation portlets to bridge the communication gap and allows rich inter-portlet communication and collaboration to occur, paving the way for portlets to become the ultimate standards-based mashable application type.

In this session you will learn:

• How you can use portlets to create next generation internet applications;

• What communication problems JSR 286 set out to solve;

• New features of JSR 286;

• How to use JSR 286 to build portlets that can collaborate.

• Real GWT Applications with Jeff Dwyer, Author, Pro Web 2.0 Application Development with GWT

Google Web Toolkit (GWT) is one of the most interesting Ajax technologies available today, with the full backing of Google and one of the most active developer lists out there. GWT 1.5 supports full Java 1.5 capability, allowing developers to quickly write Swing-style applications in their favorite IDE and then compile the code into browser-compatible JavaScript.

In this session, Jeff offers a case study of ToCollege.net, an open source application that offers a glimpse inside a modern Web 2.0 startup's codebase.  He'll begin by explaining the basic GWT value proposition and move quickly into some of the advanced capabilities that the GWT compiler offers. The project demonstrates how to merge the modern Java stack, including: Hibernate, Spring, Spring MVC, Sitemesh and Freemarker.

In this session, you will learn:

• How to write Ajax code that can be quickly refactored and doesn't require mountains of difficult-to-maintain JavaScript;

• Practical GWT/Ajax lessons from a fully functioning application - so you don't spend days trying to understand classpaths and proper directory structures;

• How GWT address the problem of Ajax development scalability;

• How Hibernate and GWT can work together for a single domain model on the server and client;

• How to use GWT to reduce HTTP requests to the bare minimum;

• How to avoid negative SEO implications, by making your Ajax code transparent;

• To understand, prepare for, and avoid XSRF and XSS attacks.

• REST and SOAP: Arch Enemies or BFF? with Ted Neward, Author, Effective Enterprise Java and more

After years of talking about Web Services, developers are still confused about how to go about using them. In part, this is because there is a substantial amount of dogma from the different camps. This session will skip over the politics and focus on the technical merits and limitations of each approach and provide a larger context for their use in an enterprise.

In this session, Ted will present a spin-free discussion about REST and SOAP: What they offer, how they differ and why you might want to use one or the other. The SOAP vendors often overstate the value of WSDL and the interoperability potential of the WS-* stack. The REST-afarians often overstate the simplicity of their approach, or fail to realize that it requires more than URLs. This session will highlight the value propositions of each approach and how they can work together.

In addition to a frank, technical discussion of the particulars of REST and SOAP, Ted will provide concrete strategic guidance for deploying services in an organization.

In this session, you will:

• Dive into the granularity of services in an SOA;

• Explore the benefits of addressability for services;

• Participate in a larger discussion of resource-oriented computing;

• Delve into security issues, including data access control;

• Learn about support for transactions across services;

• Discuss the impact of regulatory compliance on SOAs.

• Simplifying Java EE Development with Grails with Graeme Rocher, Project Lead, Grails; CTO, G2One

The past year has seen a new generation of Web frameworks emerging from the Java community, and Grails been one of the frameworks at the forefront of this movement. Based on the dynamic language Groovy and leveraging popular open source libraries like Spring and Hibernate, Grails offers the ease-of-use that developers using Java technology have been crying out for whilst at the same time embracing the software stacks already familiar to these developers.

Grails is not just a Web framework, but rather a complete software stack including and advanced build system; an integrated object-relational mapping (ORM) layer built on Hibernate; and advanced Domain Specific Languages (DSLs) for performing common tasks such as validation, URL rewriting, and querying. In addition, Grails provides and extensible plug-in system and a rich array of plug-ins that further extend its capabilities.

In this session Graeme Rocher, Grails Project Lead, will take you through a guided tour of the framework and its features.

In this session, you will learn:

• How Grails dramatically simplifies the use of persistence via Hibernate through metaprogramming techniques;

• How, through the use of convention, Grails obviates the need for verbose Spring configuration;

• How Groovy can significantly reduce the verbosity of your Java technology-based code;

• The Grails project infrastructure;

• How to simplify ORM with Grails;

• How Grails can help you develop RESTful Web services and Ajax applications more easily and quickly.

• SOA Using Service Component Architecture with Mike Keith, Co-spec lead, EJB 3.0 and JPA 1.0

Open SOA (OSOA) is collaboration between industry leaders to create a suite of specifications delivering architecture for development, assembly and composition of SOA applications. This model is called the Service Component Architecture (SCA) and it is driving next generation technologies and SOA application platforms.

The primary building block of SCA is called simply the service component. Components may be wired together, spanning heterogeneous technologies and implementations, to form a composite application domain that can be executed by one or more distributed runtimes. By abstracting out the services and references to services, a component type can be instantiated to facilitate plug ability with specific service implementations, be they newly created composites or existing legacy components.

In this session, you will learn:

• Where SCA came from and where it is going;

• What the main ingredients of SCA are;

• How SCA can be used to develop SOA applications;

• Where SCA fits with Java, Java EE and Java standards.

Recommended general knowledge:

• Basic familiarity of SOA and distributed components;

• General service-oriented computing concepts.

• Son of SOA: Event-Driven Architecture and the Real World with Eugene Ciurana, Director of Systems Infrastructure, LeapFrog Enterprises

Application development and deployment using SOA faces problems when organizational changes occur if the participating systems (service providers and consumers) are too tightly coupled. In SOA, messages and systems are inherently synchronous, promoting dependencies that filter to the organizational level. 

Resource-Oriented Computing solves system and application integration issues by leveraging ESB, domain-specific languages, and shared memory mechanisms for integrating coupling points, not the applications themselves, by promoting event-driven interactions between system components, and by creating logical mappings of resources such as data or computations that are abstracted from the physical manifestation of the system deployment.

In this session, you will learn:

• How resource-oriented computing systems process resource representations and execute transformations and computations by defining processing in terms of compositions and asynchronous sequences of resource requests;

• How to develop complex applications within very tight deadlines by formalizing system integration around a resource-oriented model;

• How to turn SOA-based systems into callbacks, breaking the rigid provider/consumer model;

• How to develop event-driven applications based on technologies and services already in production using a multi-language approach;

• How to integrate the existing applications by applying event-driven rather than centralized control techniques;

• How to extend SOA beyond transactions to include workflow processes and lossless transformations of resources from one representation to another;

• Real world applications that use Mule ESB, OpenSpaces, Terracotta and OSGi;

• Examples of architecture, service objects, configuration files;

• Approaches to solving distributed data caching.

Recommended general knowledge:

• Enterprise service bus;

• Distributed data caching technologies;

• Enterprise integration patterns and SOA;

• Domain-specific language basics.

• Spring 2.5 On the Way to 3.0 with Juergen Hoeller, Co-founder, Spring Framework

Annotation-based configuration is a hot topic in 2008. With EJB 3.0 and Spring 2.5 already available and JSF 2.0 and Web Beans on the horizon, the wealth of annotation-based configuration options requires awareness of how those are related and how they compare with traditional configuration approaches.

The Spring Framework 2.5 introduced comprehensive support for annotation-based configuration, along with full support for the Java 6 and Java EE 5 platforms. Now Spring is preparing for the Spring 3.0 release, introducing further annotation-based configuration options and unified expression language support. This talk discusses Spring as a modern Java 5 oriented application framework – covering the core component model, integration with common technologies such as JPA and JSF, as well as Spring’s annotation-driven web MVC.

In this session, you will learn:

• How to design components in a Java 5-based enterprise application, using dependency injection and AOP with the help of source-level annotations;

• How to get the most out of Spring 2.5’s new annotation-based configuration options;

• How Spring 2.5’s feature set compares with other annotation-based component models;

• What to expect from Spring 3.0.

Recommended general knowledge:

  • Spring 2.0 fundamentals

• Stock Trading – Using JSR-275 and Spring for a Monetary System with Werner Keil, Principal Architect, T-Mobile

JSR-275 specifies Java packages for modeling and working with standard measures known as units.  In this session, spec lead Werner Keil demonstrates how to use JSR-275, Web Tier and Services based on Spring for a simple, real world compatible Stock Market Trading System. Some of these technologies will be part of Java 7, so everybody who intends to use Java for a financial enterprise application or system involving money should know about those today.

In this session, you will learn:

• How to enable a dynamic Web application for 2 or more dynamic trading systems (Stock and Currency Exchange);

• How to use Web services in financial markets;

• How to use Yahoo! Financial; 

• Details on potential changes in Java 7.

• Testing with JRuby with Ola Bini, JRuby core developer

Testing is getting more and more attention - But the Java language sometimes gets in the way of writing the tests you actually want to write, or writing them quickly enough. The larger the application, the more important it is to test it correctly. Getting more tests per line of code is one way of scaling testing to the levels needed to develop today. By using Ruby for testing, you can get more tests written more easily while not having to convert your whole application to Ruby.

This session will describe how you can leverage JRuby and state-of-the-art Ruby testing tools to increase your test coverage, write more tests, more easily and also how to manage your integration testing at a different level.

In this session, you will learn:

• How polyglot programming can improve any Java project;

• What RSpec and BDD are;

• How to use JtestR to improve testing;

• How to mock Java classes and interfaces;

• How Ruby can be used together with Java.

• The Busy Java Developer's Guide to Scala with Ted Neward, Author, Effective Enterprise Java and more

Concurrency represents a huge new problem for Java developers, as evidenced by the rising number of concurrency issues brought about by the widespread acceptance of multiple-core CPUs "in the wild." A functional language makes concurrency easier by both making it easier to write code without "side effects" (local state changes that need to be protected by atomic access mechanisms), and by offering new approaches to writing parallelizable code, in this case, using a new model known as "Actors."

In this session we will cover some of the interesting aspects of Scala, a new functional/object hybrid language from Martin Odersky (creator of Pizza, GJ and a major contributor to Java5 generics) that brings together the expressive power of functional languages (such as Haskell, ML or OCaml) with the object-oriented ecosystem on top of the Java  Virtual Machine.

With Scala, Java developers can write more expressive, more powerful code for the JVM without having to abandon the existing code already in Production, the power of the JVM, or the rich community that has grown up around the JVM.

In this session, you will learn how to extend your programming abilities to include:

• Case classes;

• Pattern-matching;

• Sequence comprehensions;

• Type-inferencing;

• Powerful concurrency-execution mechanisms.

Recommended general knowledge:

• An intermediate feel for the Java language and virtual machine.

• The Enterprise without a Database with John Davies, Technical Director and Head of Research, IONA

For decades, enterprise systems have been built around the database - the original canonical data structure that everything had to integrate to. The DBA was the most powerful person in the enterprise, even messages standards were based on the database structures and it seemed everything had to have a table associated with it.

The time has come to think about an enterprise free from the RDBMS - not free from persistence altogether, but free from the lock-in of the classic RDBMS. John will talk through some recent projects at several large financial institutions now building global trading systems without a database in sight.

In this session, you will learn:

• Where data and persistence are headed without a database;

• How to move away from the lock-in of RDBMS;

• What a database-free institution looks like.

• Typesafe Embedded Java DSLs with Jevgeni Kabanov, ZeroTurnaround Tech Lead; Co-founder, Aranea project

With projects like jMock and Hibernate, Criteria Query embedded Domain Specific Languages (DSLs) have been brought to Java. This talk introduces two projects that develop embedded DSLs for building SQL queries and engineering Java bytecode. Jevgeni will introduce and discuss some patterns based on advanced use of Java Generics and some other features that allow building fully typesafe DSLs in Java.

You’ll learn how to develop DSLs for your own domain and problems in a typesafe way utilizing full strength of the Java type system.

In this session, you will learn:

• How to encode DSL syntax in Java;

• Whether to use method chaining or method composition;

• What generic tupling is good for;

• How to encode metadata in a typesafe way;

• How to combine typesafe and type unsafe expressions;

• How to combine usual and DSL-style control flow.

Recommended general knowledge: A high Java aptitude is a must. Familiarity with SQL is important and some familiarity with Java bytecode engineering framework will help.

• What's New and Exciting in JPA 2.0 with Mike Keith, Co-spec lead, EJB 3.0 and JPA 1.0

The Java Persistence API (JPA) has taken the Java development world by storm and is now recognized as the enterprise standard for object-relational persistence. The masses have settled into using JPA as a means to persist Java objects to relational databases, but sometimes they require features that are either missing or not fully specified in the 1.0 release.

JPA 2.0 is filling in the feature gap and introducing many of the additional features that developers have asked for. We will examine where the current standard stops and where the new 2.0 release continues on. We will discuss some of the difficulties and complexities of the new features and when it may be appropriate to use them.

This session will be suitable for anyone either using JPA or planning to use it at some point in the future. People that are just curious about what JPA offers and what it will offer in the future may also find this session interesting. This will also be your chance to provide input to the 2.0 feature set.

In this session you will learn:

• What the new query expression language will look like;

• How to specify and use advanced object-relational mappings and collections;

• Sophisticated entity identifier configurations;

• Additional modeling capabilities;

• Advanced API and locking options.

Recommended general knowledge:

• Persistent Java applications;

• Relational database concepts;

• Object-relational mapping.

• What’s new in EJB 3.1 with Antonio Goncalves, JCP Group Member, Java EE 6, EJB 3.1 and JPA 2.0

When Java EE 5 came out, it created a rupture from J2EE 1.4. The EJB stack was redesigned with one aim: simplification. Now EJBs use a POJO model, optional XML configuration files and brand new persistence capabilities. Java EE 6 will be shipped with EJB 3.1, which will bring more power and simplification to the enterprise platform.

In this session, you will discover the new features of EJB 3.1 and see how EJB development has gone from heavy, to lightweight, to even “lighter” weight.

In this session, you will learn:

• How you can use simplified interfaces with Session Beans;

• How to package EJBs in a war without an ejb-jar;

• About Singleton that provides easy access to share state;

• How to use the calendar based EJB Timer;

• Asynchronous method invocation.

Expert Panels

• Languages: The Next Generation

Moderator: Eugene Ciurana, Contributing Editor, TheServerSide.com

Panelists: Ola Bini, Ted Neward and Graeme Rocher

This panel brings together experts on a wide variety of languages to discuss where language development is taking the industry.  As the different languages shape, get insight from those at the forefront into problems and solutions.

Fireside Chats

• Effective RESTful Services with Dan Diephouse, Software Architect, MuleSource

In the past few years, more and more people have been basing their services on the architecture of the Web: REST. REST is the formalized architecture of HTTP based on the concepts of resources, client-server interactions, links, caching and more. While the concepts are powerful, and often simple, it isn't always intuitively clear how to build enterprise-class services. 

In this Fireside Chat, we'll discuss fundamental concepts, reliability, security, how to model your services, and more so that you can build services in the RESTful architectural style effectively.

• The Spring Framework and Its Ecosystem with Juergen Hoeller, Costin Leau and Eberhard Wolff

This fireside chat gives attendees a chance to get in touch with leading Spring framework developers and consultants. Topics up for discussion include:

• The direction of the Spring portfolio in the 3.0 generation;

• Annotation-based configuration versus external configuration;

• OSGi as a deployment model for enterprise applications;

• Spring in the world of Java EE 6.  

Attendees are welcome to raise further topics and to share their own experiences with Spring and related frameworks.

• Zero Turnaround in Java Development with Jevgeni Kabanov, ZeroTurnaround Tech Lead; Co-founder, Aranea project

Turnaround is the time it takes for the changes in code to propagate to the running application.  It includes build time, deploy time and initialization time. Recently, developments in the Java ecosystem and IDEs have made it possible to develop software with zero turnaround. 

In this Fireside Chat, Jevgeni Kabanov will provide an overview of these developments, which include dynamic languages like Groovy, JavaScript and JRuby, framework support for reloading like Tapestry 5 and RIFE, module approach in OSGi and generic class reloading approaches like HotSwap, JavaRebel and FastSwap. 

With each approach, we’ll discuss benefits and limitations. We also review how to set up your build environment to get least possible turnaround whether you program legacy code or start from scratch.