Parleys.com

Spring Security 2, the former Acegi Security System for Spring, is a comprehensive framework which helps you implement enterprise application security requirements, like single sign-on, authorization checks and the use of several authentication technologies.

This session presents not only the new features of Spring Security 2, but also shows some best practices and examples to get the most out of it. Covered architectures will include web (2.0) applications, web services and client/server applications.

After years of Struts/JSP being the default choice for Java web applications, Seam together with JavaServer Faces and Facelets has become an excellent alternative. Seam is an application framework for Java Enterprise Edition which introduces the notion of declarative, contextual application state management.

In the first half of this session, Pete Muir will introduce Seam, its contextual programming model and its tight integration with other frameworks such as Hibernate, jBPM and RichFaces. In the second half of this session Peter Hilton and Nicolas Leroux explain why they chose Seam over the many competing frameworks, what it was like getting started with Seam, what its learning curve is like, and what their practical experiences with Seam has been on two commercial projects during the last year.

After years of Struts/JSP being the default choice for Java web applications, Seam together with JavaServer Faces and Facelets has become an excellent alternative. Seam is an application framework for Java Enterprise Edition which introduces the notion of declarative, contextual application state management.

In the first half of this session, Pete Muir will introduce Seam, its contextual programming model and its tight integration with other frameworks such as Hibernate, jBPM and RichFaces. In the second half of this session Peter Hilton and Nicolas Leroux explain why they chose Seam over the many competing frameworks, what it was like getting started with Seam, what its learning curve is like, and what their practical experiences with Seam has been on two commercial projects during the last year.

The long-awaited second edition of Effective Java is here! It covers the latest in best practices for the Java platform. This presentation will concentrate on three areas where    new material has been added to the book: enum types, generics, and concurrency. Do you want to know how to combine the safety and richness of collections with the performance of bit fields?
Have you ever been confused by wildcard types? Do you want to know when and how to use lazy initialization? Then come to this talk. The patterns and idioms you learn will be directly applicable to your programs and designs.

Today's software landscape resembles increasingly a tower of Babel: Systems are built using many different languages, combining server-side and client-side languages, scripting and systems programming languages, general and domain specific languages, all glued together with a hefty amount of XML. The advantage of this approach is that each individual language can be tailored to a specific application domain. Its disadvantage is that the necessary amount of cross-language glue can make applications cumbersome to write, deploy, and maintain. An alternative is offered by scalable languages, which can be used for many different applications, ranging from small scripts to very large systems. An important aspect of a scalable language is that it itself is extensible and malleable. It should be possible to define very high-level libraries in it, which act in effect as specialized domain specific languages. The advantages of this approach is that it leads to more regular system designs, gives better static checking, makes applications easier to deploy, and increases their reliability. In this talk I'll describe the design principles of the Scala programming language, which has scalability as its primary design objective. Scala combines lightweight syntax with strong static checking on a Java-compatible platform. It encourages the embedding of domain-specific languages as high-level libraries. I discuss how Scala affects systems design and discuss its suitability for large scale industrial deployment.

It's clear that we are headed for continued change in enterprise Java. Business requirements are changing, with the rise of SOA and a richer web experience. Scripting languages and productivity frameworks such as Ruby on Rails are placing welcome pressure on enterprise Java to enable developers to deliver results quicker. The traditional application server seems less and less relevant in today's environment--especially as transformational technologies such as OSGi move to center stage. In this keynote, Rod Johnson will consider where tomorrow's innovation will come from in enterprise Java. How will the role of the JCP change? Will other standards bodies play a role? Will end users be more empowered--and how can you help to shape the future? How will the continued rise of open source affect the platform--especially with Sun's recent embrace of open source, and the emergence of a significant and sustainable open source industry?

Stop writing new - A Comparison of Dependency Injection Frameworks

At the heart of most successful open source projects is an emphasis on open architecture -- at least one mechanism that allows the product to be utilized as a support network for unanticipated extensions and independently motivated functionality. Such extensibility mechanisms allow an open source project to decentralize its evolution and take advantage of Internet-scale collaboration. However, they can also be a source for unnecessary complexity and hidden barriers to entry. Representational State Transfer (REST) is an architectural style that I developed to describe and redefine the World Wide Web. The essential constraints of REST are designed to promote the development of open architectures within Web-based applications, such that the resulting resources are reusable across independently developed systems (today, we call these "MashUps"). The same principles can be used to design other open architectures, though not necessarily with the same constraints. This talk will focus on applying principled design techniques to the design of open architectures, as demonstrated by various examples from successful open source projects.

