Parleys.com

"Maintaining and evolving deployed applications is a challenging 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."

Scala is a new language for the Java Platform that blends object-oriented and functional programming concepts. This talk will focus on the design choices of Scala, and what they mean for developer productivity. The talk will highlight what it means to program in a functional style, and show you how Scala facilitates programming in a hybrid of both functional and imperative styles. The talk will also explore how Scala compares to dynamic languages such as Ruby and Python. And you'll see examples of real, production Scala code that will illustrate what it feels like to program in Scala.

Pairing can be a highly effective practice that adds significant value to a project, or it can be a disaster whose cost far exceeds managers' fears that they are just paying two people to do the work of one. In the worst case, you won't get the work of one out of the two. They might even do damage that others have to clean up later. The challenge lies in the fact that working as a pair demands a level of attentiveness, collaboration, and continuous focus that working solo just doesn't require. We want to demonstrate some of the behaviors that can undermine the value of pairing, solicit audience feedback about their own experiences and observations, and explain how and why pairing works or doesn't work.

This session was first presented at Agile 2008, where a group of four people rehearsed and acted out "bad pairing" scenarios. In this case, the scenarios have not been rehearsed. Participants in the session will be asked to come forward to act out scenarios with the facilitator. Participants may also suggest scenarios based on their own experiences. Together, we will discuss approaches to correcting the unproductive pairing behaviors.

Although Java offers some great security 'features', this talk will handle the lack of 'build in' security when you develop your web applications.

Security is not an on/off button or parameter you activate for your deployment!

Some real world hacks will be demonstrated to show how easy it is to break the confidentiality or integrity of your data and how easy it is to break you web application!

To finish off in a positive note: it IS possible to do it the right way.

Open Web Application Security Project (OWASP) is a worldwide free and open community focused on improving the security of application software. Our mission is to make application security "visible," so that people and organizations can make informed decisions about application security risks.

OWASP tools and methodologies such as OWASP Java security, source code security review and the enterprise security provide developers with a massive advantage over organizations that are trying to deal with security using existing ad hoc secure coding techniques.

Although Java offers some great security 'features', this talk will handle the lack of 'build in' security when you develop your web applications.

Security is not an on/off button or parameter you activate for your deployment!

Some real world hacks will be demonstrated to show how easy it is to break the confidentiality or integrity of your data and how easy it is to break you web application!

To finish off in a positive note: it IS possible to do it the right way.

Open Web Application Security Project (OWASP) is a worldwide free and open community focused on improving the security of application software. Our mission is to make application security "visible," so that people and organizations can make informed decisions about application security risks.

OWASP tools and methodologies such as OWASP Java security, source code security review and the enterprise security provide developers with a massive advantage over organizations that are trying to deal with security using existing ad hoc secure coding techniques.

If you're a Java web developer, you're certainly familiar with monolithic WAR
deployments and library bloat, and you've probably thought numerous times,
"There must be a better way." Well, there is! By building on the benefits of an
OSGi runtime environment and combining the Spring and Spring-DM
programming models, the SpringSource Application Platform offers enterprise web
developers exciting new opportunities. This session will focus on developing web
applications in an OSGi environment and will include a discussion of the migration
path from a standard Java EE WAR to a fully OSGi-enabled web application
packaged as a Web Module within a PAR. We will begin with an overview of
deployment and packaging options available on the Platform and then take a
closer look at each supported web deployment model from Standard WARs to
Shared Libraries WARs, Shared Services WARs, and finally Web Modules.
Attendees will walk away with a solid understanding of how to both develop and
deploy next generation web applications on the S2AP.

The process of estimating size, time, effort, etc., is fundamental for the success of every software project. Unfortunately, it is often the case that the stakeholders (including project managers, developers, and users) don't know how to do it properly, and everybody ends up working against the clock to meet impossible targets, getting poor software late as a result. After a short introduction in which I'll present what can and should be estimated (e.g., time, size, effort, cost, etc.), I'll focus on what is necessary to get started with some simple, but very effective techniques.

One-size-fit-all fits nothing! Just one kind of AOP won't fit all applications, either.
Therefore, there are many choices available when using Spring-AspectJ
combination. First, there is a choice about AOP system: proxy-based AOP or
bytecode-based AOP. Then there is a syntax choice: traditional AspectJ,
@AspectJ, and XML syntax. Within bytecode-based weaving, there are weaving
choices: build time weaver or load-time weaver (LTW). If you choose LTW, you
have further choices of AspectJ agent-driven or Spring-driven LTW. Confused?
Don't be. These choices, while confusing at first, exists for a reason. This session
explores all these choices and provides guideline on choosing the right
combination to make you successful with AOP.

See Adobe's vision of the future of RIAs. We'll discuss the importance of high-quality design and the tight communication required between designers and developers to build truly compelling applications, including how to make the tools that each prefer interoperate. Finally we'll discuss features and changes expected in Adobe's product line up, like the next version of Flex (code name Gumbo)..

During this relaxed SpringOne'08 keynote Adrian Colyer gives a high level overview of what's next for the Spring Platform, followed by an interesting demo by Rob Harrop covering the new dynamic Spring OSGi services

Ajax has the power to make your applications satisfying and beautiful or painful and frustrating. This talk shows how Dojo can help you create amazingly beautiful user experiences and how DWR brings the beauty to Java by making Java and JavaScript work well together.

Both Dojo and DWR have changed a lot in the last 2 years. Dojo now has a theming system, many new widgets, and great documentation. DWR can now synchronize data between the server and multiple clients, you can implement Java interfaces with JavaScript, and call both ways between Java and JavaScript.

"Management and monitoring are often afterthoughts in many enterprise
application architectures. Developers fail to design for manageability because they
think it is too time consuming or too complex. Some are overwhelmed by the
amount of information that can be exposed and the seemingly endless number of
ways it can be aggregated. Others are concerned with the performance impacts of
monitoring deployed applications. As a result, applications are built with little to
no runtime visibility. This can result in critical failures that could have been
prevented through application management.
This presentation will show how management and monitoring can be easily and
consistently incorporated into any enterprise application using Spring. Attendees
will learn best practices for architecting applications for manageability, and will
see how they can achieve runtime application monitoring with minimal
configuration and low performance overhead. Spring provides components that
utilize JMX and AOP to greatly simplify modeling and instrumentation tasks. This
presentation will provide detailed instruction on how to use these components in
the development of every aspect of an end-to-end application management
solution."

The demand continues to grow for rich interactive content, applications, and services that run on a variety of clients. Rich Applications have achieved a new degree of sophistication with requirements to add multimedia and animation. With the JavaFX SDK and Java SE 6 update 10 it is possible to incorporate innovative elements of rich client applications into existing Java software with minimum effort enabling consistent user experiences on the desktop, mobile devices, TV, and other consumer platforms.

This session provides a glimpse into cross-screen applications development using JavaFX libraries such as vector graphics and animation, and media applications with native audio and video. Additionally, this session will illuminate the JavaFX SDK that provides a suite of tools for web scripters, designers and application developers, namely:

JavaFX SDK: The JavaFX compiler and runtime tools, 2D Graphics and media libraries to create highly interactive applications for the desktop and browser.

NetBeans IDE with JavaFX: A sophisticated development environment to build, preview, and debug JavaFX applications.

Project Nile: A set of plugins for Adobe Photoshop and Adobe Illustrator that allows exporting graphical assets to JavaFX applications.

Java Runtime Environment 6 Update 10: This new version of the Java Runtime Environment (JRE) provides a redesigned Java browser plug-in that allows drag and drop of JavaFX applications from the browser to the desktop.

In summary, this keynote session will present an overview of the JavaFX product family. The remainder of the session will be devoted to creating impressive GUI applications with animation and multimedia capabilities using the JavaFX scripting language.

The Spring Framework 2.5 introduced comprehensive support for annotationbased
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.

The Java programming language provides numerous features to support the construction of large programs, but could do more to reduce JAR hell and simplify application packaging. The majority of this Devoxx keynote will describe how modular programs can address these issues, and how Java language and VM features can be designed to make programs more modular while retaining compatibility with legacy code.  In the seond part Mark will also look at possible features for Java SE 7.

Users are increasingly expecting their content and applications to be available across all the screens of their life. Built upon the Java Platform, JavaFX 1.0 provides the tools, APIs, and features necessary to create dynamic applications for the next generation of internet application innovation.

This session starts with an overview of the language, particularly from a Java developers perspective. The session will then dive into the JavaFX scene graph, animation, and media APIs. It ends with a brief roadmap for the future of the JavaFX platform.

After attending this session, attendees will be able to walk away with a good understanding of how to use JavaFX technology for designing compelling rich internet applications.

The talk begins with a brief discussion of the distinguishing features of ORM
specifically Hibernate. We'll compare Hibernate to other approaches such as
straight JDBC and we'll try to clarify when Hibernate is a good choice. Then we'll
move on to review the main pieces of Spring's Hibernate integration, which
among other things will help us understand the value Spring adds for Hibernate
applications. If you're using Hibernate today you may wonder why you should use
Spring's Hibernate integration. My hope is you'll get a solid understanding about
that after this part of the presentation. In the second part we will examine Spring
2.5 features relevant to building data access code with Hibernate and we'll look at
sample code along the way.

Taking the next step in evolution of concurrency APIs, looks at how the libraries will evolve to support many-core parallelism.

Users are increasingly expecting their content and applications to be available across all the screens of their life. Built upon the Java Platform, JavaFX 1.0 provides the tools, APIs, and features necessary to create dynamic applications for the next generation of internet application innovation.

This session starts with an overview of the language, particularly from a Java developers perspective. The session will then dive into the JavaFX scene graph, animation, and media APIs. It ends with a brief roadmap for the future of the JavaFX platform.

