Sessions

The popularity of open source has been well documented and the reasons for its popularity are fairly well known: no license payments, frictionless commerce - collaborative development of a solution between users and developers speed at which new releases and big fixes are provided - and reduced QA costs. However, we must recognize that open source is still a relatively new phenomenon and the business models and the businesses are still in flux. The questions that we will explore in this presentation are:

• Will open source business models stand that test of time of positive and negative cycles in the economy?
• If you separate out the monetization of open source from the creation of intellectual property, what are the results that you can expect to happen?
• As the big players start to notice open source, what competitive reaction will they take?
• Open source is changing from being an industry value destroying disruptive force into a vehicle for innovation and change. Should the business model change to better reflect this new reality?
• As technologies mature, will open source technologies still be able to move with the agility that they can now or will real world demands of enterprise customers dictating backwards compatibility, long support cycles, etc., result in reduced speed of releases and reduced quantities of value add in each release?

We will explore these questions and more not just from the lens of technology management but also by examining the underlying economics and assumptions that go into the current wave of open source projects.

Most of the successful open source projects developed strong communities long before they had business around them. Despite no money, projects like Spring, Hibernate, Tomcat, etc., created loyal communities. Once the communities were established, the projects became businesses. Conversely, many major traditional software vendors have tried to enter the open source market by providing the source code and throwing money in the form of marketing at their open source projects. In almost every case, these projects have failed to succeed in developing a community. In this presentation, we will explore the characteristics of successful and failed open source projects. We will explore their respective communities to better understand what drove the development of these communities and why other projects failed to gain a critical mass. We will highlight why marketing spend will not create communities and why small independents have an equally successful chance of being successful with open source as the big players. We will close the presentation with a tried and tested formula on how to build successful communities around open source projects.

This workshop takes an in-depth look at the fundamental building block of an Eclipse product - the plug-in (also known as bundle in Open Services Gateway Initiative terms). You will learn, through an end-to-end hands-on exercise, how to use the Plug-in Development Environment (PDE) to create, develop, test, debug and deploy a plug-in. You will then learn the fundamentals of RCP development by creating a minimal standalone fully branded rich client application using the Plug-in Development Environment tooling. Presented by the Eclipse Plug-in Development Environment team, this tutorial is an ideal primer for everyone who is new to Eclipse, Rich Client Platform or plug-in development. Attendees will leave this tutorial with a good understanding of the Eclipse plug-in component model and the plug-in development lifecycle. Attendees will also have the opportunity to ask questions to the people who are response for PDE and will benefit from their expertise in developing RCP-based applications.

This talk introduces the embedded Rich Client Platform (eRCP) project to the developer. To put it simply, the embedded Rich Client Platform project is all about the exploration of taking the well-established Eclipse Rich Client Platform paradigm for desktop applications and moving it to the embedded space. The embedded Rich Client Platform project is currently used in devices ranging from cell phones to PDAs. It also currently supports Windows Mobile and Nokia-based platforms (with support planned for more platforms!). This talk will cover the typical eRCP application development process: (a) Building a simple application (b) Testing on a win32 runtime (c) Deploying on a device (and desktop!). There will be discussions of the application and architecture model before we start a simple coding exercise to familiarize non-RCP developers with the RCP model. Attendees will leave this talk with a good understanding of the embedded Rich Client Platform and how to leverage the embedded Rich Client Platform in their applications. If attendees want to get involved with the project, there will be discussions after the presentation about getting involved in the embedded Rich Client Platform community.