The term software factory is controversial. But think about it... No industry has experienced more innovation than the factory industries. On the contrary, the key to meeting demand is to stop wasting talents of skilled developers on rote and menial tasks...

Josh Bloch and Neal Gafter present yet another installment in the continuing saga of Java Puzzlers, consisting of eight more programming puzzles for your entertainment and enlightenment.

Java programmers now have a standard solution for creating and validating XML signatures. And with the progression of JSR 106 (Java XML Encryption API) through the Java Community Process, a standard solution for XML encryption will soon be available.

Groovy is an agile and dynamic language for the Java Virtual Machine. Builds upon the strengths of Java but has additional power features inspired by languages like Python, Ruby and Smalltalk. Makes modern programming features available to Java developers with almost-zero learning curve

OW2 Members present and demonstrate leading OW2 projects working together to provide a full-featured open source information system.

The conference covers a range of complementary middleware from OW2:

• Exo WebOS as the portal
• XWiki as the extensible wiki
• Bonita as the Workflow
• JOnAS as the application server
• SpagoBI as the Business Intelligence platform
• Talend as the Data Integration platform
• PEtALS as ESB and Service infrastructure platform
• Orchestra as BPEL orchestration engine
• Spagic as enterprise monitoring platform

Google Gears is an open source browser extension that lets developers create web applications that can run offline. During this presentation Dion Almaer will explain what Google Gears is and what the future usage will be within Google and other related partners.

Enterprises are deploying SOAs to gain business flexibility and efficiency. However when it comes to ensuring superior performance this approach and the technologies that underpin it, pose special management challenges. The loose coupling of services offers clear benefits - such as better alignment between business and IT; however, the complexities of service-orientation bring hidden performance risks. SOAs are simply the next generation of composite web applications, which CA Wily has been managing for over 9 years. They do have specific management challenges, but these must be considered in the context of the whole web application infrastructure through which Web services transactions flow.

In this session we will share our experiences, ideas, observations and thoughts on the real world impact and associated challenges of composite Web applications. We will take a close look at some of the key technologies and approaches behind a Service Oriented Architecture or SOA; and then focus on the Application Performance Management challenges associated with SOA.

This talk will provide a detailed view into a new platform IBM is building that is optimized for time and simplicity. This new platform allows you to build modern web applications easily and quickly with an event-driven, scripting centric programming model and an optimized runtime. This talk will provide an overview of the project and a detailed look at the programming model, including samples and demos. We will also discuss a new form of commerical software development being used with this project. To read up before the talk, check out www.projectzero.org .

Validating data is a common task that is copied in many different layers of an application, from the presentation tier to the persistence layer. Many times the exact same validations will have to be implemented in each separate validation framework, proving time consuming and error-prone. To prevent having to re-implement these validations at each layer, many developers will bundle validations directly into their classes, cluttering them with copied validation code that is, in fact, meta-data about the class itself.

This JSR will define a meta-data model and API for JavaBean validation. The default meta-data source will be annotations, with the ability to override and extend the meta-data through the use of XML validation descriptors. It is expected that the common cases will be easily accomplished using the annotations, while more complex validations or context-aware validation configuration will be available in the XML validation descriptors.

The validation API developed by this JSR will not be specific to any one tier or programming model. It will specifically not be tied to either the web tier or the persistence tier, and will be available for both server-side application programming, as well as rich client Swing application developers. This API is seen as a general extension to the JavaBeans object model, and as such is expected to be used as a core component in other specifications, such as JSF, JPA, and Bean Binding.

Apache ServiceMix is an Open Source ESB (Enterprise Service Bus) that combines the functionality of a Service Oriented Architecture (SOA) and an Event Driven Architecture (EDA) to create an agile, enterprise ESB.

Apache ServiceMix is an open source distributed ESB built from the ground up on the Java Business Integration (JBI) specification JSR 208 and released under the Apache license. The goal of JBI is to allow components and services to be integrated in a vendor independent way, allowing users and vendors to plug and play.

