JACQUARD is a joint project between INRIA, CNRS and Université des Sciences et Technologies de Lille (USTL), via the Computer Science Laboratory of Lille : LIFL (UMR 8022).
The JACQUARD project tackles the large problem of designing complex distributed applications, i.e. composed of numerous cooperative and distributed software components which are constraint by various requirements like persistency, security, fault tolerance. We want to illustrate the capability of software engineering to produce new component oriented platforms and new methodological and technical traits to design and exploit these applications. We explore the use of component models, separation of concerns and weaving in the different phases (model, design, assembly, deployment, and execution) of the application's life cycle. We goal to produce fully functional platforms and tools, in relation with standardization organisations like OMG, and with the open source software world.
One of the first historical steps towards programming appeared in 1725 on a weaving
machine
But History keeps in mind Joseph-Marie Jacquard who creates and commercialises the first automatic weaving machine during the beginning of century XIX. The machine was so precise that J.M. Jacquard designs a program that weaves his own face on a fabric. J.M. Jacquard innovations have greatly contribute to first steps of computer science with the perforated cards to support programs. The idea of independent programs for a programmatic machine was born!
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
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
We aim to associate these 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.
For the next four years the projects goals are:
- Produce a full platform for the CCM model. This platform, called OpenCCM, has to contribute to the OMG standardization work. Moreover it will provide new adaptable containers allowing the weaving of system aspects, dynamically following the application requirements. It will also provide an integrated environment to manipulate, deploy and exploit assemblies of components.
- Produce a methodological and technical environment to specify theses assemblies of components using aspect oriented design, via a dedicated modelling tools for assemblies and a dynamic aspects oriented platform (in a next step of our JAC platform).
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
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, ...)
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 inherit of the non functional aspects of the container.
Actually containers (like the EJB or CCM containers) can only contain 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
Assemblies can be construct on demand with 'Components On The Shelves'. We work on this
point with our TORBA environment
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
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 supports 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)
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'
JAC (Java Aspect Components) is a framework in Java for
programming aspects
We plan to extend the current version to new basic aspects for distributed programming. We plan also to integrate JAC in an UML based CASE tool to promote Aspect Oriented Design. In a second step we plan to evolve JAC towards Component Oriented Programming. JAC will produce component and containers (like in the EJB, CCM, Web Services or Fractal models).
Software Engineering helps in increased productivity by re-usability. Component oriented design is a recent step towards that productivity. It allows 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 these 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
re-usability. It is related to aspect oriented structuring, and design plans like the Views,
SOP
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 re-usability. Such a functional component has to capture a functional dimension with a high level of abstraction. Our idea is to introduce the notion of 'model components' parameterized by a 'required model' and that produce a 'provided model'. Then the modelling phase can be seen as the assembly of such components by connecting provided model to required model. Note that component ports (specified by a model) can be more sophisticated that simple interfaces of objects or software components.
In a first step we consider UML like models. Then our approach requires the study of assembly constraints at the model level. We plan to use OCL based constraints. Connections between models will often need some adaptations of the models. We plan to use transformation tools to realize these adaptations. This is related to the work of Clarke around composition operations (override, merge, ...). We are exploring the UML template notion in order to compare it to our model components. Our present work shows that the UML specification needs to be extended in order to make templates parameterizable by complex models. We are defining a set of constraints which formalizes this extension.
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 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: re-usability at the
modelling phase leads to re-usability 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 or EJB. This point,
preserving functional aspects into applications, was present in our earlier work on CROME
We identify some structural patterns which allow to target functional decomposition onto component platforms.
Finally we plan to introduce the 'functional aspect oriented modelling' in Case Tools
( UML Objecteering and Eclipse UML2 plugin).
A first result is the specification and realization of a UML profile which allows to describe view components.
These view components can be connected to different base models according to 'design and connections' rules.
An Objecteering module is available at
OpenCCM stands for the Open CORBA Component Model Platform: The first public available and open source implementation of the CORBA Component Model (CCM) specification defined by the Object Management Group (OMG). The CORBA Component Model (CCM) is the first vendor neutral open standard for Distributed Component Computing supporting various programming languages, operating systems, networks, CORBA products and vendors seamlessly. The CCM is an OMG's specification for creating distributed, server-side scalable, component-based, language-neutral, transactional, multi-users and secure applications. Morover, one CCM application could be deployed and run on several distributed nodes simultaneously.
Then OpenCCM allows you to design, implement, compile, package, assemble, deploy, install, instantiate, configure, execute, and manage distributed CORBA component-based applications.
See at
JAC (Java Aspect Components) is a project consisting in developing an aspect-oriented middleware layer. JAC current version is 0.11. Current application servers do not always provide satisfying means to separate technical concerns from the application code. Since JAC uses aspect-orientation, the complex components are replaced by POJOs (Plain Old Java Objects) and technical concerns implementations that are usually wired deep into the containers implementations are replaced by loosely-coupled, dynamically pluggable aspect components. JAC aspect components provide: seamless persistence (CMP) that fully handles collections and references, flexible clustering features (customisable broadcast, load-balancing, data-consistency, caching), instantaneously defined users, profiles management, access rights checking, and authentication features.
See at
>From the beginning of the project, a lot of efforts has been put on the design and implementation of OpenCCM, our Open CORBA Components Platform. Currently, OpenCCM is composed of five independent and complementary parts: The production tool chain, the packaging and assembly tool chain, the distributed deployment infrastructure, the container runtime framework, and the management framework.
The OpenCCM production tool chain allows users to design, define,
implement and compile CORBA components. This tool chain is based
on a component-based modular and extensible architecture
The heart of this architecture is the OpenCCM Interface Repository which is the runtime reification of the CORBA Components meta model. This repository stores meta data reifying component types and all other OMG IDL/PSDL/CIDL constructions. This meta data repository provides application programming interfaces (API) conform with the OMG specification of the CORBA 3.0 Interface Repository. Then a set of front-end compilers and back-end generators are connected to this repository to feed and visit it respectively.
On one hand, the OpenCCM repository is fed by several front-end compilers
for the OMG Interface Definition Language 3.0 (OMG IDL) allowing the design
of component types, for the OMG Persistent State Definition Language (OMG PSDL)
allowing the design of persistent states, and for the OMG Component Implementation
Definition Language (OMG CIDL) allowing the design of component
implementations. Moreover, OpenCCM contains also a front-end compiler
for the OMG UML Profile for CORBA Components allowing users to design
component types and implementations from a UML tool. This latest
front-end is built following the OMG Model Driven Architecture (MDA)
approach. A UML repository is built from the UML meta model thanks
to the ModFact tool (a OMG MOF repository factory) developed by
the LIP6 (
On the other hand, the OpenCCM repository is visited by a set of back-end generators for producing the CORBA Components client and server equivalent OMG IDL 2.x mapping, OMG PSDL related Java interfaces and implementations, OMG CIDL related Java container code, Java templates for implementing CORBA components, and finally pretty-printers for OMG IDL 3.0, OMG PSDL, OMG CIDL, and XMI UML. Back-end generators for XML descriptors defined by the CORBA Components Specification are planned for next year. Most of these generators are designed as MDA model transformations, especially those generating Java code. Here a Java repository has been built to reifying Java interfaces and classes to generate. Then various specific transformations visit the OpenCCM Interface Repository and feed the Java repository according to the Java code to generate. Finally a general transformation visits the Java repository in order to generate Java files.
One main advantage of the OpenCCM production tool chain architecture
is its modularity and extensibility allowing users to add new front-end
compilers for other component design notations (e.g. Architecture Description
Languages, Platform Independent Models, Domain Specific Languages, etc), and
to add new back-ends to generate new output files like documentation, C++ code, etc.
Currently, this modular and extensible OpenCCM production tool chain
architecture has been validated by external users. For instance,
the OpenCCM tool chain is embedded in the PERCO platform developed
by THALES Communications, and in the open source Cadena tool developed by the
Kansas University (
The OpenCCM packaging and assembling tool chain allows users to package
and assemble CORBA components. From the users' point of view, this is a
graphical stand-one packaging and assembling tool allowing the edition
of CORBA component and assembly ZIP archives and all CORBA Components
XML descriptors. Internally, this tool is built with our Appolon
software framework (
The OpenCCM distributed deployment infrastructure allows users to deploy, install, instantiate, configure, and interconnect CORBA components in order to build CORBA component-based distributed applications. This infrastructure takes CORBA component and assembly ZIP archives as input and interprets their XML descriptors in order to set up the CORBA distributed applications, i.e. download component binaries on target nodes, create required CORBA components servers and containers, install CORBA component homes into containers, create CORBA component instances from CORBA component homes, configure CORBA component properties, interconnect CORBA components via their ports, register homes and components into the CORBA Naming Service and the CORBA Trading Service, and finally start the created CORBA components.
The OpenCCM distributed deployment infrastructure is built as a CORBA component-based distributed application which implements the deployment API defined by the CORBA Components Specification and provides new supervision and management features. The main CORBA components of this deployment infrastructure are the DCIManager reifying a deployment domain (e.g. a local network), the NodeManager reifying a virtual node where CORBA components could be downloaded and instantiated, the ComponentServerManager reifying a CORBA component server where containers could be created, the ContainerManager reifying a CORBA component container where homes could be installed and components created, the AssemblyModelManager reifying an installed CORBA component assembly, and the AssemblyManager reifying a running CORBA component assembly. The main goal of this latest component is to implement the distributed deployment process: It schedules distributed deployment operations according to XML CORBA Component Assembly descriptors. As the OpenCCM deployment infrastructure is a set of CORBA components, it is possible to create various deployment infrastructure architectures by defining various assemblies of the previous described components. Moreover it is possible to deploy a basic deployment infrastructure and then use it to deploy more sophisticated deployment infrastructures which will meet application specific requirements.
Finally as the possible OpenCCM deployment infrastructures are composed of CORBA components running into CORBA containers, then this is possible to inject non functional properties like persistency, transactions, security, etc. into the distributed deployment process. Currently, we have experimented transactional distributed deployment which allows us to automatically rollback deployments when failures are detected, e.g. deployment errors, network and node crashes, etc. Our future perspectives are to experiment the injection, into the distributed deployment process, of some new non functional properties like access control security to control that deployments are only done by authorized persons, and various deployment scheduling policies to inject flexibility and parallelism into the distributed deployment process.
The OpenCCM container runtime framework allows to host and execute CORBA components, and inject non functional properties thanks to containers. This runtime framework is built on top of the CORBA 2.4 features, i.e. Object Request Broker (ORB), Portable Object Adapter (POA), and Portable Interceptors (PI), and on top of standard CosNaming, CosTrading, CosTransactions, and CosPersistentState services.
The runtime library currently implements session containers and it is composed of a set of Java classes inherited by Java container code generated by the OpenCCM production tool chain. Moreover, a flexible and extensible container model and architecture has been designed to allow us to build new containers supporting new services as logging. The container services are designed as software components exposing clear external interfaces, they can be packaged and deployed. Then a new container is dynamically built at deployment time by assemblying several container service components.
Related to the persistency service, we have implemented the CORBA Persistent
State Service (PSS) on top of the Java Data Objects (JDO) technology.
This allows us to run the persistency service on top of various JDO implementations,
currently the Kodo commercial product (
Related to the transaction service, we have initiated a new research
collaborative activity inside the ObjectWeb community. This
new activity, named GoTM (
The OpenCCM management framework allows users to discover, introspect, manage, monitor and reconfigure CORBA components dynamically at runtime. >From the users' point of view, this is a graphical stand-one management tool allowing the exploration and management of the OpenCCM Interface Repository, of the CosNaming and CosTrading services, of all the components of the OpenCCM distributed deployment infrastructure, and of any application specific CORBA object, home, and component. Internally, this tool is built on top of a generic software framework for building graphical user interface management browsers. This framework is extensible by plug-ins. A plug-in is described by a XML file and contains a set of Java code implementing API defined by the browser software framework. The XML files allow users to configure how to navigate on and display objects and to set up which menu items are associated to objects. This browser software framework has been experimented in several contexts: The OpenCCM browser, the OpenCCM packaging and assembling tool, the Fractal browser and the GoTM browser. In the context of OpenCCM, this framework allows us to provide generic management capabilities, and users could add their own application specific management features.
Finally, all the previously presented OpenCCM features are supported on a large set of environments: Java 1.2.1, 1.3.x and 1.4.x environments ; Linux, Linux for PDA, MacOS X, Solaris, Windows 2000/NT/XP and CE for PDA operating systems ; and Borland Enterprise Server (BES) 5.0.2 and 5.2, IONA ORBacus 4.1.x, JacORB 2.0, and the Community OpenORB 1.2.1, 1.3.0, 1.3.1 and 1.4.0 CORBA implementations.
Since the beginning of the project, two new research directions have been followed and lead to the following set of results.
Many systems in safety critical areas use replication of vital components to improve reliability. Replication have been studied extensively in the literature. So, we do not invent new replication techniques but we deal with the software development complexity introduced by such fault tolerance form. We investigate new ways for handling replication in distributed applications using separation of concerns. Actually, SoC is achieved by modularising the software around its logical functionalities or sub-functionalities. Using modularisation allows the programmer to decompose the software into understandable components and achieve a better degree of reusability and maintainability. Our goal is to design a flexible software infrastructure able to implement replication as independent as possible of the context of its application. To do that, we use the Aspect Oriented Programming approach which aims at allowing different aspects of complex software to be programmed separately and then woven into a single final application.
A library of aspect components have been defined for distributed
programming with JAC. They allow to program aspect-oriented
applications with availability needs. They provide an active
replication policy with broadcast, load-balancing, cache and
consistency aspects. Our approach decomposes first the replication
management application into many communication components defined
separately. We provide then a same generic programming
interface to integrate the components into the application as aspects. We allow thus an application programmer to choose the
adequate manner to implement its replication strategy
(replication type, replication degree, replica location,
communication and synchronization forms...)
, without having to know the implementation
details of the replication management protocol
Second, with new component platforms, architects create distributed applications by assembling components. In all these platforms, software architecture defines the application organization as a collection of components plus a set of constraints on the interactions between components. Facing the difficulties of building correct software architecture, abstract software architecture models were built. They are powerful methods in the specification and analysis of high-level designs. Lots of architecture description models have been defined to describe, design, check, and implement software architectures. Many of these models support sophisticated analysis and reasoning or support architecture-centric development.
Nevertheless, these models are often static or work only on the
components composition. In these conditions, it is difficult to
build large software architecture or to
integrate new components in an existing software architecture or
to add a forgotten concern such as security or persistency. So, we
propose TranSAT (Transform Software Architecture Technologies),
an abstract component model for designing software architectures
Software engineering aims at being rationalized always more and begin
to reach levels of productivity and reuse that come near to other
fields such as mechanics or electronics. Objects technologies then
those based on components participate to this quest. In
The Component Oriented Design of Information Systems is spreading.
After being used for gaining in re-usability at the architectural
level, components are nowadays applied at the business logic level.
We focus on the design of multiple functional views in such information
systems, specially within the EJB framework. Traditionally, in the
database context, this problem is solved by the notions of ''view-schemas''
applied to a database schema. In
In the context of the RNTL ACCORD project
The RNTL project ACCORD has 8 participants (EDF, CNAM, ENST, ENST-Bretagne, France Télécom, INRIA, LIFL, Softeam). The goal is to produce a design framework using explicit contracts to specify and assemble components. We want to facilitate understanding of complex systems, enhance the flexibility and the reusability of components, and allow strong validation of assemblies. This work has to be done independently of technical infrastructures.
The partners of this project are INRIA, BULL, France Télécom, Schlumberger, Scalagent, ExperLog, Kelua, I3S, LAMIH, LIFL, LIP6, LSR. The project wants to specify and construct an adaptable framework for the design of middleware. This framework includes the following components: the Fractal model of component, JORM for persistency, JOTM for transactions, JONATHAN for the bindings, JORAM for the event based communications. The project contributes to the ObjectWeb code base.
The collaborative action GRID RMI includes the following INRIA projects: Paris, ReMap, Jacquard, and OASIS. The goal is to tackle the software system layer of the GRID computing using objects and components techniques. The project uses different platforms: PM2, PadicoTM and PaCO++, OpenCCM, ProActive and Do!.
The 'Region Nord Pas de Calais' has initiated a large research plan around the new technologies for communications. We lead the software section of this plan. Beyond this plan the 'Region Nord Pas de Calais' has facilitated the creation of a new research institut called IRCICA to promote new collaborative research projects between software and hardware laboratories. The JACQUARD project is one of the first projects supported by this institut.
ObjectWeb is a French initiative to promote high quality open source middleware. The vision of ObjectWeb is that of a set of components which can be assembled to offer high quality. We are member of this consortium, we lead the College of Architects (2002-2003), and OpenCCM and JAC are projects hosted by the consortium.
We participated to the organization and animation of four ObjectWeb Architecture Meetings:
INRIA Rhône-Alpes, Montbonnot Saint-Martin, France, 30 - 31 January 2003.
University of Jussieu, Paris, France, 28 - 29 April 2003.
LIP6, Paris, France, 1 - 2 July 2003.
INRIA Rhône-Alpes, Montbonnot Saint-Martin, France, 24 - 26 September 2003.
The 'COmponent based ArCHitecture for distributed telecom applications' project is a PCRDT project in the IST program. The project groups 9 academic and industrial labs. The goal is a component oriented CORBA platform for the telecom domain. Our OpenCCM platform forms the basis of this architecture.
OSMOSE stands for 'Open Source Middleware for Open Systems in Europe'. It is an ITEA project. The project groups 16 European industrials and 7 public labs. The goal is to give up an European dimension for the ObjectWeb consortium. The OSMOSE project wants to federate high quality components from European labs, and to produce applications for the great European industrial domains.
AOSD-Europe is an ongoing proposal to set up a Network of Excellence (NoE) on aspect-oriented software development within IST-FP6. The proposal brings together 11 research groups and among them members of the JACQUARD project and other members from INRIA. The proposal is led by Lancaster University, Darmstadt University and University of Twente. The goal of the NoE is to harmonise, integrate and strengthen European research activities on all issues related to aspect orientation: analysis, design, development, formalization, applications, empirical studies.
We work in the international consortium OMG (Object Management Group) since 1997. OMG defines well-known standards: CORBA, UML, MOF, MDA. We can quote our 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. We also participate in the definition of an UML profile for CORBA Components.
We work in the international consortium OMG (Object Management Group) since 1997. OMG defines well-known standards: CORBA, UML, MOF, MDA. We can quote our 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. We also participate in the definition of an UML profile for CORBA Components.
Philippe Merle,
`` Chartering the Components 1.2 Revision Task Force '',
OMG Technical Meeting,
Paris, France,
June 2003.
Philippe Merle, Chair of the OMG Components 1.2 Revision Task Force (RTF),
Philippe Merle, Member of the OMG Deployment Finalization Task Force (FTF),
Philippe Merle, Member of the OMG UML Profile for CCM Finalization Task Force (FTF),
Philippe Merle, Member of submission team for the OMG UML Profile for CCM RFP
Philippe Merle, Member of the voting list for the OMG MOF 2.0 IDL RFP,
Philippe Merle, Member of the voting list for the OMG MOF 2.0 Query/View/Transf. RFP,
Philippe Merle, Member of the voting list for the OMG MOF 2.0 Versioning RFP,
Philippe Merle, Member of the voting list for the OMG QoS for CORBA Components RFP,
Philippe Merle, Member of the voting list for the OMG Streams for CCM RFP,
AOP Alliance is an international open-source initiative to provide a
common API for building aspect weavers
<
We give some invited tutorials in conference:
Marc Born (Fraunhofer FOKUS), Tom Ritter (Fraunhofer FOKUS), and Philippe Merle,
`` Realization of Distributed Applications using MDA and the CORBA Component Model '',
Tutorial at the ACM/IFIP/USENIX International Middleware Conference (Middleware 2003),
Rio de Janeiro, Brazil,
16 - 20 June 2003.
R. Pawlak, L. Seinturier, `` JAC Tutorial '', Tutorial at AOSD'2003 (Aspect
Oriented Software Development), Boston, USA.
Philippe Merle strongly participates to the 4th Summer School on Middleware and Building
Distributed Applications, organised by INRIA Rhône-Alpes and ObjectWeb Consortium
(ICAR 2003, 25 - 29 August 2003, Autrans, France). See at
We participate to some Masters of Computer Science (University of Lille, University of Valenciennes, University of Namur (Belgium), on the CCM, MDA and on AOP.