Demonstrations at ECOOP 2004

D1: Advanced refactorings in Eclipse

Robert Fuhrer, Frank Tip, IBM T.J. Watson Research Center; Adam Kiezun, MIT

We propose a demonstration of several advanced refactorings for Java implemented for the Eclipse IDE ( These refactorings are semantics-preserving program transformations typical of the transformations object-oriented programmers perform manually to improve the structure of existing programs, and promote reuse, clarity, and extensibility.

This demonstration consists of three parts: (i) a review of Eclipse's implementations of several common refactorings, including Extract Method, Introduce Factory and Change Method Signature, described in Fowler's seminal book on refactoring, (ii) a demonstration of generalization-related refactorings such as Extract Interface, which extracts an interface from a class to reduce dependencies on implementation particulars, and Generalize Type, for remediating over-specific declarations, and (iii) a demonstration of Genericize Container Uses, a refactoring in development for migrating uses of standard container classes (e.g. ArrayList or HashMap) to their generic counterparts in Java 1.5 (e.g., ArrayList). This determines the element types that flow into containers, modifies declarations and allocations where possible, and removes casts rendered redundant.

The latter two categories require non-trivial static analysis, and present challenging software engineering usability issues, reflecting complications that programmers face in performing such transformations manually. Therefore, each demonstration will include a brief overview of the technical challenges that the refactoring presents, and highlights of the approach we took in addressing them. In particular, we briefly describe a new piece of Eclipse infrastructure designed to help implement various kinds of context-sensitive and context-insensitive type and pointer analyses for Java.

D2: A web services management layer for the selection, integration and management of web services

María Agustina Cibrán, Bart Verheecke, Davy Suvée, Wim Vanderperren, Vrije Universiteit Brussel

The goal of this demonstration is to illustrate the Web Services Management Layer (WSML), an intermediate layer in between the client applications and the web services. The WSML aims at decoupling client applications from specific web services allowing the just in time integrations of services: new services that were not foreseen at development time can be dynamically integrated into applications. By weakening the link between the client applications and the services, hot-swapping functionality between services can be installed to dynamically swap to other semantically equivalent services in case of unavailability. In addition, this mechanism is extended to consider non-functional properties of services in the selection. The WSML also deals with several client-side management concerns such as caching, billing, accounting, security, etc. We observe that service management concerns crosscut the core applications. At the same time, a technology that can cope with the volatile world of the web services environment is required.

Aspect Oriented Programming (AOP) aims to cleanly modularize crosscutting concerns of a system. In this demo we show how dynamic AOP is ideal to implement the core functionality of the WSML and achieve a clean encapsulation of the service management concerns at the same time as achieving the desired flexibility and adaptability. For the implementation of the WSML the dynamic aspect oriented language JAsCo is adopted.

D3: OptimalJ ― model-driven, pattern-based development

Bastiaan Schönhage, Compuware Europe B.V.

OptimalJ is a software development tool that supports Model-Driven, Pattern-Based development. It is based on OMG's MDA (Model Driven Architecture).

In OptimalJ, the software developer starts with a high-level platform independent model that defines the application from a conceptual perspective . Based on these high-level models, OptimalJ can automatically generate J2EE models, including EJBs and JSPs. At this level, developers can add platform specific knowledge and model the integration with databases or external entities such as webservices or CORBA applications. Finally, based on the platform specific application models, Java code is generated that is used as the basis for the working J2EE application. Since OptimalJ supports incremental development, changes in the models are incorporated in dependent models as well as in the generated code while, of course, leaving the code added by the developer untouched.

In this demonstration, the OptimalJ product itself will be demonstrated to illustrate how OMG's MDA can be implemented in a development tool. Some of the underlying technology and concepts will be discussed. Additionally, we will see how the architecture of OptimalJ allows developers to write their own "implementation patterns" to plug in new technologies based on the available models.