The software components challenge needs new models and platforms to allow large scale interoperability of components in designing complex distributed applications. Actually, some models exist : Enterprise Java Beans by Sun Microsystems, .Net by Microsoft and the Corba Component Model in the CORBA3’OMG standard. These models and platforms are clearly not satisfactory because of the lack of functional completeness and interoperability. Moreover, the industrial propositions only deal with a lot of technical problems to capture the component software notion, but mainly forgets the needs to manipulate the models of components and applications independently of the technical aspects. This point has been recently tackled by OMG with its Model Driven Architecture (MDA) initiative.We agree that theses points (Component Models, Component oriented Platforms and Model Driven Engineering) lead to new research problems in the goal to produce a better integrated product line from analysis to exploitation for component based applications.

JACQUARD members have a great research experience in two computer science domains related with the goal of the project: Jean-Marc Geib, Philippe Merle and Raphaël Marvie have some important contributions in the Distributed Object based Platforms area, Laurence Duchien, Bernard Carré and Olivier Caron on specifications and use of separation of concerns for complex applications. For example, we can quote the contributions to the OMG standardization work with the CorbaScript language ( proposed to the Scripting Language for CORBA RFP, and accepted as the IDLscript chapter of CORBA3) and with the CCM (Corba Component Model) chapter for which we lead the response group and the revision task force. Other examples are the JAC (Java Aspect Component) platform, one of the leading platforms for dynamic weaving of aspects, and the View Approach for structuring the design of information systems.

We aim to associate theses experiences to design and produce an ambitious new platform for component based complex applications with new methodological and technical traits for structuring the large set of hardly related problems in supporting theses applications. Models, platforms and applications have to benefit from new open middleware using separation of concerns and weaving. Our contributions want to understand how a better structure of models and platforms can give better software for complex applications.

This part of the project deals with the design and the production of new tools for component based platforms. This work was initiated in the Computer Science Laboratory of Lille (LIFL) and is now one of the projects of the ObjectWeb Consortium under the name OpenCCM. Our goal is a full platform for the OMG’s Corba Component Model (CCM). We want to fully capture all the aspects of this norm and contribute to it. Our ambition is to produce the first referenced CCM platform in an open source format. Actually OpenCCM is already a LGL software accessible at http://www.objectweb.org/openccm. Beyond this production we aim to investigate three points as research topics: open the platform to allow extensibility and adaptability, open the run-time containers to weave non functional aspects, and give the capability to freely assemble components in an open environment. These three points are detailed in the next sections. This work are related to other works on open middleware: the Fractal model for component middleware (ObjectWeb, INRIA Sardes project, France Telecom RD),reflexive middleware approaches (Dynamic TAO, Fexinet, OpenCorba, OpenORB), adaptable middleware approaches (ARCAD RNTL project), virtual machines (VVM) and QoS driven Midleware (Issarny).

The OpenCCM project proposes an open framework to produce and exploit CORBA Components. One can specifies such a component in the new OMG IDL3 language with is an extension of the old CORBA IDL2 language. The framework can produce IDL2 schema from IDL3 descriptions, and the associated stubs for various programming languages (Java, C++, IDLscript, …). The framework is itself composed of reusable components around an IDL3 global repository. This architecture is open and extensible. The components are written in the Java language and are also CORBA components, so that they can be assembled to create several configurations. So the platform can be instantiated in several way onto middleware like ORBacus, OpenORB or Borland Enterprise Server.

Current work plans to complete the framework with the Component Implementation Definition Language, the Persistent State Definition Language, and the JORM framework. This will allow the platform to automatically generate containers with persistency capabilities. We work also on the assembly and packaging tools using the XML descriptors of CCM, and we also work on the transformation tools towards C++.

A major goal of component based platforms is to be able to separate functional aspects (ideally programmed by an expert of the tackled domain) from the non functional aspects (ideally programmed by an expert of the computer system techniques). This separation can be implemented by a technical separation between the components (functional aspects) and the containers (non functional aspects). A container hosts components, so that the components inherits of the non functional aspects of the container.

Actually containers (like the EJB or CCM containers) can only contains a limited set of non functional aspects (activation/termination , communications and events, security, transactions and persistency). Theses containers are not extensible neither statically nor dynamically. So they cannot respond to specific needs like fault tolerance, replication, load balancing, real- time, monitoring, …

We plan to design these open containers. We investigate a generic model for containers and the weaving mechanisms which will allow an application to specify particular needs. So an application will be able to reclaim the deployment of well-fitted containers.We work on a specific API to develop non functional aspects for our containers. In a first step we have to specify a great set of non functional aspects to find the way to compose them. Non functional aspects can be seen as interceptors, so we work on composition of interceptors to produce containers. In a second step we will investigate the possibility to dynamically manipulate the containers to change the configuration of non functional aspects.

An open environment for component based applications has to deal with some problems: We have to allow assemblies and deployment on demand. In this part we plan three goals: a virtual machine for programming distributed deployments, a trader of components to realize assemblies from ’on the shelves’ components, a repository to manipulate and drive assemblies of components.

Current middleware propose fixed deployment strategies which are not adaptable to specific needs. These deployment tools are mainly ’black boxes’ and ad-hoc in a particular environment. In the CCM context we can exploit the XML based OSD language which is used to describe assemblies. This is a good basis to describe deployments. But the CCM does not define an API to control the deployment and the associated tools have not be realized for today in an open manner. Actually we work on a set of operations to deploy OSD assemblies. We investigate several useful properties (like optimised deployment, parallel deployment, fault tolerant deployment, transactional deployment) implemented by these operations. This will lead to an open API for adaptable deployment strategies. We plan to use IDLscript to specify the strategies.

