Parleys.com

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.