• Next-generation web integration: Java applets interoperate well with JavaScript in all major web browsers.
• Multi threading support in the Java platform and libraries hides network latency from the end user, and increases the application's throughput.
• Native desktop integration supports concepts like drag-and-drop "on to the web".
• The Java platform's powerful and flexible security model allows true web service mashups to be created which connect simultaneously to many web services.
• The rich image handling and graphics capabilities of the Java core libraries facilitate development of advanced graphical applets and applications.

In the last two years we've seen increasing efforts by Sun Microsystems to revamp Java on the desktop - what somebody called "the Swing Renaissance". First, most of the performance issues have been solved; then we have now many more components thanks to SwingLabs and other third parties' projects; we have better Look and Feels too; last but not least, gurus such as Romain Guy have been demonstrating how to build cool and effective GUIs with Swing. It's high time to apply the learned lesson to some real product.

In this talk we will show you the blueMarine project, an opensource desktop application to support the photographic workflow. blueMarine is being designed following the best practices for the creation of a 'filthy rich client', from animations to the use of JOGL, and taking advantage of the rich framework delivered by the NetBeans Rich Client Platform.

• New Xml configuration. Xml editor and developer friendly - no more class names!
• The new extensible configuration model
• Enhancements to the Mule runtime environment
• How mule works with BPM and where BPEL fits in
• OSGi support, For dynamic component loading and hot deployment
• Data Streaming support

Ross will also discuss the Mule roadmap for 2007/2008 including new
arrivals in the Mule ecosystem and 2 Mule Customer case studies (H&R Block and Major League Baseball: mlb.com).

This JSR will aim to provide a high level easy-to use API for developers to write RESTful web services independent of the underlying technology and will allow these services to run on top of the Java EE or the Java SE platforms. The expert group will investigate whether a subset of the API can be made used with Java ME. The goal of this JSR is to provide an easy to use, declarative style of programming using annotations for developers to write REST ful Web Services and also enable low level access in cases where needed by the application.

RESTful Web Services is a relatively new area in the industry and there are still a lot of unknowns in this space. For example, a key aspect of RESTful Web Services is for the service to be stateless. However, this often requires the developer to produce boiler-plate state restoration code that could be avoided with state-aware API help. We expect the expert group to be an active and engaged group of people participating to prioritize and help drive issues to achieve the end goal of a developer friendly API.

In the past 8 years, the Java EE platform has grown and matured, and is now able to cover a wide range of enterprise and web application development needs. In addition, the Java EE platform has fostered a vibrant community and marketplace for additional technologies, frameworks, and applications that work with the platform. Some of these provide facilities that are missing from the platform. Others provide alternatives to platform facilities. A major theme for this release is to embrace and support those technologies as part of the overall Java EE landscape, while also continuing to simplify the platform to better target a wider range of developers. To that end we propose two goals for this release - extensibility and profiles.

Standards are the foundation of the modern world. It would not be
possible to mail a package or send an email message, drive a car or take an airplane trip, shop for food in a supermarket, obtain medical treatment in a hospital, watch TV or movies, enjoy a sports game, or do any of the other things that the modern world offers if it weren't for standards.

Java is built on standards, and its success is directly attributable to the community-driven process through which the language and platform are evolved. The Java Community Process (JCP) is your standards organization. It's not just for platform implementors and large corporations. The views of individual developers and the open-source community matter, and you can directly influence Java's future by joining the JCP and by participating in its activities. We'll tell you how...

But why use a copy when you can use the real deal? JRuby on Rails is a reality. It is the original Ruby on Rails framework, running on top of the Java platform. JRuby is an implementation of the Ruby language which runs all valid Ruby programs, and Rails is just one of them.

This session will take you all the way from an introduction to Ruby and Rails (and a description on how they have managed to change the world) to showing you exactly how you can go about creating your own first JRuby on Rails web application. After this session, you will know how to get started and how to proceed, and you will have gotten a taste of the future of web development that will leave you craving for more.

You will get a short introduction into master data management and the latest trends.

IDE plug-ins are available for both the NetBeans IDE and Eclipse. Both plug-ins support as-you-type validation, code completion, syntax highlighting, and hyper link navigation.

An excerpt from the speaker's blog at http://learnjavafx.typepad.com lists some of the strengths of JavaFX Script:

• Its simple, declarative syntax used to express user interfaces, including a very rich set of layout widgets that make easy work of laying out a user interface in a platform-independent way.

• Its innate ability to support the model-view-controller pattern because of its very powerful bind capability.

• The concept of triggers (functionality that is automatically invoked when certain conditions take place, such as when the value of an attribute changes). This enables the declarative syntax as well.

• JavaFX programs will run anywhere Java programs will run, because they run within the context of a Java Virtual Machine (JVM).
• Its very powerful syntax for defining, modifying, and querying sequences (think arrays).

We are now facing critical issues which until now many within the agile community have preferred to avoid talking about. Activities such as modeling, documentation, exploratory testing, and database development must become more explicit within our methodologies. We need to find ways to fit into IT governance frameworks, process maturity frameworks, and regulatory guidelines.

In this session, the speaker covers some more advanced features of JAX-WS 2.1, JAXB 2.1 and the RI, and shows you how they simplify the task of developing web services. We will take you well beyond the basic introduction of JAX-WS, and show you how problems people often face when developing web services can be addressed using JAX-WS. Handling schema and service evolution, automating corporate design guidelines, and extending protocol support beyond HTTP are just some of the things that are now possible with JAX-WS.

The focus will be on the core session bean and message-driven bean component models and their client API. Although the Java Persistence API was developed within EJB 3.0, it will evolve under a separate JSR rather than within EJB 3.1.

Aspects that should be considered by the Expert Group for inclusion in this work include, but are not limited to, the following:

• Removal of the requirement for a separate local business interface.
• Support for direct use of EJBs in the servlet container, including simplified packaging options.
• Singleton beans.
• Support for asynchronous session bean invocation.
• Support for stateful web services via stateful session bean web service endpoints.
• Specification of concurrency options for stateful session beans.
• Application-level callback notifications, including for container initialization and shutdown.
• EJB Timer Service enhancements to support cron-like scheduling, deployment-time timer creation, and stateful session bean timed objects.
• An ejb-jar level component environment to simplify the specification of shared dependencies among components.

The goal of the Expert Group will be to investigate these issues and identify and pursue directions for enhancement to the overall programming model and facilities of the Enterprise JavaBeans API.

The new API will also tackle related date and time issues. These include formatting and parsing, taking into account the ISO8601 standard and its implementations, such as XML. In addition, the areas of serialization and persistence will be considered.

The final goal of the new API is to be simple to use. The API will need to contain some powerful features, but these must not be allowed to obscure the standard use cases. Part of being easy to use includes interaction with the existing Date and Calendar classes, something that will be a key focus of the Expert Group.

Red Hat in conjunction with the open source community released JBoss ESB 4.2, a JBoss.org open source project. JBoss ESB intermediates interactions between enterprise applications, business services, business components, and middleware to integrate and enable automation of business processes.

In his presentation Johan will look at the architecture and benefits of the JBoss ESB. The main part of his talk will cover multiple demo's of some basic, as well as some more advanced features of the JBoss ESB.
Johan will conclude his session by presenting the current product roadmap. He will also explain why you should choose for JBoss ESB in future SOA projects.

Spring Web Services 1.0 provides a flexible, powerful Web services framework by facilitating best practices such as contract-first Web service development, the WS-I basic profile, and loose coupling between contract and implementation, allowing for the creation of flexible Web services using one of the many ways to manipulate XML payloads. By providing developers with a simpler approach to contract-first development, Spring-WS resolves many of the interoperability issues associated with typical Web services approaches.

The purpose of Java Persistence 2.0 is to augment the Java Persistence API to include further features requested by the community.

This session will give you an up-to-the-minute glimpse into work in progress on Java Persistence 2.0, and will provide you with an opportunity for feedback on new directions.

Aspects to be discussed include the following:

• Expanded modeling capabilities and object/relational mapping functionality, including support for collections of embedded objects, ordered lists, combinations of access types, greater flexibility in combining existing mapping options, etc.

• Expanded query capabilities and additions to the Java Persistence query language

• Standardization of additional contracts for entity detachment and merge, and persistence context management

• Standardization of sets of "hints" for entity manager and query configuration

• Expanded pluggability contracts for Java EE environments

• Support for validation