This talk discusses a wide swath of topics, including good citizenship, appropriate messaging between objects, canonicality, reflection & code generation, improving your abstractions via domain specific languages, sacred cows, code generation, common code smells, and anti-objects. The goal is to make you think differently about the code you write every day. No one writes perfect code, and every developer eventually falls into a slump where they just crank out the same code day after day. This talk helps identify your pitfalls and how to avoid them. The session will also discuss Good citizenship, Sacred cows (including getter/setters, test names, and others), Methods & messaging, Canonicality (The Don't Repeat Yourself principle from the Pragmatic Programmer), Mixins and Aspects, Reflection, Code generation, Abstraction upgrade via DSLs, Common code smells (including helper classes, procedural programming, and others), and Anti-objects, with lots of examples. Attendees will learn anti-patterns to avoid in their code and ways around common pitfalls, including bad habits ingrained for years.

Is Service Oriented Architecture the next wave of distributed computing or just the same old crap in a shiny new package? This session provides an overview of what most people agree is the definition of SOA. Neal will talk about SOA, ESB, CORBA, your MOM, and a bunch of other acronyms. This session is a pragmatic look at SOA from a developer perspective, including such (never talked about) topics like transports, granularity, versioning services, transformations, and whether you should be doing this or not. The meat of the talk, however, is details on how to implement SOA, including the evolution from current stovepipes all the way to SOA nirvana. Neal session will also showcase some common implementation pitfalls. SOA can work if you ignore the hype and focus on the real meat: building loosely coupled message-based applications.

Java is dead; long live Java! The Java language is over a decade old, and it's starting to show its age, hampered by both backwards compatibility that it didn't need and the changing world. And I have ample examples! But the decline of the language is offset by the rise of the platform: the Java platform is as robust as ever. This session discusses the coming tend in software engineering, which Neal calls "Polyglot Programming": special purpose, targeted languages running on current virtual machines. We already do this: every application today uses Java, SQL, and Ajax. In the coming years, we'll expand our horizons to start using JRuby, Groovy, Jaskell, and a host of other languages, all targeting the Java VM. This talk discusses why you should expand your current horizons and the tools with which to do it. Neal also talks about practical considerations for implementing multiple languages on the same VM, including lessons learned from the .NET experience. Make no mistake: this style or programming will become mainstream as developers become more overwhelmed by business demands. Come see your future.

Selenium is one of the most powerful functional testing frameworks to come from the open source world in a long time. This session covers all aspects of Selenium, starting from its origins as an internal user-acceptance testing tool through testing Ajax applications. This session covers Selenium functionality, syntax of the test scripts (both HTML and the scripting language), keywords, testing techniques, recording tests, creating extensions, and testing Ajax applications. As Selenium is the premiere testing tool for Ajax, Neal will show you several examples of the power of Selenium combined with Ajax. He will show you how to set up both Test Runner and Remote Control Selenium, including examples of both. Additionally, he will discuss best practices for when you would use one versus the other. Come to this session to see examples of tests written in HTML, Java, and Ruby, and discuss the pros and cons of each approach. Because Selenium is such a good Ajax testing tool, Neal will show several examples of using Selenium to test sophisticated Ajax behaviors (including a Google maps clone). Come see the awesome power of the tool that was named after the chemical that cures Mercury poisoning!

This session explains all the hype surrounding Ruby on Rails, in a context familiar to Java developers. It covers convention over configuration, ActiveRecord, controllers, views, Ajax, scaffolding, testing, and deployment. Find out why everyone won't shut up already about Ruby on Rails! This web framework for Ruby has appeared from nowhere to become the critics darling: there must be good reasons why. This session discusses how configuration works in Rails, persistence through ActiveRecord, scaffolding, controllers, views, and Ajax. It also covers the important topic of testing, and how Rails makes it easy and automatic. Finally, this session discusses deployment and reflects back on the important lessons that Rails teaches Java developers. Ruby on Rails holds important lessons for Java developers, and this framework has already been heavily influential in the entire web arena. During the course of this talk, Neal will not only show how Rails works, but also point out the important lessons Rails teaches us about how to build frameworks.

It is a universally accepted fact that a fundamental process is necessary for a stable foundation. Even nature follows a systematic algorithm, right from the genetic biorhythm to human evolution. The enterprise is not alien to this concept. In fact, a unified process governs the success of an enterprise. However, a common problem in industries is the absence of a process that is aligned with enterprise recommendations and has architecture-centric, technology-driven project delivery models. Most industries adopt an easy and fast Return on Investment (RoI) policy whose theoretical or conceptual foundations are infected and inadequate. This can be remedied with a refactoring of IT strategies, architectures and policies. In this session, Soumen highlights the features of Rational Unified Process and at the same time summarises few of its major limitations. These limitations give Enterprise Unified Process (EUP) the opportunity to provide an exhaustive guideline to extend this process according to enterprise need. In this session you will be introduced to EUP’s features and promises, besides learning more about an enterprise process that aligns the enterprise with its architectural foundations.

Today information systems are no more synonymous with enterprise systems. Now enterprise is a value chain relationship between suppliers, partners, and customers. Meta-information (or models) is one of the key aspects of the new generation enterprise. Harmony, the enterprise classification framework leverages the GERAM, RM-ODP, IEEE 1471-2000, MDA, AOP, ISO 9126 and OMG Reusable Assets Specification framework foundations to classify the enterprise as an extension inheritance and harmonizes the enterprise ecology. This session unravels the beauty of enterprise classification framework that empowers your enterprise utilizing model driven and service oriented enterprise systems development approach. The Harmony classification framework defines the long awaited requirements of a foundation upon which enterprise value chains can be easily integrated. Note: This classification framework is not A Product, It is a success roadmap for today’s enterprise, and it enables real enterprise harmony. Key Points to be covered in this session:

• The CORE (Classify, Organize and Relate the Entities) feature that facilitates wiring the enterprise meta-information together in a robust, decoupled, on-demand enterprise environment.
• Enterprise Life Cycle Refining Process: What is enterprise Life Cycle? Life Cycle versus Life History?
• Enterprise Influences and Harmony Foundation blocks
• Harmony Classification Framework: Why it is the most powerful Enterprise Classification Framework
• Enterprise Architecture Force Fields
• 64 Chambers of enterprise architecture developments
• How does this classification framework populate the required artifacts suggested by GERAM, TOGAF, IEEE 1471-2000, ISO 9126, MDA and RM-ODP?
• How to support MDA and SOA?

Thanks to the dominance of consulting organisations and the influence of several consultants, enterprise architecture has been projected as an artistic story, while it should rather be an art of expressing the enterprise with the help of engineering concepts. Enterprise Architecture should be able to identify the nature of the enterprise, explain the roadmap for success and provide recommendations to help successful evolution of the enterprise. Integration is key to almost all enterprise system development, and” I AM” [Information around Modules] has been replaced with “We ARE” [Wider Enterprise fuelled by Abstracted Reusability Entity value chains]. However, enterprise requires an enormous effort to integrate the value chain verticals across the globe. This includes the enterprise semantic models that address the business dynamics and orchestrate business processes. Enterprise architecture framework and enterprise classification framework can play a vital role in differentiating these increasingly blurred technology stack choices and provide a guided roadmap toward convergence in various aspects. This session demystifies these integration puzzles and discusses how harmony and the enterprise classification framework play a crucial role in the realm of enterprise integration.

One powerful idea sustaining the interest in modularisation is that enterprise software can be developed in parallel, thereby preventing lengthy iterations and resulting in savings in the IT budget of an organisation. This modularisation concept promotes the idea of ‘buy in’. This is why package modules such as ERP and CRM are doing good business, and organisation assets moving towards supplier assets. Modularisation is probably another reason why ISVs are doing well. Modularisation is another driving force behind offshore development and the outsourcing concept. The enterprise is now going through a major technological innovation breakthrough that has completely changed the enterprise game. However, a closer inspection reveals that extracting the right set of enterprise metadata information out of the Houdini's cage shifts the nature of the current enterprise portfolios from components to on-demand services, data to meta-model, and modules to models. Model Driven Architecture (MDA) is a technique for deriving a platform-independent modeling solution, which approaches the ideal of iterative, dynamically evolving, scalable and interoperable enterprise domain abstraction. Meta-information (or models) is one of the key aspects of this new generation enterprise. The enterprise should also be able to seamlessly interact with other enterprises using disparate technology. This session will explain Model Driven Enterprise Architecture development and unleash the power of models that help build robust enterprise architecture.

There are hundreds of criteria for evaluating RIA and AJAX products. So many that it's easy to lose focus and misjudge priorities. This talk proposes a decision tree that leads through an evaluation process. It asks for the most distinctive requirements and product features in a top-down sequence, discussing the essential differences between technology options. The focus is entirely on questions you should answer when evaluating RIA products. There is no assessment of specific products, because the individual features of products tend to obscure fundamental issues. The first question to ask is whether the user interface (UI) of your application is simple enough for HTML. If the answer is yes, then HTML remains the best option because it enables ubiquitous end user access via browser. However, if any of the following features help improve the UI, you should consider RIA technology:

• Partial screen updates
• Asynchronous communication
• Server push
• Widgets supporting direct manipulation
• Multiple coordinated windows
• Modal dialogs
• Menus
• Keyboard navigation

RIA technology provides rich client capabilities in a web infrastructure. The goal is to combine the advantages of desktop applications with those of web applications. There are three fundamentally different technology options to achieve this: JavaScript, Java, and Flash. Their respective core advantages are discussed in this presentation. 

Using Java to build Rich Internet Applications (RIA) has proven its strength for enterprise web applications on the server as well as on the client side. Based on numerous projects, a number of patterns and best practises have emerged. This session presents the most important Java RIA patterns and shows, based on specific real-world examples, appropriate usage scenarios. The session will discuss a number of design patterns that can be employed for the presentation layer, such as state pattern, presentation model, command pattern, half object plus protocol etc. Some of these design patterns ease client-server partitioning, others either support a specific partitioning model or are independent of that. With traditional fat clients it was common to implement both the presentation logic and most of the business logic in the client, leaving just data persistence to the server. Web applications represented a radically different partitioning approach; basically leaving nothing to the client while the server hosted everything from presentation logic down to data persistence. Rich Internet Applications are not constrained to a single architectural partitioning. The client may range from extremely thin to traditionally fat. Before you set out to realize such an application, you should know the pros and cons of these partitioning approaches. This either helps to choose a suitable RIA library, or to make the advantages and limitations of an already chosen library more visible.

Once upon a time, Apache Struts was the undisputed ruler of the Java Web framework land. It was used in almost every Java J2EE web application created. However over the past couple of years, Struts has lost a lot of ground not only in usage but also in mind share. Apache Struts however is now making a comeback, with the new version 2.0. Based on what was earlier OpenSymphony WebWork, Struts 2 hopes to provide a simple yet feature rich solution for Java web applications. Webwork + Struts = Struts 2, an elegant, extensible framework for creating enterprise-ready Java web applications. Struts 2 not only has a great set of features, but will also benefit from having the Apache and Struts brand names that developers have grown to rely upon. There is already growing interest in Struts 2, and once a final version of Struts 2.0 is available, we should see adoption rise quickly. Harshad’s session will look at:

• The origins of Apache Struts 2
• Struts 2 Features and Architecture
• Comparison with Struts 1
• Design Considerations for a Struts 2 web application
• Develop a demo web application that uses Struts 2 framework
• Address the question - Should you adopt / migrate to Struts 2?

Groovy is an agile dynamic language for the Java Platform with many features that are inspired by languages like Python, Ruby and Smalltalk, making them available to Java developers using a Java-like syntax. Grails is an open-source web application framework that leverages the Groovy language and complements Java Web development. Both are rapidly growing in popularity and bring unheard of Rapid Application Development (RAD) features to the Java world. Session Highlights:

• Introduce Groovy. Discuss the origins and need
• Demonstrate Groovy features
• Web development with Groovy: Introduce Groovlets and GSP
• Grails Features and Architecture: Highlights and working of Grails
• Grails Installation
• Developing a sample grails application: A grails application that will demonstrate features and simplicity of the framework
• Customizing Grails for real world applications
• Deploy / Run the application on a J2EE server

Application development today is achieved through the use of numerous tools from software vendors, open source communities and homegrown tools. Getting these tools to work together is an integration problem that has never been solved. Each vendor and open source project creates his or her own API standards and many hours of effort are required to create even the most straightforward of integrations. These integrations are often the most fragile part of the application development infrastructure stack and when they fail they introduce serious productivity reductions. The reason these integrations are so fragile is that it requires every publisher of tools in the Application Lifecycle Management (ALM) arena to keep track of dozens of other publisher's product versions and API standards. With new versions of ALM software products being released every week, this is a daunting challenge. What is needed is a common integration and interoperability framework so that software publishers need only worry about integrating to one point, the integration framework, and to one standard, a web services oriented one. This session will describe in detail how the Eclipse ALF project is solving that problem.

The Application Lifecycle Framework (ALF) Project enables development and IT tools to be orchestrated in support of the consumer’s business needs. ALF provides the logical definition of the overall interoperability business process. This technology handles the exchange of information from one tool to another, the business logic governing the sequencing of tools in support of the application lifecycle process, and the routing of significant events as tools interact. ALF achieves this by providing a common infrastructure (SOAP Web Services, BPEL orchestration engine and the ALF Event Manager), and a set of domain vocabularies that define the events, objects and attributes. Together, these address the issues of tool interoperability and interchangeability, process segmentation, reusability, and versioning. ALF provides various Common Services (logging, notifications, security, etc.) that are easily integrated into BPEL processes to create richer interoperability processes. This session will demonstrate how the framework works and show how easy it is to integrate vendor and open source tools into the framework. Additionally the session will highlight the Eclipse plug-ins for managing the environment.

Building a rich Internet application (RIA) can seem like a daunting scripting task. But since the rise of many frameworks, fall of some and adoption of others, life has become somewhat simpler. That is of course provided one can pick the appropriate Ajax framework and get going with it quickly. In this session, Sangeeta will focus on the GWT framework. Google Web Toolkit (GWT) is an open source Java development framework that claims to help you escape the matrix of technologies that make writing AJAX applications so difficult and error prone. GWT is especially of interest to those with prior Java programming knowledge. The GWT framework allows a developer to write the front end in the Java programming language, and the GWT compiler converts the Java classes to browser-compliant JavaScript and HTML. The session will look at:

• Overview of Ajax and GWT
• What is GWT?
• Build a rich UI Java web application with GWT from scratch
• Modify the application to demonstrate features of GWT
• Useful widgets in GWT
• Why GWT? A quick look at some alternatives

This session will focus on one of the most popular framework for Ajax development, Dojo. Dojo is a library that can be used to build a rich Internet application (RIA) with minimal effort. Dojo is an Open Source Toolkit that is supposed to make your web application development faster, easier and better. Dojo allows you to easily build dynamic capabilities into web pages and any other environment that supports JavaScript. Dojo has one of the widest range of effects and functionality available out of the box. In this session Sangeeta will demonstrate how to best leverage the functionality to develop Rich Internet Applications (RIAs). The session will look at:

• Overview of Ajax and Dojo
• What is Dojo?
• Understanding the basic Dojo architecture
• Build a web application with Dojo from scratch
• Modify the application to demonstrate the features of Dojo
• Forms and other useful widgets in Dojo
• Browser compatibility and other common issues faced in Dojo based Ajax development
• Why Dojo? A quick look at some alternatives.

The internal SOAP processing engine is the core of the Axis2 framework. It provides a powerful extension mechanism, which can be used to add arbitrary functionality to the engine. Compared to its predecessor Apache Axis 1.x, both the engine and its extension mechanism were greatly improved. Many concepts of Axis 1.x can be found again in Axis2, but at the same time new features were added and a few new concepts like phases and modules were introduced. When developing Web Service applications with Axis2, it is essential to understand how the internal messaging processing works and how it can be controlled, extended or changed. This session provides helpful expert knowledge, which will enable developers to efficiently use Axis2 in their projects and to leverage its powerful features. Attendees will learn, how SOAP messages flow through the Axis2 engine, what flows, phases and handlers are all about, how to change the behaviour of the engine, and how to develop and deploy extension modules.

Web services are a rather new technology for many developers, however it's been around for more than five years now. While its ability to integrate systems is one of the key reasons for using the technology, many developers found that it didn’t seem to be that simple to achieve and thereby got stuck with interoperability issues. Even though the profile documents that were published by the WS-I organization have improved the situation significantly, there remains quite a lot of interoperability issues developers have to deal with. Over the past years, a number of best practices and development approaches have been developed that guideline the use of Web service technology. In this session, numerous important expert tips will be introduced, which were gathered in more than six years of professional working experience with Web Services. Following these guidelines, developers will be able to successfully implement Web services applications faster, sailing around most typical interoperability traps.

Data-centric SOA complements "Application"-centric SOA similar to how Computer grid environments are complemented by Data grids. SOA is thought of as a means to integrate legacy applications in a reusable and interoperable manner by wrapping legacy business logic as services accessible from different applications. In most of the cases, until now, it is application business logic or transactions that are being provisioned as services. On the other hand there are a lot of data sources and data centric activities that need to be accessed in a modular and reusable format. These data centric activities have the same requirements as the traditional pieces of infrastructure that have been wrapped up as services. "Data Services" can be utilized to provide service-oriented access to activities like data consolidation, transformation, federation, replication, etc. Some common business problems that need data services include business intelligence, compliance, etc., that are on the top of a lot of Information Technology organizations priority list as requirements from business divisions. This session will go over the assimilation of Data in the SOA world and describe various data services patterns that can be employed for solving Data Integration problems. The session will begin by defining “Data Services” and provide a hypothetical functional architecture. Following that, use cases will be addressed to show the reason why data services are needed in today’s heterogeneous IT environment. At the end, it will go into actual definition and deployment of a data services solution based on a particular use-case.

In traditional application architectures, the design phase in the Software Development Life Cycle (SDLC) plays a critical role in enabling well-architected solutions. Yet there hasn't been much discussion about the design or the modelling phase of SOA-based applications. Translating business requirements into services and service models allows for leveraging services throughout the lifecycle. This also allows for mapping the services to an implementation architecture of the right nature, which could be based on a component model like EJB or a simple database infrastructure. SOA is all about reuse and leveraging existing investments and a model-driven SOA allows for an intersection between requirements established as services and their implementation based on existing infrastructure and new components. This enables the business visibility into IT by making the changes visible in directions, requirements and implementation. This session will describe a hypothetical architecture for Model driven SOA. This will be followed by a demonstration of model driven SOA using a commercial product.

Data Tooling Platform (DTP) project is a top-level project within the eclipse community. The main goal of the DTP project is to provide functional tools and frameworks for developer activities that deal with data sources. Not too obvious is the fact that it’s not just database tooling but also caters to “data sources” of many kinds. At this point the focus of DTP has been on targeting databases as data-sources and their associated activities. Key functional areas of DTP project include connectivity layer, model base and SQL development tools. Model base focuses on creating eclipse modeling framework (EMF) models for the various artifacts associated with data sources, e.g. DB Information, SQL, etc. Connectivity layer relies on Driver Management Framework to describe an extensible way to define drivers used to connect to different data-sources. It also provides an extensible Connection Management Framework to provide entry points to various data-sources and manifests as Connection Profile. As DTP is focusing on delivering support for databases as the supported data-sources for initial release, the last component that has been focused upon is the SQL Development tools. These provide frameworks and tools for editing and debugging SQL code. Key aspect of this is the frameworks that have been designed to allow different database vendors to extend DTP to support their databases and still present the developer a familiar interface across different vendors in the eclipse environment. The goal of the presentation is to enable attendees to familiarize with the DTP project to an extent that they will be able to start using the tool. This session will begin by describing various facets of DTP as explained above. It will be followed by a demo of available functionality in DTP 1.0 release for supporting database development. The session will end by pointing to new functionality that is being targeted for future versions of DTP release.

Mylar's task-focused UI has changed the way that developers work. Current IDEs overload us with tens of thousands of artifacts, and as a result we often spend more time searching, scrolling, and navigating than we do programming. Mylar focuses the Eclipse IDE to show only the information relevant to the task-at-hand. This makes working with large systems much easier and multi-tasking effortless. In addition, Mylar's integrated task management facilities displace the cumbersome browser and email based mechanism of task tracking.

This talk will start with an overview of Mylar's task management features including offline editing, background synchronizations and change notifications, and demonstrate how these work for repositories such as Bugzilla, JIRA, and Trac. Demonstrations of the tool will show you how to get the most out of Mylar's task context management when working with Java, Eclipse plug-in, and web applications. Mylar's context sharing and change set management will then be used to show the tool can make the entire development team more productive by realigning interaction around tasks. The second part of the talk will overview how Mylar’s frameworks can be extended when building IDE, desktop, and server-side applications. The talk will conclude with a showcase of the state of tools built on Mylar that integrate task-focused programming with the various applications and services that make up the developer’s workday.

This session will provide an overview of JSF, specifically focused on comparing concepts with Struts 1.x. More detail coming soon!

This session will provide an overview of Shale, including a comprehensive comparison to Struts. More detail coming soon!

This session will demonstrate alternative approaches to encapsulating Ajax functionality with JSF. It will include demonstrations of various techniques (Ajax-enabled components, jMaki wrapper components, and Project Dynamic Faces). More detail coming soon!

The focus of this session is on answering the question "What can today's IDEs do that would lure even a dedicated Emacs user? More detail coming soon!

This session will provide crisp information on where to put the view, controller, and model tiers, and the technology options (both Java and non-Java) for each approach. More detail coming soon!

Although Eclipse is a well known success in the open source community, what is less appreciated is that it represents the most successful model to date for supporting collaborative industrial development of product-ready technologies. Through open governance, transparent development processes and a commercial-friendly licensing model Eclipse supports a new model for companies to share the cost and risk of technology development. By establishing a rich and open innovation network, the many contributors to Eclipse are changing the dynamics of the software industry.

Eclipse has grown from a few projects in 2001 to more than 60 projects in 2006, and the number of projects is still growing. Many consumers of the Eclipse technology typically rely on a stack of different components that they extend with their own components. Until the Callisto simultaneous release in June 2006, feature and release panning was not synchronized between projects - integration and testing was time consuming and costly.

With Callisto, the consumers received a stack of 10 projects that were planned and released simultaneously.
We will discuss the benefits of Callisto for the Eclipse Eco System as well as the lessons learned from the year that lead to Callisto. We will also look into the future and discuss what the Europa release in 2007 will hold for the Eclipse community.

Knowledge workers are overloaded with so much data that they often spend more time looking for information than they do getting work done. The Tasktop is an Eclipse Rich Client Application that brings the benefits of Mylar’s task-focused interaction to a large range of knowledge work activities. The Tasktop plug-ins can be used by programmers to integrate Mylar with their desktop applications and web services in order to reduce information overload and bring focus to their entire workday. Managers can install the standalone Tasktop in conjunction with their issue tracking or project management repository of choice in order to streamline the team’s collaboration around tasks. The Tasktop leveraging the openness and extensibility of the Eclipse and Mylar and frameworks in order to re-align knowledge work around tasks. In a similar way to how the Mylar developer tools are transforming the productivity of Java programmers, the Tasktop is set to bring about a fundamental improvement in the productivity and working conditions of knowledge workers worldwide.

This session takes a detailed look at the architecture of Java object- relational mapping solutions, focusing on differences among the three primary open source competitors in the JPA space: TopLink, Hibernate, and OpenJPA. Topics to be discussed include query language approach, performance options, byte-code enhancement, persistent object caching strategies, persistent fields versus methods, and persistent identity

This session looks at the rationale for object-relational mapping in the Java application development space. Are you comfortable discussing "impedance mismatch", "domain object modeling", "byte-code enhancement", "container-based persistence", "pojo persistence", "inversion of control", "native query", and "drop into SQL" with your peers? Are you aware of the productivity and quality improvements made possible by object relational mapping? Come to this session on Java Persistence and get answers.

The provision of transactions and transactional safety is one of the most important features of today's information systems. Using Web services not only as a way for a SOAP-based point-to-point integration, but in terms of a real service orientation, it is quite clear that these interaction scenarios have to be secured under the terms of a transaction. The provision of solutions for this topic sets one of the major challenges on the way to realising real service oriented application scenarios. The focus of this session therefore is on transactions and special conditions for those in loosely coupled environments. Based on a more theoretical view on this topic, an introduction into the WS-Transaction specification (which is now under the control of the Organization for the Advancement of Structured Information Standards) will be provided to point out how to achieve transactional safety for Web services, and therefore applications which provide functions based on a composition of several services.

With so many WS specifications and standards out there, it is not surprising if you decide to exclude Web service technology from your software implementation. This session will search for answers to the question on whether there is a deeper truth in this bias or not. The focus will be on boards, organisations and enterprise consortiums as well as their intentions and influence in the “world of Web services”, shortly: a who is who in Web services will be presented. Furthermore, this session will also take a closer look at the structure of Web service specifications as well as point out the importance of several specifications and how they are organised.

Choosing the right framework constitutes an important part of today's design decision when it comes to providing persistence on the level of objects. More so, future applications are required to be programming language and platform agnostic. This is what the idea of the so called Service Oriented Architecture (SOA) is all about. And this is exactly where the problem starts. In new environments, based on the principles of the SOA, the decision of how to provide persistence is not only restricted to choosing the best framework (matter of factly, there is nothing available at all). This session will provide an overview of the today's handling of persistence aspects in service-oriented architectures and to discuss some necessary aspects that have to be solved for the future.

Test first development is a top-down process by which code is written starting with tests. Once tests have been created, the process changes to that of making the tests work by implementating the application code. In this presentation, we demonstrate how Eclipse support for JUnit facilitates test first development in the context of creating Java and Java EE applications, as well as test first development of Eclipse plug-ins themselves.

It is always beneficial for a project to define a clear and cycle free software architecture. But how can you fight growing deviations with the planned architecture and the physical code base? how can you avoid expensive redesigns and refactoring phases? How can you achieve an outstanding technical quality of your code base? The section explains the basics concepts of architecture management for java projects. By applying architecture management on your project you can avoid otherwise unavoidable deviations between your architecture and your code base and dramatically increase the probability of success for your java project.

Wouldn't it be good if we could always implement requirements using the vocabulary in which we naturally talk about them? In this session, Vishal Puri will describe the new AOP support in Spring 2.0, how it integrates with AspectJ, and how it fits in the construction of enterprise applications. Using an example-driven approach, attendees will learn how to simplify the implementation of many common enterprise application requirements. The way you think about software may never me the same again.

Spring 2.0 is a major new release of the Spring framework that takes POJO-based development to a new level of sophistication. The themes of Spring 2.0 are simplicity and power: it makes existing tasks even easier, while extending the power of Spring to new areas. In this session, Vishal Puri will explain a number of the important enhancements and new features, including XML extensibility features, allowing "custom tags" to extend the capabilities of Spring configuration, significant enhancements in the Spring AOP framework, making the powerful AspectJ pointcut expression language available in the Spring runtime and First-class support for dynamic languages such as Groovy and JRuby, as the Spring component model becomes cross-language. Last but not the least he will talk about the integration with the new Java Persistence API standard for O/R mapping.

Sequence diagrams are one of the best ways for documenting the flow aspects of an application. The value of a sequence diagram can be significantly enhanced if it can be associated with other project aspects. For example use case or performance information can not be fathomed with today's tool from a sequence diagram. Though most of the times the sequence diagram tries to address concrete use cases and profilers do try to aggregate information at a flow level but currently no tool tries to provide an easy way to inter relate this information. Also the usual approach of maintaining a different modeling tool, which is insulated from the development tool causes sequence diagrams to soon get out of date. This session discusses an approach to compile the information from Eclipse projects and present the same on a Sequence diagram.

Even as Modelling is an integral part of the Eclipse platform with EMF, the visual synonym has not been dealt with the same thrust. Particularly in terms of how to persist the visual view of any realized model. Frameworks like GMF makes up for this by providing additional meta-information schema to persist visual annotations. This, however, is restricted to the usage of tools that make use of the GMF runtime. GMF's intention was to use the XML MetaData Interchange for Diagram Interchange, but wasn't able to take that approach as the specification were not ready in time. Visual notation commonness would enhance the portability of diagrams across various products following similar standards. Moreover, will help adhere to specifics used world over similar to UML today. The Model Development Tools project of the Eclipse communities targets to set forth certain attempts to standardize the same. In this session, we will present an approach for the visual meta-data management that could be used in any modeling tool development project. We put forward a subset of the framework that would enable graphical tooling utilizing your own modeling elements.

SOA is now embedded deep into application infrastructure and architectures considerations today. SOA adoption is typically seen as a top-down decision- decided at the enterprise level and then adoption across all applications. For successful adoption though, the individual applications in the enterprise also need to be ready for SOA. This implies that for inbound access, the service facades exist and for outbound access, there is a well-defined coarse-grained integration layer. The SOA readiness can be established regardless of the enterprise wide platform in place nor any need for SOA in the organization. An application can build SOA within, in a much-localized context. IN the short term this results in a better structured design, and in the medium term the application can easily plug-in into any SOA infrastructure. Such flexibility in SOA readiness is very critical for ISVs building generic solutions.

Java EE can be effectively leveraged for building SOA into individual applications. The facades and integration are the key components. This integration layer must be at the top rather than the conventional JCA based solution that is at the bottom- at the same level as Database accesses. This fundamental shift in paradigm can result in individual applications adopting SOA in isolation and being ready for enterprise SOA. This session discusses how J2EE enables such Bite-Sized-SOA. While SOA is the fabric across the organization, Web2.0 is at the fringes providing a rich user experience while accessing various resources over the web. Somewhere in the middle, is Java EE. In its incumbent capacity as a leading applications infrastructure platform, it comes in the path of both Web2.0 and SOA. Java EE also enables usage patterns where the SOA services can be accessed from AJAX like rich Web2.0 clients.

This session explores how Java EE snugly fits in, and establishes a few usage patterns for SOA adoption, centered around JEE and individual solutions. Specifically looking at "readiness" approaches for individual applications. Introducing the concept of Bit-sized SOA

JSR 168, the first version of the Portlet API, defined standards for the expected behavior of portlets and portlet containers. However, the fledgling specification lacked clear definitions in key areas of portlet and portlet container behavior. As a result, developing real world applications in JSR 168 almost always requires going beyond the specification to fulfill business requirements. JSR 286 improves on the JSR 168 spec by providing for inter-portlet communication, eventing, portlet filters, and more. This session will discuss some of the topics related to the JSR286 (except confidential aspects) and cover real world examples where the new definitions might make development easier than with JSR168.

The Server Side, JavaLobby, and other developer communities are notorious battlegrounds for the perpetual wars over which programming framework reigns supreme. Yet at the end of the day, technology is just a tool to be used to get the job done, and different problems are best addressed with different tools. The success or failure of a project more often depends not on the tools used, but whose hands they're in. This session will discuss the various strengths and weaknesses of these three popular platforms. We will also see how Liferay, an open source Java portal, can be an aggregator of portlets using different technologies, including Java, Ruby, and PHP.

The Gartner Group predicts that by 2008, 80% of development projects will be related to service oriented architectures. BEA, IBM, and others are pouring millions into marketing around their software's readiness to take on the crucial task of providing a SOA. But are there open alternatives? This session will showcase the Liferay architecture, including the exposure of services via EJBs, Spring, JSON, and SOAPWeb Services to facilitate the rapid deployment of composite applications in an SOA context. Also highlighted will be integration with the Apache ServiceMix enterprise service bus (chosen for its compatible license), and Liferay's leveraging of the JBPM Workflow engine.

What does it take to write a full fledged graphical editor with all the bells and whistles? not much! that is, if you use GMF. Graphical Modeling Framework (GMF) provides infrastructure for creating rich graphical editors with minimal effort. It neatly bridges the modeling capabilities of EMF (Eclipse Modeling Framework) and the graphical editing capabilities of GEF (Graphical Editing Framework). In this session, I will walk you through the various steps in developing a graphical editor using GMF. We will consider a simple use case for a graphical editor, starting with a domain model, adding graphical & tooling definitions and finally tying everything together to generate a fully functional graphical editor.

This Session talks about Oracle and Eclipse shared vision on tooling and also provides insight in to latest toolkits that Oracle contributed to Eclipse community for developing application on Oracle Fusion middleware, such as: (i)JavaServer Faces Tooling, to simplify development and deployment of JavaServer Faces (JSF) applications by providing an extensible tooling infrastructure and exemplary tools for building JSF-based Web applications;(ii) Eclipse Link : Eclipse Persistence Platform project in Eclipse that will deliver a comprehensive persistence platform;(iii) Dali JPA Tools, to support the building of extensible frameworks to simplify, define, and edit Object-Relational (O/R) mappings for EJB 3.0 Java Persistence API (JPA) Entities; (iv) BPEL Tools, to add comprehensive support to Eclipse for the definition, authoring, editing, deploying, testing and debugging of WS-BPEL 2.0 processes.

As enterprises evolve their IT infrastructure there is a trend towards consolidating applications and services into centralized data centers. This is primarily motivated by the operational ease and flexibility in such a centralized design. There is also an associated trend of outsourcing applications using the SaaS (Software as a Service) model that is motivated by economic and operational benefits. At the same time, the users of these applications, namely employees, business partners and customers are becoming more and more decentralized. They are accessing applications from remote offices, business partner’s offices, roaming laptops, Internet kiosks, mobile devices, etc. Each of these access locations has different security and network performance characteristics. Notwithstanding these trends, there is an expectation that IT provides access to all application and services in a high-performance, consistent and secure manner, no matter where the applications are hosted and no matter from where the users access them. Many security products address the needs of secure access to applications from any network. There are also several products that address optimized application access over WANs with varied performance characteristics. However, to provide a complete solution IT needs to blend both the security and performance needs of these applications and be able to work with the wide set of application protocols in use today. This presentation goes into the issues and challenges faced with creating a secure and optimized multi-protocol application delivery infrastructure.

JBuilder 2007, built on top of Eclipse, provides so many new features that it can be a little daunting.

From code and design Audits and Metrics, Visual EJB, JPA and Web Services development, automatic conversion of descriptor-based EJB 2.1 code to an x-doclet or annotations-based solution, LiveSource UML Class diagrams, the deep-IDE integration of open-source lifecycle tools provided by TeamInsight, all the way to the developer profiling and debugging capabilities in OptimizeIt, it can get difficult to keep track of all the features.

Rather than drowning you in PowerPoint and presenting you one feature after another out of context, this session will take a different approach. We'll start with a real-life Java project and work through a simple development scenario, using many of the different JBuilder features along the way

By the end of the session you will have seen the main features that JBuilder adds on top of Eclipse "in action", and have a much clearer understanding of the value JBuilder 2007 provides to developers.

This session will explore the contemporary expectations of Web applications and how Ruby on Rails helps to meet these expectations in less time and with less code compared to other technologies and strategies. While explaining the features and capabilities of Ruby on Rails, we will also discuss the unique benefits and challenges presented by the philosophy and techniques employed when invoking its special kind of magic. In conclusion, we will demonstrate how CodeGear’s Ruby on Rails IDE overcomes these unique challenges by providing a comprehensive development environment which is specifically targeted at the Ruby language and Ruby on Rails framework, thereby enabling developers to be even more productive when using these wonderful bits of technology.

What Java IDE are you using? What capabilities are most important to you? What tools can help you be more successful in your Java programming? What is your choice of framework for your Java IDE (Eclipse, NetBeans, proprietary, programmer's editor, none)? This keynote will take a look at the past, present, and future of Java Integrated Development Environments. The keynote will explore modern Java IDE support for coding, UML modeling, visual editors, refactoring, debugging testing and performance tuning, code analysis (audits, metrics, securify), enterprise Java development, Web and Web Services support, build systems, team and peer collaboration, open api and plug-in architectures, platform support, open source, localization, and more. The keynote will also present a prescription for future IDE capabilities required to meet the deveopment demands of tomorrow.

Automated functional testing is a key technique that allows complex systems to rapidly evolve without regressing. When a system grows, and the amount of functionality that the system offers also grows, so does it's test suite. After a while, a test suite can become as large and as complex as the system that it tests. Maintaining large test suites needs the same kind of concepts and principles that enable development teams to tackle complexity - concepts and principles such as design, refactoring, reusability, and abstraction. This talk covers the issues involved with the functional testing of applications that change - moving targets that need new techniques for testing them.