After attending this session, attendees will be able to walk away with a good understanding of how to use JavaFX technology for designing compelling rich internet applications.

Keynote presentation Devoxx 2008

This session will cover the internal architecture of the SpringSource Application Platform. Topics covered include: - Modularity - Concurrency - Serviceability - Dumping, Deadlock detection, Management Console - Advanced features - Scoping, Profiles, Load-time weaving - Configuration

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.

Structuring a large code base maintained by teams working in parallel can be a real challenge. If you are not disciplined about code structure overtime, you will end up with a tangled, unmaintainable mess that cannot adapt to change and risks ossifying into legacy. This session presents typical challenges in evolving large code bases, focusing on package interdependencies and module decomposition according to 'conceptual boundaries'. We will discuss lessons learned from the Spring project itself, and investigate the use of tools for validating architectural soundness.

This follow-on to last year's JavaOne sleeper hit 'The Top 10 Ways to Botch an Enterprise Java Technology-Based Application' explores best practices for protecting against scalability and reliability in Java Enterprise Edition applications and compute grid environments. Starting with simple abuses of messaging and clustering technologies, this presentation navigates a wide swath of options available to enterprising architects seeking to limit the effectiveness of scale-out environments.

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.

This session will introduce you to the basics of JSF 1.2 and will explain why JSF is different from other web-frameworks. The concepts of JSF will be shown using the JSF request lifecycle, a short overview of the JSF standard components will complete the picture. Additionally, we'll bring a little light into the jungle of JSF frameworks, add-ons and component libraries and introduce you to the most important ones briefly.

The Spring framework has an extremely rich set of features that span all tiers of the application. If you are relatively new to Spring you might be wondering which of the many features to focus on; which features to avoid; and how to use the various features together in an application. This talk describes how the Spring framework was used to build an enterprise Java application. We will walk through each tier of the application and describe how the Spring framework was used.

You will learn about how Spring was used to solve various design issues including:

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

In the talk Paul will look at the capabilities and approach of Open Source ESBs, and argue that the Open Source approach is the best route to creating a long-term, robust and cost-effective Service Oriented Architecture. Paul will look at Open Source ESBs including Mule, ServiceMix, and Synapse, and explore the strengths and weaknesses of each approach, and compare to the offerings from the established vendors.

Whenever the need for reporting arises one has a broad spectrum to choose from. However if it comes down to integration with Spring, JasperReports is the way to go. With reports output coming from virtually anywhere JasperReports is capable of rendering into four different formats: CSV, Excel, HTML and PDF. In this session, Joris and Jan discuss the usability and hacks of JasperReports combined with Spring.

Writing unit tests should be easy and intuitively... at least in theory. In practice, you need a lot of infrastructure, libraries and boilerplate code before you get to do something productive on a database driven enterprise project.

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.

During this presentation we will discuss unit test guidelines and best practices. We will make use of examples to demonstrate how Unitils can help you in writing simple and maintainable unit tests.

The debate about REST (REpresentational State Transfer) as an alternative to SOAP has been going on for several years now - with more and more respect for the REST point of view in the recent past. While many will agree that a RESTful approach is a better match for Web 2.0-style, public-facing Internet services, it's still often questioned how REST could be applied to 'Enterprise' scenarios. This talk will briefly summarize the REST principles behind the Web's architecture, and then show how an enterprise scenario can benefit from the properties that have made the Web a success.

Spring Beyond the Obvious - using Spring in complex enterprise projects. We all know how to dependency inject our service objects and our DAOs or Repository. We know how to set up a transactional service layer using @Transactional annotations or using <tx:advice> in XML. There are plenty situations however where is doesn't end here. Many development teams use multiple environments (staging environments, production environments, et cetera). How do you set up your application context(s) in such a way that it easy to transition from one environment to the other. How does internationalization affect your application, et cetera.

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.

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.

Welcome to the world of Spring- a very powerful framework that opens a
lot of possibilities. More often than not the potentials of Spring leave
people confused. How should an application be designed? What about best
practices? In this talk some of the issues for the architecture of
Spring applications are explained in more detail and typical approaches
are shown. This includes typical solution in areas like

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

The Open Service Oriented Architecture collaboration was formed to create a language-neutral programming model to exploit Service Oriented Architectures. Partners include IBM, BEA, Oracle, SAP, Siemens, Sun, Red Hat and Interface21. In this session Adrian will give an insight into the Service Component Architecture specification, and how Spring can integrate into an SCA-based enterprise
architecture.

At Adobe's website you can read the following about Flex 2.0: "Adobe Flex 2 software is a rich Internet application framework based on Adobe Flash that will enable you to productively create beautiful, scalable applications that can reach virtually anyone on any platform. It includes a powerful, Eclipse based development tool, an extensive visual component library, and high-performance data services enabling you to meet your applications' most demanding needs." We will share our experiences and best practices on How to build Rich Internet Applications (RIA's) based upon Flex2.0 within a Spring and Hibernate enabled J2EE architecture.

The Sun SPOT features a Java virtual machine running on metal, with developers able to write device drivers and other software. Using NetBeans open source tools or standard development tools, SPOT technology could be applied to devices ranging from toys to MP3 players to traditional sensor applications such as environmental monitoring systems and package-tracking systems. Another possibility is gesture recognition, where interfaces would be interacted with via gestures, for purposes such as transferring data on cell phones.

Modern web development requires writing better code in less time with increasingly complex technologies and languages. While relatively new, these technologies pose the same set of problems that Java developers have worked to solve for years. In this session, you will learn how IntelliJ supports you in your Web 2.0 development to move projects forward, solve problems, and hit deadlines.

Mike Aizatsky will teach you to:
* Use intelligent code assistance to code faster and more efficiently in HTML, CSS, JavaScript and JSP

* Check overall site consistency in an environment with a complex mix of languages

* Refactor existing sites by changing their structure without breaking any of the used languages

* Find and clean unused parts of your site code

Magnolia Community Edition is a free, easy-to-use yet powerful enterprise Java content management system based on JSR-170. This presentation by Boris Kraft gives you a further insight in this open source CMS product.

This presentation shows how three open source projects hosted in the ObjectWeb Consortium can be leveraged to build a powerful Enterprise Content Management solution (ECM). The major objective of this integration is to benefit from the best of Portal, Workflow and Wiki components to handle the organization content through the process of capturing, storing, managing, publishing and referencing.

This solution relays on the three components of the ObjectWeb ecosystem and is a clear example of cross fertilization of open source projects:

    * eXo Platform version 2 which is a powerful Enterprise Portal and Content Management solution used by several US federal, French and Italian administrations. It allows the creation, monitoring and publication of personalized contents through a single unified web platform.

    * Bonita is a complete Workflow System offering out of the box workflow features. Bonita increases automation, collaboration and robustness of the platform powered by eXo. It constitutes its perfect companion by providing a workflow engine, a user interface and a process design tool supporting processes for online services.

    * Xwiki is an open-source project to develop a Java eXtended Wiki engine. Xwiki can be seen as a portlet available in eXo portal offering powerful wiki fonctionalities to users. Even more, in the context of a ECM solution wiki pages can be automatically updated by a workflow engine in charge of a document validation process.

The session features short presentations of components. It then deals with a real world use case where they are combined to form an ECM suite. It will show, among others, how documents are created by users through eXo Portal, then stored in eXo Java Content Repository, processed by Bonita and then published in Xwiki.

Are you an IBM WebSphere Application Server customer? Interested in using the Spring Framework? Then this session is for you. As many of you know, IBM & Interface21 have been working closely to deliver value to customers. This session will talk about what we have been doing, and look at examples of how to best utilize the Spring Framework in your WebSphere environment. You'll also learn how to take advantage of new technologies such as JAX-WS, and EJB3 in your SOA.

UI test automation is, nowadays, a commonly used approach. First, because of the tools offering, second because different organization started to realize (if they did not do it before) how high is the defect cost, so they started to think about getting more from testing while spending less on it. For many, it becomes obvious pretty soon that the automation is not as beneficial as if first seemed.

Oracle Coherence enables in-memory data management for clustered J2EE applications and application servers that makes sharing and managing data in a cluster as simple as on a single server. Developers can easily take advantage of Coherence features using the standard Java collections API to access and modify data, and use the standard JavaBean event model to receive data change notifications.

This session will introduce Coherence and explore how it can be used to reliably cluster, scale-out and obtain high-performance continuous availability for data and stateful applications.

Compass is an open source Java Search Engine framework, allowing the integration of search functionality into any application. One of Compass main modules is a Spring integration module, heavily used among Compass user base.

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.

There are many sides to agile development, but it is all too common
to focus on only one or two, depending on personal interests, job role,
background, etc. A manager may focus on organizational and process
aspects to the exclusion of technical ones, whereas a developer may
have a complementary view. Different developers may focus on different
details to the exclusion of others: one developer may value emphasis on
a loosely coupled architecture but be less concerned by testing,
whereas another may view agility solely in terms of unit tests and task
automation. Each perspective is valid, but missing the other
perspectives means missing the whole picture.

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.

There are many sides to agile development, but it is all too common to focus on only one or two, depending on personal interests, job role, background, etc. A manager may focus on organizational and process aspects to the exclusion of technical ones, whereas a developer may have a complementary view. Different developers may focus on different details to the exclusion of others: one developer may value emphasis on a loosely coupled architecture but be less concerned by testing, whereas another may view agility solely in terms of unit tests and task automation. Each perspective is valid, but missing the other perspectives means missing the whole picture.

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.

During this Jazoon keynote Ted Neward talks about why the next five years in IT will be about languages. The programming language virtualization, tools, linguistic focus and expressiveness are different forces that are coming of age. Not to mention the impact of the over-used and over-hyped Domain-Specific languages. How will these languages tackle the evolving application security demands or rich user interfaces, Ted Neward approaches these questions in his own unique style.