Spring Web Services 1.0 provides a flexible, powerful Web services framework by facilitating best practices such as contract-first Web service development, the WS-I basic profile, and loose coupling between contract and implementation, allowing for the creation of flexible Web services using one of the many ways to manipulate XML payloads. By providing developers with a simpler approach to contract-first development, Spring-WS resolves many of the interoperability issues associated with typical Web services approaches.

In this session, the speaker covers some more advanced features of JAX-WS 2.1, JAXB 2.1 and the RI, and shows you how they simplify the task of developing web services. We will take you well beyond the basic introduction of JAX-WS, and show you how problems people often face when developing web services can be addressed using JAX-WS. Handling schema and service evolution, automating corporate design guidelines, and extending protocol support beyond HTTP are just some of the things that are now possible with JAX-WS.

Guice embraces Java's type safe nature, especially when it comes to features introduced in Java 5 such as generics and annotations. You might think of Guice as filling in missing features for core Java. Ideally, the language itself would provide most of the same features, but until such a language comes along, we have Guice.

Guice helps you design better APIs, and the Guice API itself sets a good example. Guice is not a kitchen sink. We justify each feature with at least three use cases. When in doubt, we leave it out. We build general functionality which enables you to extend Guice rather than adding every feature to the core framework.

Guice aims to make development and debugging easier and faster, not harder and slower. In that vein, Guice steers clear of surprises and magic. You should be able to understand code with or without tools, though tools can make things even easier. When errors do occur, Guice goes the extra mile to generate helpful messages.

Spring emerged as an application framework and can be considered as de-facto standard in the area of light-weight Java EE application development. Still there is one concern people constantly bring up: The XML bean definition files can get quite complex and error-prone during development. This problem has been greatly addressed with the new Spring 2.0 XML Schema-based configuration, but still there is room for improvement regarding tooling support to make Spring development even more agile.

Spring IDE provides support features within the Eclipse platform for Spring Framework development. It gives you useful tools to validate and visualize your bean definitions as well as support while editing Spring Bean defintions with content assist and much more.

Version 2.0 of Spring IDE will provide long-awaited features such as support for Spring 2.0 namespace-based configuration files, support for Spring AOP including @AspectJ-style aspects and - due to overwhelming community feedback - tools for Spring Web Flow development. Furthermore lots of detailed improvements have been incorporated in latest releases.

This session will introduce the new features of Spring IDE 2.0 and will give you an update of Spring IDE's roadmap.

The Java Persistence API (JPA) is fast becoming the popular choice for object-relational persistence not only in Java EE environments but also in enterprise applications that make use of other technologies, such as Spring. Since the JPA standard has taken hold, the developer base has gotten more experienced with the persistence model, and the questions that arise are now more of an intermediate or advanced nature.

In this talk we will introduce a few of the common features and use them as a platform on which we can discuss some of the higher order JPA topics. As part of this discussion we will show how to use multiple persistence units, define and tune identifier generators, create and invoke native queries, and use XML mapping files for overriding annotation metadata. We will also show how JPA can be used in Java SE and Spring environments.

While attendees that have some experience using JPA will profit from this talk, even those who are interested in JPA, but who have not yet started writing applications with it, could also enjoy it. Some kind of experience with Java persistence would be beneficial, though.

Many applications within the enterprise domain require bulk processing to perform business operations in mission critical environments. These business operations include automated, complex processing of large volumes of information that is most efficiently processed without user interaction. These operations typically include time based events (e.g. month-end notices or correspondence), periodic application of complex business rules processed repetitively across very large data sets (e.g. insurance benefit determination or rate adjustments), or the integration of information that is received from internal and external systems that typically requires formatting, validating and processing in a transactional manner into the system of record.

Spring Batch is the only comprehensive lightweight batch framework designed to enable batch development for enterprise systems of varying complexity. Simple as well as complex, high-volume batch jobs can leverage this framework in a highly scalable manner.

The Spring Framework is the most popular application programming framework for Java/Java EE development, with widespread usage across many industries. Spring is an open source product, published under the Apache Software License. Spring enables POJO-based development, while making it easy for developers to access advanced enterprise services. This session focuses on how to use, configure, and extend the batch framework utilizing familiar Spring patterns such as Dependency Injection and Inversion Of Control. General batch concepts such as logging/tracing, transaction management, statistics, restart, skip, resource management and job partitioning will also be covered to demonstrate the capabilities of Spring Batch. Optimization techniques enabling the batch framework to run extremely high-volume batch jobs will also be discussed, including execution within a Java EE container. The speakers will also address the misconception that Java is not appropriate for developing high-volume batch applications.