Iris shows the power of modern Java applets, highlighting the following major features of the Java platform: Dynamic extension of applets: new techniques developed within the past year in the JOGL project allow applets to use OpenGL for 3D graphics, OpenAL for spatialized audio, Java Media codecs, and other extensions previously only available to desktop or Java Web Start applications.

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

During this JavaPolis '07 keynote, James Gosling (father of Java) presents The State of the Java Universe. Java SE and JavaFX receive special attention during this keynote, where the first ideas towards a possible FX Designer tool gets presented.

blueMarine, photographic workflow with Java - or Why You Should Really Ship Swing 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.

Mule is one of the leading open source ESB and integration framework. It's focus has always been on the developer with the aim of simplifying the difficult task of implementing an integration or SOA project. The focus Mule 2.0 is to make things even easier, more powerful even more robust. This talk will pivot on some of the new features of Mule.

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

An introduction to writing applications using the Google Web Toolkit, and an update on recent improvements to GWT. This session will cover GWT basics: Java to JavaScript compilation, JavaScript Native Interface usage, the GWT component model, and GWT-RPC for communication to a server. This will be a beginner level technical presentation.

This API will enable developers to rapidly build Web applications in Java that are characteristic of the best designed parts of the Web. This JSR will develop an API for providing REST(Representational State Transfer) support in the Java Platform. Lightweight, RESTful approaches are emerging as a popular alternative to SOAP-based technologies for deployment of services on the internet.

Currently, building RESTful Web services using the Java Platform is significantly more complex than building SOAP-based services and requires using low-level APIs like Servlets or the dynamic JAX-WS APIs. Correct implementation requires a high level of HTTP knowledge on the developer's part.

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.

Bruce Snyder, founding member of Apache Geronimo and developer for Apache ActiveMQ, ServiceMix and Castor, talks with Dion about what, when and how Service Mix can be used in an enterprise or light weight Java environment. He talks about the integration patterns that Service mix supports and more.

As agile software development techniques and concepts cross the "technology adoption chasm" we find that the concerns on the right-hand side of the chasm are much different than those on the left.
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.
Other issues such as certification, enterprise architecture, enterprise business modeling, and outsourcing must also be addressed. Finally, we must help the business take a more active role in development, reform IT financing, and in general manage their IT portfolio effectively.

This JSR is to develop Java EE 6, a release of the Java Platform, Enterprise Edition targeted to ship in 2008.

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.

"Being an Illustrated Guide to Events of Significance in the Regulation of Social and Scientifick Affairs from the Earliest Period to the Present Day, Showing their Effects in Human Progress, including a Proposal for Further Advancement under the Leadership of the Duke of Java."

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

Web development have changed. In the Java world, web application development have been defined by overhead. Lots of XML configuration to write - even the simplest Servlet you can deploy still requires more XML than you would expect, all because there are no reasonable defaults. But things have changed and Ruby on Rails is the power behind this change. It is fair to say that the Rails way of doing things have effected change in basically all current web frameworks - from the libraries that are adopting the Rails way, to totally new frameworks that try to bring the agility and speed of development of Rails to the Java platform.

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.

In this session you will learn why it is so crucial to start your SOA with stable and high quality master data.
Defining master data is not an easy task, specially not for large companies. You'll get confronted with practical examples and best practices to define a good master data system.

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

JavaFX Script is a statically typed language that allows good IDE support and compile-time error reporting and has type inference, declarative syntax, and automatic data binding with full support for 2-D graphics and tandard Swing components as well as declarative animation. You can also import Java class files, create new objects for the Java platform, call their methods, and implement interfaces for the Java platform.

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

Some of the content of this presentation will be based upon the book written by the speaker entitled "JavaFX Script: Dynamic Java Scripting for Rich Internet/Client-Side Applications" http://www.apress.com/book/view/1590599454

Ed Burns, co-spec lead for JavaServer Faces, gets interviewed at JavaPolis by our JavaPosse friends Dick Wall and Carl Quinn. During this interview Ed takes the opportunity to talk about his new book and of course about.. euh ... JSF