Google Web Toolkit (GWT) provides you with a great way to develop Ajax applications in the Java language. It allows you to develop 'fat clients' for the web, without having to know the ins and outs of JavaScript and all the corresponding browser incompatibilities.

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.

Most of us are familiar with Spring mostly as platform for simplifying the development of our JEE applications using POJO based approach. Our solution still rely J2EE as the container for addressing the high availability and scalability of my application. In most of high performance/low-latency environment this combination was hardly sufficient and most people found themselves building infrastructure outside the JEE stack to address their scalability and performance requirement. In most cases this was achieved by turning their Tier based application into SOA/EDA combining In-Memory-Data-Grid (IMDG) share state between their services and Messaging Bus (ESB) to enable loosely couple communication between those services.

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.

Light weight SLA driven containers enables the deployment and management of those services over a dynamic pool of machines, in addition to that we will discuss how in future OSGI will be used to provide dynamic services and enable the management of their lifecycle independently even if they share the same VM. All this together makes the entire development of large scale application as simple as writing any other standalone Spring application today.

This presentation will give an overview of the continuing evolution of the Java Platform. With the successful launches of the Java EE 5 and Java SE 6 platforms in 2006, we look ahead to the new developments in the platforms beyond these existing releases. Technical highlights of the talk will include the new modularity technologies in Java SE 7 for packaging, distributing and publishing application code (sometimes known as super-JARs and super-packages), a survey of the candidates for additions to the Java language as well as the work in the JVM to support other languages such as Ruby and Python. Highlights will also include the new work planned in Java EE 6 to make the platform more extensible, the candidate technologies to extend the SOA architecture of Java EE and key enhancements to the existing web and EJB technologies.

In addition this talk will discuss the open source models for participation in Sun's implementations via the Glassfish and OpenJDK communities.

Specifying metadata using annotations has gained huge popularity since its introduction in Java 5. However, the story on consuming annotations isn't as clear. Reading and processing annotation is still a complex process often requiring you to understand byte-code manipulation tools and their low-level API. As a result, most developers shy away from using custom annotations, limiting their usages of annotations only those prescribed by frameworks. The result is missed opportunities for programming simplification. In this session, we explore how AOP can make it a simple task to consume annotation in a powerful manner.

This session explores many opportunities to consume annotations using Spring AOP and AspectJ. The examples discussed in this session cover a wide range from auditing, monitoring to security, transaction management, and policy enforcement. It also examines best practices in using annotations to avoid pre-processor like use of them.

Even though XML is by far, the most popular way of configuring the Spring container, it is not the only one. In this session we will focus on existing alternatives to XML, how they relate to the Inversion of Control (IoC) principle as well as the effect they have on development and deployment.

In this session, you will explore the technologies of AOP and JMX and how they can be used together to transparently add management and monitoring in a non-invasive way. You will explore aspect oriented programming using Spring's AOP framework and learn how Spring 2.0 allows you to upgrade later if you choose. Next you will explore Spring's JMX abstraction and how it can be used to expose your management and monitoring data to external clients and consume the information using JConsole or Spring.

If you are tentative about introducing AOP or JMX into your application, come take a look at some of the cool things you can do with them and how easy integration can be.

In this session Patrick explores the new Java Persistence API, and examine some common practices for how to write Spring applications that use JPA. Patrick will focus more on API usage than on mapping configuration, and will look at the bootstrapping and runtime behavior of JPA applications. You will learn about JPA's optimistic locking semantics, including the benefits of optimistic read locks. Patrick looks at when it's appropriate to use the different facilities of the Java Persistence Query Language (JPQL), and also discusses common extensions to the spec, including performance caching, pessimistic locking, and fetch strategies.

Spring LDAP completely eliminates the need to worry about creating and closing DirContext and looping through NamingEnumeration. It provides a comprehensive unchecked exception hierarchy, support for different authentication sources like for example Acegi Security, and a convenient way of processing request and response controls. As a bonus, Spring LDAP also contains classes for dynamically building LDAP filters and distinguished names. Version 1.2 even adds client-side transaction support to the feature list.

In this session, the creators of Spring LDAP will discuss these features and also do some live coding in order to demonstrate how to quickly build a fully working person manager application.

Java is an object-oriented language and object-oriented design is considered by many to be a good way to tackle complexity. However, surprisingly many complex enterprise Java applications are written in a procedural style. The business tier consists of fat services and anemic domain models and consequently can be difficult to understand, maintain and test.

In this presentation, you will learn about how to improve your applications by implementing business logic using rich POJO domain model. We will compare and contrast a procedural design with an object-oriented design and describe the benefits of using an object-oriented approach.You will learn how to identify procedural code smells and eliminate them by refactoring your code - something you can start doing the Monday morning after the conference.

Roy T. Fielding is the Chief Scientist at Day Software Holding AG and supervises the modernization development of the infrastructure which the World Wide Web is based on.

As one of the first modern Hypertext Transfer Protocol (HTTP/1.1) architects, co-author of internet standards for HTTP and Uniform Resource Identifiers (URI), as well as the founder of various Open Source software projects,amongst others, the Apache HTTP server project, his name is intrinsically tied to the development of the World Wide Web infrastructure. In his keynote address, Roy T. Fielding will pursue the question of how individual Java applets can be replaced by friendlier Web application delivery interfaces.

Closures simplify the use of APIs that rely on the use of anonymous class instances, such as the concurrency APIs and callbacks. More importantly, closures support control abstractions, which are APIs that act as programmer-defined control constructs. This 2nd closures talk includes some new ideas on the subject.

Scrum is one of the most well known agile methodologies. It has several characteristics which make it very attractive; some of them are:
1. Simplicity. Its basics can be learned in less than a day
2. Flexibility. It can be customized to fit the needs of the project
3. Scalability. It has been used in projects with up to hundreds of developers
4. Visibility. All the issues that may arise during the project lifetime become immediately visible. This makes their solution easier.

However, its implementation can sometimes be difficult. Scrum, like all other agile methodologies, is heavily based on teamwork, communication, trust, and on delegating responsibility and authority. All these things together represent a major cultural shift especially for companies used to more traditional methods which, usually, requires time and hard work to be fully accepted.

In this presentation I will give an in-depth introduction to this methodology and of some of the problems that may happen during its implementation, along with some hints and tips for their solution. I'll also give some references for the ones willing to know more. The goal is to give the attendees enough knowledge to get started without getting burned.

New users are often intimidated by the breadth and depth of Dojo. In this talk we'll get into the guts of some of Dojo's advanced, but less well known, features. This talk will cover such topics as: JSON-RPC, in-page mashups with Yahoo APIs, alternative IO transport layers, non-browser runtimes, event-system magic, deployment optimization techniques, Flash and local storage, the undo stack, form validation, and functional programming helpers.

Dojo makes professional web application development better, easier, and faster. This talk covers Dojo's core APIs, including those for Ajax, Drag and Drop, Animations, and AOP-style event handling. We'll also discuss some of the stock widgets, various ways to take advantage of them, and how you can use Dojo's package system to help make your own code faster and more portable..

Scrum is one of the most well known agile methodologies. It has several characteristics which make it very attractive; some of them are:
1. Simplicity. Its basics can be learned in less than a day
2. Flexibility. It can be customized to fit the needs of the project
3. Scalability. It has been used in projects with up to hundreds of developers
4. Visibility. All the issues that may arise during the project lifetime become immediately visible. This makes their solution easier.

However, its implementation can sometimes be difficult. Scrum, like all other agile methodologies, is heavily based on teamwork, communication, trust, and on delegating responsibility and authority. All these things together represent a major cultural shift especially for companies used to more traditional methods which, usually, requires time and hard work to be fully accepted.

In this presentation I will give an in-depth introduction to this methodology and of some of the problems that may happen during its implementation, along with some hints and tips for their solution. I'll also give some references for the ones willing to know more. The goal is to give the attendees enough knowledge to get started without getting burned.

The microService Architecture (mSA) Backplane is an OSGi-based infrastructure that will be the basis for many future software products from BEA. This project has been in development for about a year, and currently consists of about 100 different OSGi bundles that encompass functions such as logging, thread management, HTTP servlets, web services, and transaction management.

In the course of our work, we have learned a great deal about the process of breaking down existing, production-quality software into individual modules, and we have learned how to effectively use some of the best features of OSGi, such as the class loading infrastructure and the service registry. We also continue to be challenged by other aspects of OSGi, such as the security infrastructure and the mechanisms for starting and launching bundles.

In this talk, we will describe the mSA Backplane, and we will concentrate on the lessons we have learned about OSGi in the process of building it. We will assume that attendees are familiar with fundamental OSGi concepts.

Learn how to build XML and SOA systems for performance, scalability, and governance.

Frank Cohen demonstrates building a service architecture implemented with native XML technologies (both commercial and open-source,) he will compare the effort to build the application with these tools, and he will demonstrate the performance of each using a load test of the implementations. Frank will show the design and test methodology for a new architecture he calls FastSOA and the results of a recently completed performance and scalability comparison of native XML tools.
Attend this session and expect to take away the following:

    * Your choice of SOA and XML tools greatly impacts scalability and performance of the resulting system.
    * Learn Frank's methodology to quantify SOA and Master Data Management (MDM) scalability and performance and use the methodology in your work
    * Understand the differences in performance and developer productivity when choosing development tools, including native XML databases and relational databases

Alfresco is the first open source enterprise content management system developed by the founder of Documentum and including core Java teams from Documentum and Interwoven. Alfresco is developed as a scalable, aspect-oriented repository developed using Spring, Hibernate, Lucene, jBPM, Chiba and MyFaces and supporting standards such as JSR-170, CIFS and WebDAV. Alfresco presents the first standards-based alternative to expensive commercial ECM platforms.