The session is intended for architects, developers and performance testers of batch applications interested in understanding how the Spring Batch framework allows batch application developers to focus on the business aspects of batch jobs in a highly scalable enterprise environment.

Consequently, many web developers and designers find themselves faced with legacy code for the first time. Until recently most sites and pages just weren't old enough for legacy issues to be a major concern. While legacy issues and the tools and techniques for managing them are well known to programmers, web folks are just now learning about these problems. As web designers begin to grapple with the legacy issues that have hampered programmers for so long, they'll need to learn the same refactoring techniques programmers have used to manage these problems.

The Java Persistence API (JPA) is fast becoming the popular choice for object-relational persistence not only in Java EE environments but also in enterprise applications that make use of other technologies, such as Spring. Since the JPA standard has taken hold, the developer base has gotten more experienced with the persistence model, and the questions that arise are now more of an intermediate or advanced nature.

In this talk we will introduce a few of the common features and use them as a platform on which we can discuss some of the higher order JPA topics. As part of this discussion we will show how to use multiple persistence units, define and tune identifier generators, create and invoke native queries, and use XML mapping files for overriding annotation metadata. We will also show how JPA can be used in Java SE and Spring environments.

While attendees that have some experience using JPA will profit from this talk, even those who are interested in JPA, but who have not yet started writing applications with it, could also enjoy it. Some kind of experience with Java persistence would be beneficial, though.

In this session, we will talk about SOA's and Web services in a pragmatic fashion. We will talk about the proper place of a Web service within an application architecture, both from the client and the server perspective. And we will talk about the value of SOAP vs REST, and the multitude of WS-* specifications that are out there: what do they add?

After last year's presentation, we were disappointed that some attendees mistakenly used this information to avoid pitfalls, errors, and other common causes of project failure. We hope for better results this year.

• wiring application components together
• handling crosscutting concerns including transactions, audit logging, and security
• simplifying database access.
• testing

Unitils is an open source library, written by a number of colleagues from Ordina J-Technologies , aimed at making unit testing easy and maintainable. Unitils builds further on existing libraries like DBUnit and EasyMock and integrates with JUnit and TestNG. The framework includes general assertion utilities, support for database testing, for testing with mock objects and offers integration with Spring and Hibernate. It has been designed to offer these services to unit tests in a very configurable and loosely coupled way.

In this talk Joris Kuipers will review several complex scenarios they both saw in real projects and how Spring helped solve those issues. Ranging from Spring extension points to the set up of your project; this really takes Spring beyond the obvious.

• the design of a persistence layer
• the choice of persistence technology
• how to actually make layering work
• the design of the service layer
• how to do distributed applications with Spring.

In this session, we will first review the main features of Compass, focusing on Compass extensive integration with Spring. We will then see how Compass can be used to add google like search capability to Spring's petclinic sample with almost no coding involved using JPA and Annotations.

This talk focuses on six sides of agility, which notionally form the faces of a cube, and how they trade off against one another in different situations. Practices, organisation, architecture, tools, skills and attitude: each of these has different consequences and different
applicability depending on the context. For example, if a skilled team of developers wishes to adopt a more agile approach in a legacy project without tests, they are better off in the short term avoiding TDD and unit test coverage, and instead focusing on other matters of practice, tooling and architecture. By contrast, an unskilled team on a new
project are often well served by adopting a TDD approach early and forming a clear understanding of the architecture they are working in and on.

This session will provide you with an introduction on building web-based, 'fat clients' with GWT. The focus of this session will be on integration between a GWT client and your Spring-managed back end. Bram will also discuss tips and tricks for working with GWT. During this session, Bram will demonstrate how to build a simple GWT client and connect it to an existing Spring-based back end application.

In this session we will introduce a new framework - OpenSpaces that takes those different patterns and creates a simple platform on top of Spring - OpenSpaces. Openspaces simplify significantly the way we can build such applications by integrating POJO driven services with the Data and scale them out as a single unit - a processing-unit.