During this historic JavaPolis '07 discussion panel, James Gosling, Joshua Bloch, Neal Gafter, Martin Odersky and moderator Carl Quinn discuss the future of (Java) Computing and lots more. 'Why is immutable not part of the Java language' and 'How should the Java platform evolve?' are questions discussed by this very relaxed panel.

As agile software development techniques and concepts cross the 'technology adoption chasm' we find that the concerns on the right-hand side of the chasm are much different than those on the left.

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.

Other issues such as certification, enterprise architecture, enterprise business modeling, and outsourcing must also be addressed. Finally, we must help the business take a more active role in development, reform IT financing, and in general manage their IT portfolio effectively.

In this Groovy interview the JavaPosse members talk with Guillaume LaForge about the new features of version 1.5. They ask what he thinks about the Closures controversy and how it fits in the Groovy language. How can you leverage Groovy in an enterprise Java project using Grails and what books should we Groovy newbies read ?

Today's SOA practitioners find their greatest architecture challenges addressing reliability and scalability for composite applications and processing large payloads. This session presents a breakthrough design for SOAs that deliver continuous availability and linear scalability for services and applications. With new approaches that include middle-tier data caching, load balancing and HA through service-level grid enablement, you can make your SOA bullet-proof.

Java API for XML Web Services (JAX-WS) 2.1 takes web services support in the Java platform to the next level. JAX-WS expands support for web services development in Java EE 5 and Java SE significantly. By aligning with Binding (JAXB) 2.x, JAX-WS provides complete support for document-oriented web services, the XML Schema standard, and MTOM/XOP.

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.

In November of 2006 Sun announced that it would publish the JDK source code under the GNU General Public License and build a community around that code. This talk will review the progress of that effort so far, show the different ways in which developers can get involved, and discuss what's yet to come.

Enterprise JavaBeans is an architecture for the development and deployment of component-based business applications. Applications written using the Enterprise JavaBeans architecture are scalable, transactional, and multi-user secure.

The Enterprise JavaBeans 3.0 specification focused on bringing ease-of-use to the EJB API. The purpose of the Enterprise JavaBeans 3.1 specification is to further simplify the EJB architecture by reducing its complexity from the developer's point of view, while also adding new functionality in response to the needs of the community.

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.

Enterprise Information Integration (EII) solutions can provide access to disparate sources of data in real-time while addressing physical and semantic data differences.
This session will let you discover what Enterprise Information Integration is and how it can be used to create data services, a primary building block of SOA-enabled architectures, where data is de-coupled and abstracted between the data source and the consumer, and where semantic mediation and other data processing takes place.

Organizations are adopting service oriented architecture (SOA) in an attempt to reduce cost, mitigate risk, improve efficiency, and increase agility. But many organizations are finding it difficult to realize these benefits and deliver a significant return on investment. This presentation will discuss the challenges that impede SOA adoption and provide suggestions for strategies that can mitigate risks and improve success rates.

Discover the basics of single sign-on and how SAML assertions are finding their way into projects like OpenSSO, NetBeans and Glassfish to secure web services. SAML V2.0, approved by OASIS in March 2005, is an XML-based framework for communicating user authentication, entitlement, and attribute information. Beyond defining the industry-standard protocol for cross domain Web single sign-on (SSO), SAML is a keystone of higher level specifications such as Web Services Interoperability Basic Security Profile (WS-I BSP), the Liberty Alliance's Identity Web Service Framework (ID-WSF) and even Microsoft's Cardspace.

JavaPolis organized a 25 minute Q&A keynote session with James Gosling. A nice opportunity for the European Java developers to ask the father of Java about 'where is Swing going', 'what do you feel about Android', 'what is the future of Java in the RIA space' and lots more. Enjoy!

This JSR will provide a new and improved date and time API for Java. The main goal is to build upon the lessons learned from the first two APIs (Date and Calendar) in Java SE, providing a more advanced and comprehensive model for date and time manipulation.

The new API will be targeted at all applications needing a data model for dates and times. This model will go beyond classes to replace Date and Calendar, to include representations of date without time, time without date, durations and intervals. This will raise the quality of application code. For example, instead of using an int to store a duration, and javadoc to describe it as being a number of days, the date and time model will provide a class defining it unambiguously.

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.