Assemblies can be construct on demand with ’Components On The Shelves’. We work on this point with our TORBA environment. Within TORBA we can instantiate components for trading from trading contracts (specified in our TDL - Trading Description Language). This is the basis for an open infrastructure for components brokering that we plan to investigate here.

In an open framework for components we have to manipulate assemblies in all the phases of the design work and also during execution. Assemblies have to be manipulated by various users, each with its own preoccupation (assemble, deploy, distribute, non functional aspects set-up, monitoring, …). We plan to construct a global repository for all these activities. Moreover this repository has to be opened for new activities. In this way we want to define an environment which allow to define, at a meta level, the different preoccupations that we want to exist on the repository. Then the environment will be able to automatic generate a new view on the repository to capture the specified activity. This work will be facilitated by the works on the following topics on the project.

The behaviour of a complex application in an open environment is difficult to specify and to implement because it has to evolve following the context. Changes can occur in an asynchronous manner and the behaviour has to be adapted without human actions and without application stops. A language to specify an assembly of components has to capture these dynamic aspects. A platform which support the assembly at run-time also has to be able to respond to the needed changes. In this part of the project we plan to investigate these two points : new specifications of assemblies to allow the description of dynamically evolving applications, and new platforms to allow dynamic evolution at run-time. The first point is related to Architecture Description Languages (ADL), but these languages often are only focused on static aspects. The second point is related to Aspect Oriented Programming in which one can capture a specific aspect of a behaviour, but AOP platforms are mainly restricted to static weaving and do not allow dynamic manipulation of aspects.

This part of the project wants to enhance specifications of assemblies of components in the goal of designing adaptable applications. We introduce ’integration contracts’ to specify the impact of the components on the application and its context. Our approach is based on AOP to specify connexion and integration schemas. We also work on the JAC (Java Aspect Component) platform to put in work the dynamic weaving of aspects. This is described in the next sections.

Our first goal is to propose enhancements of a component models to allow specifications of dynamic evolution of an software architecture. It concerns three points of view: structural, functional and behavioural points of view. We follow a MDA approach with Context Independent Model and Context Specific Model. We work on some notions like ’composite’ or ’group’ as good levels to specify dynamic interactions between components. Our second goal is to introduce non functional aspects - and then connexions between components and containers - in languages for software architectures. We plan to extend contracts between components to contracts between components and non functional components.

JAC (Java Aspect Compoent) is a framework in Java for programming aspects. Unlike other frameworks like AspectJ, JAC allows dynamic weaving of aspects (aspects can be weaved or un-weaved at run-time) and proposes a modular solution to specify the composition of aspects. A first LGPL on of JAC is present at http://jac.aopsys.com - site of a start-up dedicated to the use of JAC. This version includes aspects for persistency, remote communications, GUI and logging.

Software Engineering helps in increased productivity by reusability. Component oriented design is a recent step towards that productivity. It allow the composition of ’on the shelves’ software entities, while preserving good properties on the software. The composition mechanisms are mainly used in construction and deployment phases, but the modelling phases often are not touched by theses ideas around composition. The MDA approach is a new way to touch the modelling phase with innovative structuring ideas. It promotes the design of computer systems around models and iterative transformations of these models towards the final application. It specifies the use of Platform Independent Models and Platform Specific Models. And finally the MDA approach claims for an automatic process, based on transformations, to product applications from models. This is clearly an innovative way to challenge the design of software engineering tools, but this is an immature process which needs some work to understand the key concepts under this approach.

We want to investigate the idea that model oriented approaches are also a way for increased reusability. It is related to aspect oriented structuring, and design plans like the Views, SOP and Catalysis approaches. Our interest takes place in the use of functional aspects which represent the various dimensions of a tackled domain. We think that the scope of functional aspects can be a basis for structuring system modelling.

Our goal is to ’disconnect’ functional views from a specific domain, and , by this way, to obtain functional components which will be adaptable to various contexts. This is the way to functional reusability. Such a functional component has to capture a functional dimension with a high level of abstraction. Our idea is to specify theses components around a ’required schema’ and a ’provided schema’ . The provided schema should be the result of the component on the required schema. Then the modelling phase can be seen as the assembly of such components by connecting provided schema to required schema. Note that a schema can be more sophisticated that simple interfaces of objects or software components.

In a first step we consider UML like schemas. Then our approach requires the study of assembly constraints at the model level. We plan to use OCL based constraints. Connexions between schemas will often need some adaptations of the schemas.We plan to use transformation tools to realize theses adaptations. This is related to the work of Clarke around composition operations (override, merge, …).We also plan to use MOF mechanisms or UML profile mechanisms to capture the modelling of our components.

Associated with the weaving techniques of AOD, we want to investigate the possibility of preserving the ’functional aspects oriented design’ from the modelling phase to the exploitation phase. We think that the functional aspects can be transformed into software components of the underlying platform. This way gives several advantages: reusability at the modelling phase leads to reusability at the production phase, designers can trace the design work in the exploitation of the application,…So our work can be a contribution to a seamless integration of modelling tools and component based platforms like OpenCCM. This point, preserving functional aspects into applications, was present in our earlier works: ROME, Cocon and Multiview. Finally we plan to introduce the ’functional aspect oriented modelling’ in a Case Tool. We plan to use Objecteering and its profile package. All the aspects of our work (UML profile for functional aspects, OCL based constraints, automatic transformations) will be implemented in the tool.