This presentation shows how typical enterprise content applications such as compliance extranets, specialist document management applications and intranet portals can be developed using open source software. The presentation covers how Java and JavaScript developers can extend the functionality of the content repository through aspect-oriented programming, build JSR-170 compliant applications that can scale to enterprise scope, build Xforms for capturing multi-channel web content, and build AJAX-enabled web applications. In addition, issues such as scalability, clustering, distribution and recovery will be addressed.

The focus of this session will be to demonstrate innovative open source technologies and give you an insight into the skills, tools and techniques for SOA-enabling your enterprise architecture. This session will be taught via lecture as well as interesting live demonstrations (e.g. .NET linking to Java-based Rules engine) on various SOA related technologies such as ESB, BPEL and Web Services. This session also includes a number of interesting data points that I have collected from meeting with senior architecture teams from numerous large IT organizations.

OpenOffice.org is multi-platform, open source office productivity suite. OOo natively uses the "OASIS Open Document Format for Office Applications" while also fully supporting the Microsoft Office formats. Due the fact of its standardized file format OOo becomes more and more important in public offices and even enterprises. But even in more complex environments an office suite needs to be integrated in existing work flows, in existing applications or needs to be extended by some special functionality to meet existing requirements.
OpenOffice.org offers a language independent API which allows to program OpenOffic.org in Java, it allows to use OpenOffice.org as service provider in your own applications, extend it with new functionality or simply customize and control OpenOffice.org. This session will give a general overview of the OOo programmability capabilities including tool support.

AJAX Development with JavaServer Faces: Look Ma, No JavaScript!

This session explains how you can build attractive, AJAX-enabled applications using JavaServer Faces (JSF) technology without the use of manually-coded JavaScript. After a brief overview of JSF and the JSF programming model, the session explains how component vendors leverage JSF's architecture to build AJAX components, and shows several of AJAX component suites in action. The session ends with a discussion of how JSF will evolve to provide even better AJAX support.

This session is pretty different from Roger Kitian's JSF session, but if you guys feel like there is too much overlap, here are some other possibilities:

Architecting JavaServer Faces Applications
Over the past year, a lot of time has been spent explaining what JSF is, and how different pieces of it work. However, little attention has been given to the process of architecting applications. This makes JSF architecture seem like a black art, since there are so many possible approaches to the application's architecture.

Intro to JavaServer Faces
JavaServer Faces (JSF) is a standard web user interface framework, developed under the Java Community Process (JSR 127), and released in March, 2004. JSF specifies a web user interface component model, complete with server-side event handling, validation, internationalization, page navigation, and declarative mapping between user interface components and Java objects.

Exploring the JavaServer Faces Ecosystem
This session examines the ecosystem that is growing around JavaServer Faces.

Large scale enterprise application deployments face challenges in development and deployment. Java EE 5 provides a mature and robust API for authoring enterprise applications. This talk tackles the issues with deploying such enterprise applications in the "real world". Specifically we'll discuss the advances in packaging reusable applications, disruption-free application upgrades and application lifecycle management. We will explore some of the ways that the Java EE 5 specification and BEA's WebLogic Server address these issues.

The technique of domain logical value-objects (DLVO) is a method for domain-driven programming that stays close to the code. It takes the "middle road" by identifying domain concepts that are more than "just data" (e g strings and integers), but still not "big enough" to qualify as long lived objects with a unique identity (e g customers and orders).

Examples from a CRM application could include phone numbers, credit classifications, email addreses, and contact intervals. By explicitly spelling these out in the design, they provide an effective way of gathering validation and other operations for reuse. As an effect it simplifies a lot of other code, which was earlier luttered with these kinds of operations.

The major advantage of using DLVOs is that it can start being applied immediately. It does neither take structural changes of the overall structure, nor craves a heavy round of preparing refactorings. So, it can be applied with a very small initial effort. In that way, it is possible to very fast start reaping some of the fruits of the domain driven approach, e g more structured in-data validation, more expressive service-APIs and clearer code in the business logic (often EJBs or similar).

I this session we present domain-logical value objects, and how you write and use them in practice. The concrete code examples are in Java, but the ideas and techniques can just as well be applied to code written in C++/C, VB or Ruby.

Spring 2.0 introduced major enhancements in the Spring Framework making it both simpler to use and more powerful. In this session, Rod discusses some of the enhancements through code examples, focusing on: - Extensible XML configuration, support for dynamic languages in the Spring component model, and support for JPA.

Rod demonstrates how Spring 2.0 provides a launching pad for further developments in 2007, discussing the implications of OSGi integration for the Spring component model, and additional configuration options.

Finally Rod surveys the Spring Portfolio, and show how the ecosystem around Spring helps in many areas of enterprise development.

Java allows the experienced developer to write highly flexible code, especially when using dynamic features like proxies and references. In this talk, Heinz brings these together with generics and enums. He will demonstrate some approaches of using Java's dynamic proxies to create virtual proxies, protection proxies, dynamic object adapters and dynamic decorators. A part of the talk will also explore the performance implications and compare it with the benefits gained. P.S. If you are wondering why "enum" is listed under "advanced features" you should definitely attend this talk.

Your high performance application is facing continuous and exponential growth in transaction and data volume? You know that SOA is the right architecture for addressing these challenges, but at the same time, you understand that web services cannot be the right way to go, because of their inherent performance limitation?

This session will show you how POJO services, combined with a Space Based Architecture approach, will help you build stateful SOA in a high performance environment. More than that: you will see how Spring can turn your POJO into a highly efficient service that can dynamically scale across an entire network of machines without changing your code.

Number Portability is something that Telecom Operators need to implement by law. This case is about how automating this process can deliver a return on investment for the Telecom Operator, and how professional open source can support this. The presentation will make use of an existing case that JCS/Dolmen implemented at there customer and how JBoss products like AS and jBPM were used to realize the Number Portability issue.

Many teams, projects and even organizations are following meanwhile an agile process. However, not always successfully. If you're looking behind the scenery, you will find out that although the agile practices like pair programming or test-driven development are used properly, the agile value system is not implemented. This is due to the fact that the practices can support agility but they can not establish agility. This leads to an expectation mismatch regarding acceptance and success of agile development.

With her experience in helping projects all over Europe to establish the agile value system, Jutta will point out what to look out for when applying agility.

Well written Swing applications tend to have the same core elements for startup and shutdown, and for managing resources, actions, and session state. New applications create all of these core elements from scratch. Java SE does not provide any support for structuring applications, and this often leaves new developers feeling a bit adrift, particularly when they're contemplating building an application whose scale goes well beyond the examples provided in the SE documentation. This specification will (finally) fill that void by defining the basic structure of a Swing application. It will define a small set of extensible classes or "framework" that define infrastructure that's common to most desktop applications...

Apache Geronimo is the latest open source application server to achieve J2EE 1.4 certification, making it ready for adoption in the Enterprise.

It is now a real contender in the open source application server market and offers a unique architecture making different open-source projects pluggable and capable of building customized stacks. This session will present an overview of Apache Geronimo, the project and community, its
architecture, its major open source components, and how to configure and use the application server. The presentation will cover a technical birds-eye-view of Geronimo's unique components and concepts such as the kernel, plugins and how to effectively use Apache Geronimo in yourorganization.

Quite often when teams are faced with the pressure of dealing with poor performance, the first instinct is to revert to those development techniques that are all so like your favorite pair of slippers. The problem is, it is almost impossible to diagnose a performance problem using static analysis of the code. To be successful (rather then lucky) one must be able to acquire dynamic data from the runtime and then be able to understand what that data is telling them. This talk will dive into how one can instrument J2EE/J2SE applications to diagnose performance problems. But since power point slides are cheap, we will minimize time looking at them in favor of spending more time solving performance problems together.

AJAX is great for many applications, but not for all. When applications get large, need to scale, or require superior security, Java-based Rich Internet Applications (RIA) are preferable. There is a simple reason for this: Java offers the most advanced, most standardized, and most reliable cross-platform UI technology by far.

Designed for full-fledged desktop applications, client-side Java outclasses AJAX in terms of functionality, stability, performance, and security. There is only one issue with conventional Java clients: they don't fit into a web architecture, despite Applets and Java Web Start. A solution for this issue is Java RIA technology. This technology bridges the gap between Java's rich UI components and a server-side web architecture, leveraging both the advantages of client-side Java and server-side application management.

Industrial strength thus becomes feasible for enterprise applications, as well as new generation Web 2.0 applications and sophisticated mashups.

What's all the buzz about Faces and Ajax working together?
Can these two technologies really work together to develop dynamic applications? This JavaPolis talk begins with an insight into the design heritage of Faces, and we'll explore some patterns for using these two technologies together. Then we'll dive into the code from a page author and component developer's perspective, and take a detailed look at the Dynamic Faces (better known as DynaFaces) Ajax framework. We wrap up with a summary of other Ajax / Faces frameworks that are available today.

Roger Kitain is the JavaServer Faces specification lead at Sun Microsystems. Roger has been involved with server side web technologies and products since 1997. He started working on JavaServer Faces in 2001 as a member of the Reference Implementation team. Roger has been involved with different rendering technologies for JSF. He has written various articles about custom component development and how JSF plays with other Java EE technologies.