An ESB is part of an SOA infrastructure. However, SOA is not simply a technology or a product: it's a style of design, with many aspects (such as architectural, methodological and organisational) unrelated to the actual technology. But obviously at some point it becomes necessary to map the abstract SOA to a concrete implementation and that's where JBossESB comes in to play!

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.

SpringSource recently announced the release of Spring Web Services 1.0.

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.

Join Arjen Poutsma in this session about this interesting new addition to the Spring portfolio!

One of the key outcomes of Java EE 5 / EJB 3.0 was the introduction of the Java Persistence API. JPA is a new standard API for Java persistence and object/relational mapping that supports use in both Java EE and Java SE environments.

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

SpringSource recently announced the release of Spring Web Services 1.0.

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.

Join Arjen Poutsma in this session about this interesting new addition to the Spring portfolio!

Learn how your organization can adopt an enterprise service oriented architecture (enterprise SOA) with a business process platform that provides enterprise services to compose and deploy solutions for your specific business processes.

In November of 2006 Sun announced that it would publish the JDK source code under the GNU General Public License and build a community around that code. This talk will review the progress of that effort so far, show the different ways in which developers can get involved, and discuss what's yet to come.

Java API for XML Web Services (JAX-WS) 2.1 takes web services support in the Java platform to the next level. JAX-WS expands support for web services development in Java EE 5 and Java SE significantly. By aligning with Binding (JAXB) 2.x, JAX-WS provides complete support for document-oriented web services, the XML Schema standard, and MTOM/XOP.

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.

Today's SOA practitioners find their greatest architecture challenges addressing reliability and scalability for composite applications and processing large payloads. This session presents a breakthrough design for SOAs that deliver continuous availability and linear scalability for services and applications. With new approaches that include middle-tier data caching, load balancing and HA through service-level grid enablement, you can make your SOA bullet-proof.

Put simply, Guice alleviates the need for factories and the use of new in your Java code. Think of Guice's @Inject as the new new. You will still need to write factories in some cases, but your code will not depend directly on them. Your code will be easier to change, unit test and reuse in other contexts.

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.

Eclipse as a Rich Client Platform is increasingly mainstream. Organizations from NASA to IBM to major banks and airlines have adopted RCP as a core platform for building their applications. In this talk we look at various current RCP usecases and examples and discuss the synergies with Spring.

Eclipse still has even more to offer in the application space. Eclipse's
inherent dynamism and the use of Eclipse on the server are largely hidden gems. Spring has its heritage on the server and has enjoyed some use as a rich client platform. In this talk we look at various current RCP usecases and examples, and discuss the evolution and integration opportunities of these technologies.

Belgian French Community wanted to implement SOA by using an ESB JBI standard. ETNIC, the Information Technology Agency of the Belgium French Community chose BULL with Servicemix to help them to develop the solution. The application developed by Bull connects more than 3,500 schools to a centralized administration system in order to facilitate student registrations. It is able to handle 20 registrations per second in order to manage the pick of more than one million registrations at the start of the new school year. During this presentation, we will explain you the solution (architecture, goals, constraints, ...) which includes the ESB Servicemix, the broker ActiveMQ, the BPEL engine Ode and several tools like Cimero, OpenNMS, Spagic, ...

It is common, in SOA project, to integrate systems that are close to each other but slightly different. Oftentimes the difference has mainly to do with different representations of the same core data. You can tackle those tasks through pure programming but it is more efficient to use a tool designed specifically for data transformation.

XQuery and XSLT (both derivates of XPath) provide powerful data manipulation and conversion features. Furthermore they are standard-based conversion engines and built into the Java platform. The presentation will introduce the principles underpinning XQuery and XSLT, demonstrate how to use them in Java and give an update on the state of the standards.

A major complaint in IT and business organizations is that they don't have a common basis from which to have discussions. One talks technology and the other talks financials and goals, in between lies a lot of confusion. In 2005, Capgemini contributed a business centric SOA methodology to OASIS in the hope of fostering a movement away from technical SOA towards business centric SOA, and it remains the only publicly available SOA methodology in that space. This presentation covers that methodology, how to apply it to businesses, how to use it to better understand where technology investment should be made, but most importantly to understand how the business operates and IT's role in helping the business achieve its goals.