In this session Paul Fremantle will cover how the OASIS Web Services Reliable Messaging standard allows Web services interactions and messages to be reliably delivered. WSRM is a new protocol that supports MQ or JMS like levels of reliable delivery on a completely open basis, with interoperability between systems including WebSphere, Apache Axis2 and Microsoft .NET.
As well as taking a walkthrough of the specification, we will take a detailed look at some of the implementations available, including the Apache Sandesha project. The session will include detailed code examples and demonstrations of reliable messaging using WSRM.
Paul is the co-chair of the Technical Committee that is standardising the WSRM specification, as well as involved in the Apache implementation, so this is a great opportunity to learn about this technology from one of the technical leaders.

Learn how to build, test and secure web services with XFire as well as some of the upcoming features including REST & JSON support.

This talk seeks to give you the basic knowledge on how to get your self started writing web services with XFire. We'll cover:

    * How to build a web service
    * How to consume a web service
    * How to test your web service
    * How to secure your web service
    * How to version your web service

Due to the short nature of the talk, we will seek to give a quick overview of each topic so you can make intelligent decisions while exploring deeper later. If time permits we will also cover some of the upcoming features including REST support and JSON support.

Do you think of SOA as the "Same Old Architecture"? The Apache Tuscany project moves SOA (Service Oriented Architecture) beyond buzzwords and vague arm-waving into reality. The project aims to create a next-generation services infrastructure in open source based on the principles behind the Service Component Architecture (SCA). With Apache Tuscany, application developers will be able to create, assemble, and deploy service networks in ways that are not easily done with existing middleware.
Apache Tuscany, undergoing incubation at the Apache Software Foundation, provides implementations of the Service Component Architecture (SCA specifications and related technologies such as Service Data Objects (SDO)
and Data Access Service (DAS). The overall goal of the project is to provide an open-source runtime platform to simplify the implementation of SOA-based applications in various programming languages such as Java, C++, JavaScript or BPEL. Tuscany integrates with well established Web Services and server technologies such as Apache Axis2, Apache Tomcat and Geronimo. This session will explain the SCA, SDO and DAS concepts and show how Tuscany simplifies the task of creating and assembling service-based applications through coding examples and a demonstration.

Transactions are entering the web services platform in the form of "web service transactions". But are they really needed? This presentation will explore the relevant WS-* standards, why and when they can be useful, and also when to avoid them. In addition, the talk will discuss some (perceived?) alternatives like BPEL or reliable messaging. This session will give you the foundation for building rock-solid reliable web services by choosing the right tools at the right time.

"Speaking of business processes, when humans are involved, it makes very little sense to have a centralized, computer-based system coordinating business processes on behalf of humans ..."
"The Human in the Machine", ZapThink

In this talk, Keith Harrison-Broninski will describe humanedj, an operating software founded directly on the principles of Human Interaction Management.

Humanedj is a new kind of process support system. It is a "personal process assistant" software that helps the user carry out any and all work activities in which they are engaged, facilitating tasks and interactions as necessary. It runs on the client machine(s) of each process participant, installing with a click. No server installation is required.

Further, humanedj provides support for the innovative, adaptive, evolutionary activities typical of collaborative human work. Think a continually re-negotiated set of contracts between process participants (in which you agree on interactions, deliverables and business rules - and assume that all these may change during the life of the process) as opposed to flowchart-style workflow/BPM (in which you have to agree on activity sequencing, loops and branch points).

Humanedj includes support for business rules, multi-agent system functionality, speech acts, XML schemas, ontologies, Web services, scripting languages, Web browsing, external document access, dynamic forms,...

It is a free software that is developed in Java as a set of Eclipse plug-ins using the Eclipse Rich Client Platform. It has an open architecture and an open API, making it extensible.

Most technologists in investment banking take ESBs to be hype; one big problem is its close ties to XML and Web Services. XML is not exactly the most efficient way to sent low-latency, high volume messages. Most Java programmers happily code in light-weight frameworks and often wonder what the hype is all about. Application server vendors realising that JEE is not getting them sales are moving into ESBs, the problem is though that they didn't seem to shake off the app server in the process. John will look at some truly enterprise-scale service buses, the architectures and technologies being used to make them investment bank safe.

Increasingly, enterprise applications model persistent datasources as Java classes and develop Business Services that query, manipulate, and persist these objects. However, developing interactive user interfaces that use Business Services to correctly manipulate the data objects requires understanding and coding against complex sets of design patterns and standards that underly the various Service technologies. This proposed specification will define a framework of classes, called Declarative Bindings, that formalize the characteristic interactions between typical UI components and values and methods available on Business Services.

By using the Declarative Bindings set forth in this specificiation, any Java UI rendering technology can declaratively bind to any Business Service. Example UI components and controller technologies include: JSP JSTL tags, JSF, Struts, and Swing. Example business services include SOAP Web Services, EJB Session Beans or any Java class being used as an interface to some functionality.

iText is a library that allows you to generate PDF files on the fly. The iText classes are very useful for people who need to generate read-only, platform independent documents containing text, lists, tables and images. The library is especially useful in combination with Java(TM) technology-based Servlets: The look and feel of HTML is browser dependent; with iText and PDF you can control exactly how your servlet's output will look.

Scripting and dynamic languages are one of the most exciting topics in programming these days. Languages like Javascript, Ruby, Python and others have soared in popularity in recent years, each bringing a fresh, different perspective to the activity of programming. Developers can take advantage of the dynamic nature of scripting languages to bind components together more easily and with fewer lines of code, resulting in higher productivity.

This session will present an open source project code-named Phobos which is is a lightweight, scripting-friendly, web application environment running on the Java platform, aimed at addressing emerging developer requirements. The goal of Project Phobos is to show that Java is an excellent platform for server-side scripting, allowing dynamic-language developers to leverage the power of Java SE and EE.

The initial language that Phobos is supporting on the server side is JavaScript, and jRuby will follow.

Live demo using IDE integration of Phobos projects will be presented, including Ajax support and the ability to debug asynchronous calls from the browser right in the IDE, JPA (Java Persistence API) usage in the context of JavaScript to generate CRUD applications, as well as JavaScript server debugging.

The Apache Harmony project is building an independent implementation of Java SE. Recently graduate from incubation, it's a full fledged project with a rapidly developing codebase and a strong community. The projects main goals are creating a full and compatible implementation of Java SE (starting with Java SE 5) as well as developing a modular architecture for both the Java class library as well as the Java Virtual Machine. This session will briefly cover this history and motivation of the project, provide a status report of the community and techincal issues encountered to date, and demonstate the current state of the codebase.

Change happens. In systems, and with technology and communities. Adapt with it.Jini technology was announced with much fanfare a number of years ago. Since then, despite the fact that a vibrant Community of individual developers and companies have been using the technology to build interesting dynamic, adaptive distributed systems, the technology more or less fell off the radar of most developers. Well... things have been changing in a number of significant ways, and Jini is back on the radar. Let's take a look – we'll do a quick overview of the technology, and then dive into the latest information and changes: open source, collaborative projects, wiki information site, research projects, and commercial uses.
If you're interested in Java -based service -oriented distributed systems which are scalable and evolvable... come have a listen and let's discuss.

The Eclipse platform is a healthy project. The Eclipse development team has consistently hit its projected delivery dates with precision and quality. This isn't possible without a team strongly committed to shipping quality software. How is this really done? This session sheds light on the key practices in the Eclipse development process and outlines proven practices for managing a large project, performed by geographically dispersed teams in a highly dynamic environment. In the context of Jazz, we'll explore ideas about how tools can help teams apply these practices to improve and maintain the health of their projects.

This session motivates, explains and discusses important, popular and successful patterns for Java desktop applications. It describes and compares two approaches to organizing the presentation logic and separating this logic from the presentation. You learn about a 3-tier desktop architecture and get acquainted with basic data binding concepts that help you implement the techniques introduced.

Agile Software development practices according to Scrum and eXtreme programming are more and more known and applied on small projects (team size 6 - 10 people). The question that will be answered during this session is how those practices were applied to a large J2EE development project (60 people) executed by a mixed team of ARDATIS and ACA-IT solutions.

We will brief you about:

    * our 'Ventouris Program' (short introduction)
    * our lessons learned - do & don'ts about
      o customer collaboration
      o test driven development
      o continuous integration
      o refactoring
      o simple design
      o pair programming
      o metrics (velocity & story points)
      o retrospective meetings

Animation and whizzy graphical effects can be totally gratuitous, but they can also be used to make applications more effective and users more productive. This session examines fundamentals of timing and animation and shows techniques for implementing cool effects on Swing components. It also discusses recent advances in combining 2-D and 3-D effects in the Java? Platform, Special Edition (Java SE) 6 ("Mustang") release.

Aranea is a web framework that facilitates Object-Oriented techniques like encapsulation and polymorphism by using POJO components, explicitly managed by the programmer. Aranea is also a full-stack web framework providing both a powerful controller that supports nested flows, and a custom JSP tag library.

This talk however is not so much about Aranea, but about the object-oriented programming techniques applied to the web development. We want to show how usual OO idioms and patterns can make challenging tasks surprisingly simple and how many inherent problems just seem to go away.

We will also discuss the integration facilities that Aranea provides and how it can help to unite the fragmented web framework ecosystem. This will include a live demonstration of integration with Struts, JSF and GWT.

The EJB 3.0 spec defines the ability to apply custom made interceptors to the business methods of your session and message driven beans (and of course to the JBoss @Service and @Consumer beans). EJB 3.0 interceptors take the form of methods annotated with the @javax.ejb.AroundInvoke annotation. This JavaPolis talk by Bill Burke covers this part of the EJB3 spec.

It has often been said that XML and the Java platform are natural complements of each other, yet for many kinds of applications the marriage between these two technologies has proved to be less than completely harmonious. This talk will review the existing means of manipulating XML in Java applications and explore a new approach based upon integrating the syntax of XML documents directly into that of the Java programming language.

The talk covers the most insidious security vulnerabilities in Java Web and EE applications through practical demonstration of how to exploit these vulnerabilities and recommendations on how to prevent them. The threat posed by each vulnerability is explained and strategies for mitigating the flaw are introduced. The talk concludes with a discussion about integrating security at every step of the development life cycle.

The Ruby programming language has exploded in popularity, spurred in part by the agility of the Rails web framework. Rails has in turn changed the way we look at web development. The two together are forcing developers to rethink how applications should be written. The world is changing. JRuby aims to bring Ruby to Java developers and provide an alternative platform for Ruby developers. In this presentation Thomas and Charles explain Ruby and show what makes it great, demonstrate how JRuby brings Ruby to Java and Java to Ruby, explore how JRuby on Rails brings agile web development to Java EE and Java EE's best features to Rails, and discuss the future of Ruby, Rails, and dynamic languages on the JVM.

Kirk has been focusing on performance tuning for quit some years now so for Ted Neward is was very obvious what the interview should be about. Next to performance questions Kirk also explains what the Java Champions program is all about.

A really interesting JavaPolis presentation on how to introduce in a pragmatic way clustering within a WebWork/Spring/Hibernate enterprise application like Confluence. Mike (co-CEO Atlassian) shares his practical experience on how his team has tackled cluster challenges, like how do you setup Lucene in such an environment, what about events, files and much more.

State management has always been a complex and tricky part of web application development. Continuations simplify this and automatically allow you to create a one-to-one conversation between users and a web application. State preservation and flow control no longer need to be handled manually, bringing you back to the simplicity of single user console applications. Remember 'scanf()'?

This presentation will introduce continuations from general principles, followed by practical examples that demonstrate how they
benefit web application development and their frequent usage patterns. Finally, you'll also see how continuations can be used as part of standalone application development. This topic always gives rise to enthusiatic discussion so plenty of time will be allocated for Q&A.

In actual enterprise level applications, either web or services based, it's more and more necessary to have a suite of tests to be executed automatically in order to prevent regressions of the system.
Commercial tools actually available are quite expensive and they often retain high levels of complexity or too high learning curves.
In this session you will be introduced to some mature open source tools, with particular reference to FitNesse for services test and Selenium for web applications test.

Ted Neward interviews Bruno Lowagie about his new book iText in Action, on how to create and manipulate PDF. Bruno is the initial developer and one of the current maintainers of iText, a free Java-PDF library. He works as a developer for the ICT department of Ghent University, Belgium.

Bill Venners, Artima's founder and president, was interviewed by Ted Neward at the 2006 JavaPolis conference. Bill Venners focuses on a range of topics related to Java's evolution, including the question of how to evolve the language without adding more clutter to it.

During this interview Brian Goetz talks about his book "Java Concurrency in Practice" and the Java Performance Myths which he presented at JavaPolis. How much performance tuning should we do and will the introduction of scripting languages to the VM harm speculative performance is just a small list of the questions fired by Ted Neward.

This less technical but nevertheless important JavaPolis talk, gives an introduction to the Java Community Process (JCP) and discusses the proposed JCP changes. Heather also tackles a few questions on how compatibility will be maintained now that Java is open sourced and the impact on JCP.

Ted Neward interviews Java Champion Heinz Kabutz and asks what his favorite features are in Java6, what the Java Specialist newsletter is all about and how much energy developers should take in performance tuning.

Dr. Heinz Kabutz is a Java guru living in South Africa. He consults, holds courses, programs, and - writes a weekly newsletter in which he shares some rather unconventional insights about Java. Things that push the envelope; make Java do things you thought it could not; dirty tricks and such. In other words, stuff you do not usually find in Java periodicals or newsletters.

Ted Neward interviews Java Champion Heinz Kabutz and asks what his favorite features are in Java6, what the Java Specialist newsletter is all about and how much energy developers should take in performance tuning.

Dr. Heinz Kabutz is a Java guru living in South Africa. He consults, holds courses, programs, and - writes a weekly newsletter in which he shares some rather unconventional insights about Java. Things that push the envelope; make Java do things you thought it could not; dirty tricks and such. In other words, stuff you do not usually find in Java periodicals or newsletters.

SOAP launched the Web services revolution, and the new generation of SOAP-based frameworks are finally delivering on the potential of SOAP extensions to support security, reliable messaging, transactions, and more - features that can be crucial to SOA. Yet an increasing number of developers are becoming disenchanted with the complexity and overhead of SOAP frameworks and are choosing easier alternatives, generally in the form of services based on Plain Old XML (POX) message exchange over a variety of protocols. In this presentation you'll see how POX-based services can provide the same functionality as the latest SOAP extensions, and even support inter operation with SOAP through adapters. Wash the SOAP out of your eyes and you'll learn to look at Web services from an entirely new perspective.

During this interview Romain Guy and Chet Haase talk about the status of Swing. their soon-to-be-released Swing book and the future of the Swing eco-system. Questions like the possible impact of XAML, WPF and 3D support within the Swing environment are question that Ted Neward dictates which great interest.

Software versioning is one of the most neglected areas of software development. We're all aware of the need for version control systems in development, but these systems are external to our source code.
How do you write software that withstands the test of time, software that does not have to be rewritten each time you change an interface, software that can still read persisted objects even if they were written by the last version of the application?

This podcast discusses some fanciful futuristic concepts as well as currently useful approaches to writing software that scales over time.

Software versioning is one of the most neglected areas of software development. We're all aware of the need for version control systems in development, but these systems are external to our source code.
How do you write software that withstands the test of time, software that does not have to be rewritten each time you change an interface, software that can still read persisted objects even if they were written by the last version of the application? In this interview Ted Neward talks with Alex Krapf about The versioning problem in the Java space.

The Spring-OSGi project makes it easy to build Spring applications that run in an OSGi framework. A Spring application written in this way provides better separation of modules, the ability to dynamically add, remove, and update modules in a running system, the ability to deploy multiple versions of a module simultaneously (and have clients automatically bind to the appropriate one), and a dynamic service model.

During this interview Eric Evans introduces himself to our listeners and explains in a gently way what Domain-Driven Design (DDD) really is. He also discusses how you can compare DDD to Object Modeling and what he thinks of Naked Objects.

Ted Neward interviews Neal Gafter who talks about the two Closures proposals, how they differ from each other and what kind of problems Closures can solve in the Java language. 'Did the Java language become too complex with the introduction of Generics' and 'How does it feel now that that your java compiler code is splashed in the open' are just few of the questions of this interesting interview.

Version 6 of the Java? Platform, Standard Edition, had just been released at the time of this talk, so Mark Reinhold presented an overview of its key features. Looking ahead to Java SE 7 he'll survey some of the features being considered for that release and explain how anyone in the wider community can get involved in its development.

This talk covers the possible next big thing in SOA... transformations from Legacy systems to SOA (L2S). Dirk Slama, co-author of Enterprise SOA, approaches this topic in 4 major parts: L2S Toolkit, Framework, Roadmap and Community.

The vast majority of SOA works focuses on the upfront challenges and opportunities of new projects and transformational work starting from the very highest parts of the organisation. As with many new technology initiatives however the overall lifecycle challenges are often relegated to being secondary concerns. This presentation argues that some of the most immediate benefits are actually in these post delivery elements and that the correct application of business SOA to existing IT estates can make them easier to manage and become an integral part of the transformation exercise, rather than being a problem to be "wrapped".

Most of the attention around SOA has focused on its application to the very largest enterprises. This focus is understandable - these megacorps are the ones that have the most to gain or lose from a new architecture (and also the biggest consulting budgets) - but it has meant that the issues and requirements of smaller enterprises have often been overlooked in SOA discussions. This is especially true in areas such as governance, where the requirements of the largest enterprises are very different from those of their smaller kindred. Applying SOA guidelines based on requirements that aren't appropriate for your business leads to governance bloat and bureaucracy. In this presentation you'll see how to apply SOA in a more agile fashion to allow small and mid-sized enterprises to gain the benefits of flexible service components without the governance overhead often associated with SOA.

With 17 sponsoring vendors, Service Component Architecture (SCA) represents an important industry initiative to produce next-generation service infrastructure. This talk provides an overview of SCA, focusing on how SCA will impact technology strategy over the next two years. In addition to discussing the evolution of SCA as an industry collaboration effort, the talk covers the key elements of SCA, including assembly and composition, service authoring, and policy. Particular emphasis is placed on how SCA can be used to evolve existing middle-ware investments to take advantage of SOA.

Most large enterprises have launched an initiative to adopt service-oriented architecture (SOA), but SOA is not a solution that comes in a tidy little box. SOA is a new way to design systems, and it is more about culture than it is about technology. SOA will impact many aspects of an organization, from software development and operations to accounting and incentive systems. Without some type of governance program, a SOA initiative will almost certainly spiral out of control. In this session, Burton Group Research Director Anne Thomas Manes will discuss the fundamentals of a SOA governance program.

Patterns are widely accepted as a means to describe common ways of architecture and design. In the book "Server Component Patterns" (Wiley, 2002) we described component-oriented systems like EJBs as a set of Patterns. This talk presents how Spring implements these patterns and illustrates the new approach Spring takes towards components. Also new Patterns in Spring like Exception Translator or Template are presented. This shows the principles Spring uses for the integration of different APIs and makes the design of Spring easier to understand.

Domain Driven Design (DDD) suggests dealing with complex software system using a domain model and preserving the model in implementation. Since domain model entities have rich behavior, so should their software implementation artifacts. A direct mapping between domain model and software artifacts create simple-to- understand, inexpensive-to-implement, and easy-to-evolve systems.

The recently-released EJB 3.0 specification has perhaps been one of the most talked-about technologies that has emerged from JCP for some time. At the center of attention is the Java Persistence API, a lightweight persistence model that acts as a point of convergence for the dominant persistence products currently on the market.

Standardization of persistence inside of the Java EE platform, as well as in the SE environment, will finally provide enterprise applications with the ability to write to one API and be able to run on the vendor of their choice. This talk covers the core concepts of the API and describe how it can be used in applications.

The recently-released EJB 3.0 specification has perhaps been one of the most talked-about technologies that has emerged from JCP for some time. At the centre of attention is the Java Persistence API, a lightweight persistence model that acts as a point of convergence for the dominant persistence products currently on the market.

Standardization of persistence inside of the Java EE platform, as well as in the SE environment, will finally provide enterprise applications with the ability to write to one API and be able to run on the vendor of their choice. This talk covers best practices and common usage patterns of the Java Persistence API in conjunction with a Java EE application server.

If this was buzzword bingo Gregor probably would be an instant winner with his session title. Nevertheless, patterns and service-oriented architectures do have very interesting and relevant intersection points. Both terms are fashionable, somewhat blurry and often abused. Both terms are also very much about architecture and design trade-offs - the softer side of software development.

Despite all the hype, SOA brings alternative architecture styles and programming models into the mainstream. We now write software using process engines, asynchronous message flow, rules engines, transformations etc. Each style comes with a collection of patterns that should be recognized and documented so that we can build effective solutions and discuss design trade-offs outside of specific technology choices and implementations.

Recently, there has been a shift in Web service development towards document-driven Web services. Rather than expose Java classes using RPC exporters, we are seeing Web services emerge which centralize around the Web service message.

Spring Web services (Spring-WS) is a new product from the Spring community that aims to help developing these document-driven Web services. In this talk, we will describe the difference between RPC and document-driven Web services. Additionally, we will talk about the value of:

• Validating requests and responses
• SOAP vs. REST
• XML Marshalling
• Using XPath for data binding

Throughout the entire talk we will show how to implement these concepts using Spring-WS.

In this second part of the SpringOne keynote you'll receive an overview of the Spring Stakeholders like BEA, Oracle, IBM, Alfresco, LogicBlaze and others. Hear how Spring 2.0 is used in the core of the forthcoming WebLogic 9.5 to implement new Java EE 5 features around injection and interception. Rod Johnson also covers, from a high level, the Spring 2.0 features such as simplified configuration, AOP, web, service and data layer and the support for multiple language implementations like JRuby, Groovy and bsh.

Adrian Colyer then continues talking about how Spring and Java EE 5 work together to give you an enterprise development stack. But Adrian also covers potential Spring future features like support for OSGi, SCA, improved management of applications through JMX, further simplification of the JPA programming model etc.

During this first part of the SpringOne 2006 (day one) keynote, you'll hear Rod Johnson give an introduction on how Spring got created followed with some customer Spring references and user's perspectives.

The introduction is followed by a very interesting talk by Nick Masterson-Jones, Director of Information Technology at Voca. Voca processes direct debits, direct credits and standing orders from one bank to another within the UK. With over 5 billion transactions worth 4.5 million EURO in 2005 and close to 100 million complex transactions in 4 hours every day this is without any doubt an interesting Spring case study. Nick Masterson-Jones explains why and how they have used the Spring framework within the financial sector.

This presentation provides developers with a practical approach to security issues typically encountered when developing Spring-based enterprise applications, with a particular focus on Acegi Security. Ben Alex covers authentication, web request authorization, method authorization on your services layer beans, and domain object access control capabilities. The presentation briefly compares two common implementation approaches: container managed authentication (CMA) and Spring/Acegi Security. A sample web application is being used throughout the presentation to illustrate some typical security requirements of enterprise applications.

Ben then migrates this sample application from CMA to Spring/Acegi Security during the course of the presentation.

No previous experience with Spring Security is required to benefit from this presentation, although a basic understanding of CMA and configuring Spring beans would be ideal.

The new Java Persistence API part of EJB 3 (JSR 220) promises to provide a standardized light-weight POJO persistence API for object/relational mapping with support for inheritance, polymorphism and lazy loading that can be used outside application servers. This talk covers Spring 2.0 JPA support, the reasons behind it and will demonstrate how Spring eases JPA development, testing and deployment.

Improving the User Experience without the JavaScript hassle: Ajax, DWR, and Spring Buzzwords like AJAX (Asynchronous JavaScript And XML) and XmlHttpRequest are buzzing around Java blogs for months now. The DWR (Direct Web Remoting) project aims to provide easy AJAX for Java. This session will provide an introduction on using DWR as part of a web application. It will provide insight into the ease of using DWR to add dynamic behavior to your web application, without the hassle of knowing the ins-and-outs of XmlHttpRequest. The focus of this talk will be on DWR in conjunction with Spring. A hands-on example will be used of adding dynamic behavior to a sample Spring MVC application. Furthermore, best practices and dos and don'ts are discussed.

XOM (XML Object Model) is an open source API for processing XML with Java using a streaming tree model. Although it is open source, XOM was implemented using the cathedral model of development (one designer's vision) rather than the bazaar model. This JavaPolis talk by Elliotte explores the design goals, basic API principles, XML principles, Java restrictions and requirements, and testing techniques and tools that have informed XOM's development. In the process, Elliotte identifies some general principles of API design for all Java libraries and systems.

In this talk, Michael Rowley will describe SDO and how it can be used to simplify and unify data access programming. Michael will describe the architecture and APIs that make up SDO and will show several examples.
Simplifying data access has been a perennial issue for Java developers and several technologies have been created for that purpose. Since SDO does not attempt to be all things to all people, there are times when it is complementary to other technologies, while in other cases it competes. This talk will compare code as it looks with SDO to code that uses other approaches.

Phone manufacturers know that developers are looking to create an application that will take the mobile phone market by storm, something that will attract the business user or the private consumer, but why do some applications seem to be more popular than others? What is it that gives one application an edge over another? Are the most successful applications targeting a specific audience or does it span market segments, do they need to stand out to have appeal, or is the success of the application down to the technical specifications and abilities of a specific phone, or is it all a matter of how much marketing money you spend? In this talk, Sony Ericsson will examine several of the key factors that make certain applications more appealing to the mobile phone market than others, including marketing and technical rationales. Mikael Nerde will be examining what is required to make an application successful, as well as elaborate on the types of applications that are not yet created but there might be a market for?

Java has come a long way from being an interesting experiment back in 1999 to what it is today : de-facto, mainstream programming platform for mobile devices. The fact that there are more than 700 million Java enabled devices today is a direct result of this ever-increasing adoption of the Java Platform as 'the' platform for mobility computing. In this talk, you'll receive a quick snapshot of where we are today including a brief discussion of some of the issues that developers are facing such as fragmentation. We will then start to discuss a key initiative from the Java community, namely the Mobile Service Architecture(MSA), which addresses this very issue. We will then dive into the details of MSA, architecture, implementation, etc. We will also discuss in detail, other evolving, next generation mobile java standards such as Mobile Operations Management APIs(JSR-232), which brings OSGiTM standards based, service-oriented, managed and secure computing environment for mobile Java. Srikanth will then take a look at a case study of how these technologies are implemented in Nokia Series 60 platform, and discuss day-to-day issues such as UI programming on this next generation Java platform.

One of the key results of the work on EJB 3.0 has been the introduction of a lightweight POJO persistence model for Java EE. This work on persistence has also been expanded to include use in Java SE environments - i.e. "outside the Java EE container". This talk covers the key aspects of the Java Persistence API, including changes since the publication of the JSR 220 Public Draft. Topics cover include: Brief overview of the developer view of the new POJO persistence model, EntityManager API and entity bean lifecycle, Persistence units and persistence contexts, Detached objects vs extended persistence contexts, Object/Relational Mapping using Java metadata annotations and/or XML and more.

When somebody says "challenging environment", what do you think of? Well, the Formula One environment is really one of these challenging environments. Behind those fast streaking cars there is a complex world made of real-time systems collecting and distributing high-speed data feeds to pieces of software and team engineers that take decisions by the second. This does not occur in the stable, quiet, controlled-atmosphere room in the computing center of a bank, but in a narrow, noisy, hot garage, with extremely busy people moving among flying network and power cables. So it is not unlikely to have the network erroneously disconnected, or a switch that goes unexpectedly off, or a troubled computer that stops working. Nevertheless, real-time data must be still collected and delivered: stop the flow for more than a few seconds and engineers could miss that signal glitch that is warning about an engine failure ? in a word, the race is lost. Last but not least, the whole garage is unpacked and set up every week in a different location of the world. Now you get where the challenge is.

In this JavaPolis conference talk you'll see JasperReports in action by the founder and Architect of JasperReports, Teodor Danciu. JasperReprots is a powerful open source Java reporting tool that has the ability to deliver rich content onto the screen, to the printer or into PDF, HTML, XLS, CSV and XML files. It is entirely written in Java and can be used in a variety of Java enabled applications, including J2EE or Web applications, to generate dynamic content. Its main purpose is to help creating page oriented, ready to print documents in a simple and flexible manner.

As architect and designer of Java tools, demos and several professional Swing libraries, Karsten Lentzsch is considered a leading expert in Java user interface technology and pluggable look&feel. He brings a wealth of experience in designing usable and elegant Java application to JGoodies. This talk describes how to build a Swing application that looks good and works well. We present the most critical Don'ts - things you should avoid, and the most important Do's - guidelines you should follow. You learn about simple steps how to improve the appeareance of your visual design, and how to compete with or outperform decent native desktop applications. Several examples for good and poor design demonstrate the effect of the techniques described in this session.

SAML has emerged as the gold standard for building Cross-Domain SSO solutions and is a key technology in the domain of federated identity management. SAML is being adopted at a fast pace by a growing number of enterprises today, no doubt because of the vast industry support for this relatively new technology, which is no less then impressive. During this talk the basic concepts of SAML will be explained. An executive overview as well as a technical synopsis will be presented. What are SAML assertions, attributes, artifacts, bindings and profiles ? What problems does SAML solve, how does it all work out in real life, what is the SAML producer consumer model etc... But also questions like what is the Liberty Alliance and what is OpenSAML will be answered. Finally we'll have a glimpse at what the future will bring.

Java Business Integration (JBI) is a new Java standard, defining a framework for creating service-oriented architectures (SOA's) using plug-in components. This presentation will familiarize you with what JBI is, and the technical underpinnings that make it work. You'll learn about service-orientated integration, interoperable component models, and how the seemingly simple concept of message exchange patterns is the key to interoperation in JBI. This talk will be of value to two developer audiences: those who are interested in building plug-in components for JBI, and those who are interested in building complete integration or application using a SOA such as JBI-based systems.

During this talk you'll receive an update on WebWork. WebWork is a Java web-application development framework. It is built specifically with developer productivity and code simplicity in mind, providing robust support for building reusable UI templates, such as form controls, UI themes, internationalization, dynamic form parameter mapping to JavaBeans, robust client and server side validation, and much more.

Jason Carreira has been developing and architecting J2EE applications for 5 years. For the last 4 years he's been at Notiva designing and building an enterprise financial software package from the ground up. In his spare time, he is a core developer of the XWork command pattern framework and WebWork 2.0 MVC web framework at OpenSymphony, and has recently released WebWork in Action for Manning Publications.

JDK 5.0 is a huge step forward in developing concurrent Java classes and applications, providing concurrency building blocks for both novices and experts. This talk explores the new low-level concurrency utilities included in JDK 5.0, and examine their features and scalability.

Prior to the release of JDK 5.0, the Java platform provided basic primitives for writing concurrent programs, but they were just that – primitive – and difficult to use properly. In addition to many new high-level concurrency utilities, such as semaphores, mutexes, barriers, thread pools, and thread-safe collections, JDK 5.0 also includes a number of JVM-level enhancements for concurrency, and a set of low-level concurrency utilities for developing highly scalable, nonblocking concurrent algorithms in Java.

Even with built-in support for locking, it has not been practical to develop nonblocking concurrent algorithms in Java prior to JDK 5.0. With JVM support for accessing hardware-provided concurrency instructions (such as CAS) and the atomic variable classes provided in java.util.concurrent.atomic, it is now possible to develop highly scalable, wait-free, lock-free classes in Java.

In addition to the Spring 2.0 Update conference talk, Dion Almaer asked some additional Spring related questions to the founder of the Spring framework Rod Johnson.  During this interview following questions are discussed:  How will the ApplicationContext look different with Spring 2.0 ?  What's happening with Spring AOP and Web Flow in 2.0, and "Where is Spring RCP going ?"

Agile development is a phrase that it appears no buzzword-compliant software development project can be without. However, it is a proper understanding of the motivation and practices, rather than the buzzword conformance, that makes the actual difference in development.

The concept of agility has differing (mis)interpretations and (ab)uses. Sometimes it is used as a synonym for Extreme Programming. By contrast, others use it to mean a generic notion of something that is not quite Extreme Programming, but may borrow ideas from it. Some developers may label a project agile just based on the occasional use of JUnit. Others may use the label to justify not writing any documentation or not agreeing to scope or delivery dates. To be fair, not all uses of the term are cynical or misguided, but the term has lost some of its potency through dilution.

This session begins by revisiting the motivation for agile development, and goes on to explore the wide-range perspectives that are encompassed by approaches that can claim to be agile, including both technical and non-technical aspects, the relationship between agility and architecture, the effect of skill and attitude, the role of organisation, and the support of practices and tools.

During this Vincent Massol interview you'll receive more information on the status, philosophy and strenghts of Maven 2.0.  "What were the shortcomings in Maven 1 and how do we now write maven 2 plugins ?" are just a few questions Dion Almaer asked.  Other topics discussed are Continuum, Cargo and Agile outsourcing and offshoring... check it out.

Spring 2.0 is a major release that makes the Spring Framework both more powerful and easier to use. In this presentation, Rod will survey the new features of Spring 2.0, before focusing on two of the most important: the introduction of extensible XML configuration, and significant enhancements to Spring AOP. Spring 2.0 allows Spring configuration to be enhanced with custom XML tags, which can provide valuable abstraction for repeated or complex configuration tasks. Rod will show how to define new tags, and how this capability will benefit all Spring users. Spring 2.0 makes Spring AOP both simpler and far more powerful, and marks a major milestone for AOP in general. In conjunction with AspectJ 5, Spring 2.0 provides a complete roadmap for AOP usage, from dynamic proxies up to full use of AspectJ weaving, using the same programming model. It becomes possible to use the powerful AspectJ pointcut expression language in Spring AOP, as in AspectJ. Spring AOP can even run AspectJ annotation-style aspects within its proxy based runtime, with the same low cost of adoption as Spring AOP.

In this services oriented interview with Ted Neward you'll get more info on Teds view of XML Services Vs Web Services within a possible generic container. Interesting about Ted is that he has a very comprehensive knowledge of both the C# and Java world. With that in mind Dion asked the following questions: "Can the Java Community learn from the .NET framework and from the Microsoft Web Services Stack?" or "What are the LINQ features (C# v3) that we might see in future releases of the Java language ?". Good stuff, just check it out!

In this short interview Romain Guy, who's still a french student working at Sun, will talk about the Synth look and feel, why he thinks you should use Swing instead of SWT You'll also get more information on the recently released Swing labs (still in beta) and how Romain got this great Swing "job" at Sun. In addition Dion couldn't resist to ask Romain when to use Swing Vs AJAX.

In this podcast provides a guided tour of the new things in the AOP world. It explains new features in AspectJ along with the practical considerations in utilizing each of them. The talk explores the fundamental synergy between AOP and metadata to understand right (and wrong) utilization of metadata-based crosscutting. Load-time weaving (LTW) enables adding aspects to your existing applications deployed in any application server with a minimal effort. The presentation shows how to utilize LTW to improve your productivity considerably, even if you don't yet subscribe to the AOP philosophy and don't want to use AOP in production.

During this interesting interview Brian Goetz explains what was broken in the Java Memory Model and what the fuzz was all about. Get also more info on why Brian is writing a "Java Concurrency in practice" book. "What impact will multi-core CPU's machine have on Java applications ?" or "How can I find and fix concurrency problems?" are, amongst others, great questions Ted Neward asked Brian.

Income growth of workers in any economic sector is directly related to productivity growth. In the past, the productivity of the technology sector grew not because technical workers were becoming more productive, but because technical capability was growing so fast. Unfortunately for the incomes of software development professionals, this is no longer the case. Future income growth will be related to our ability to increase software development productivity. How can software development productivity be increased? Through the same approaches used in operations: a focus on customer value, a short, effective supply chain, healthy discipline, and innovation. This class will discuss techniques that businesses have used for decades to jump-start an increase productivity, and show how they can be used to increase software development productivity.
View the talk here

During this interview Elliotte Rusty Harold explains why XOM was build and what its use cases are. The pain points of DOM and SAX are highlighted and streaming Vs tree-like XML parsing are discussed. Why doesn't he like interfaces and says they're vastly over-used in Java ? What would he change in the Collection and NIO classes and why isn't he impressed by Generics ? Also hear Elliotte's view on the Ruby Array class which last year was heavily discussed based on Martin Fowlers blog post.

"How does Shale fit (with)in Struts?" these are one of the questions Dion Almaer asks Shale developer David Geary during this short JavaPolis interview. David talks about the JSF common gotchas which Shale wants to address and how it compares to Apache MyFaces.

Web services are the building blocks of modern Service Oriented Architectures (SOAs). When used properly, they offer excellent interoperability for an ever-increasing range of enterprise requirements. But before you can achieve the benefits you have to navigate the hazards, starting with basic choices such as REST vs. SOAP and going on to issues of interface structuring, XML Schema compatibility, and service evolution over time. XML and Web Services consultant Dennis Sosnoski gives you the guidance you need to make informed decisions on all these areas, including a look at the capabilities for reliable messaging and transactional operations being added by the new generation of SOAP Web services frameworks. Want to get to SOA? Despite what some vendors say, you don't always need to take a bus...

In this nice interview you'll hear what exactly Joshua Bloch and Neal Gafter do at Google and how Java fits in.
What they like to see in the Dolphin release?
Will we see a second edition of Effective Java?
What does Neal think of project Link?
And what is going on with Neal and frogs?

These are just a few questions which Ted Neward asked the Java Puzzlers.

You can also view this interview (login required)
Duration: 45min

In this JavaPolis keynote you'll receive an overview of the next release of the Java Platform called Mustang (Java SE 6) and some early ideas on Dolphin (Java SE 7). Graham Hamilton, Vice President and Fellow Java Platform Architect at Sun Microsystems, also covers the near future release of Java EE 5 including topics such as AJAX, EJB3, JAX-WS and Microsoft Indigo, JMX, Dynamic Languages and more.

You can also view this talk (login required)
Duration: 47m20s

This presentation shows how J2EE technology was extensively used to build a mission-critical healthcare application and how it achieved the level of integration needed. Using the J2EE technologies such as EJB, Servlets, JSP, JMS, JTA, and JAAS, it was possible to create a robust and high performance application, with a high level of reuse and flexibility...

This presentation explores the values, principles, and practices upon which AM is based and identifies when AM will and will not work in practice. It defines what it means for a model to be agile and presents numerous examples. The concept of agile documentation is described, and a discussion of how modeling is performed in an agile manner on both XP and RUP projects is overviewed...