A very interesting JavaPolis Q&A session with Joshua Bloch on closures and other Java related topics. From 'Is there an impedance mis-match with Java and the BGGA proposal?' to 'Was the wildcard feature tried out thoroughly enough?' and 'What is your job at Google?'... enjoy the ride!

Last year Neal Gafter premiered his BGGA Closures proposal at JavaPolis. One year later Joshua Bloch presented his view on the Closures Controversy and why he feels that CICE is a more suitable approach. One way to look at the available proposals is to consider the impact on Java as a language: whether it's possible to undergo fundamental change while still preserving the 'Feel of Java'.

So finally at JavaPolis 2007 we announced the next generation of Parleys.com. Ben and I have been working on this for almost half a year, so during the keynote we were very excited to demo our new RIA baby... a 30 min. joy ride. In this interview with Dion Almaer you get some more information about the development and future plans.

Scala is a general purpose programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages. It is also fully interoperable with Java. This interview will give you more information on how Scala was found and what it actually is.

As web sites transition from simple content to full-blown, two-way applications the legacy cruft of the past ten years is becoming apparent. There are millions of sites and billions of pages that have been around since the 1990s. Many of these pages were designed for browsers like Netscape 3, Internet Explorer 2, or even Mosaic. They may have been redesigned several times, but the underlying structure and markup remains the same; and this is becoming a problem. These pages don't work well with modern technologies and tools like AJAX, DOM, E4X, JavaScript, and more.

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 world of software development is constantly changing and evolving. New ideas arise all the time and existing ideas go in and out of fashion. Software development processes find it very hard to keep up with this rapid rate of change, especially as they find themselves quickly going of fashion or becoming bloated as they bolt on more and more information. Teams find themselves struggling as they try to mix-and-match practices from various sources into a coherent way-of-working or work out where to start their improvements.

The term "Service-Oriented Architecture" is very popular these days, but what does it mean? Is SOA just an abbreviation for Same Old Architecture? And if it isn't, where does the old architecture fit in?

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?

magine that you are responsible for driving a truck across America, along highways, through cities and around detours, dealing with whatever idiosyncrasies that weather and traffic might throw at you. Now imagine that your job is not to drive the truck, but program a computer to drive the truck for you. How would you go about turning over everything you know about driving to computer? Trying to plan a large software development effort is not much different than trying to plan the development of a software package to drive a truck across America - without access to the truck. In software development, we have been asked to solve too many truck-driving problems. And when it turns out that we have been handed an impossible problem, it's usually the developers - not the process or the scale of the problem - that are held responsible for the failure. At its core, software development is the process of gradually finding ways to turn over more and more of what we know to computers so that we have more space left in our minds to discover ever more interesting things. This talk will look at successful development efforts on the scale of the truck-driving problem - the development of the Internet, for example - and offer a proven but neglected theory about how to develop complex software.

One of the most difficult things to do (in Java web development) today is pick which web framework to use when development an application. The Apache Software foundation hosts most of the popular Java web frameworks: Struts, MyFaces, Tapestry and Wicket. This session will compare these different web frameworks, as well as Spring MVC and Stripes. It will briefly explain how each works and the strengths and weaknesses of each. Tips, tricks and gotcha's will be plentiful. Lastly, it will provide attendees with a sample application that utilizes all 6 frameworks, so they can compare line-by-line how the frameworks are different. This sample application will include the following features: sortable/pageable list, client and server-side validation, success and error messages as well as some Ajax functionality. The frameworks will be rated on how easy they make it to implement these features.

This session will give an update on recent developments in Spring.NET covering messaging, interop, WinForms, .NET 3.0, and AJAX integration. An overview of features not found in Spring Java, such as the Spring Expression language and its integration into the container, will also be presented.

Java is back on the desktop! We need to deliver high-quality, good-looking, multi-tier swing applications to our customers. How can Spring help us to achieve this at minimal cost?
Next to the typical usage of Spring for IoC, transaction management, security, remoting, and internationalization, this talk will focus on applying Spring to construct a composite smart-client desktop application. Spring aids to develop a consistent user-interface made out of re-useable desktop components. Furthermore, it helps to maximize productivity, and lower the barrier for new developers.