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 focuses on the problem of designing complex distributed applications, i.e., those composed of numerous cooperative and distributed software components, which are constrained by various requirements, such as persistency, security and fault tolerance. We want to investigate the ability of software engineers to produce new component-oriented platforms and new methodological and technical approaches to design and exploit these applications. In particular, we explore the use of component models, separation of concerns and weaving in the different phases of an application's life cycle (i.e., modelling, design, assembling, deployment, and execution). Our goal is to produce fully functional platforms and tools. Finally, we are members of standardization organizations (OMG) and the open source software world (ObjectWeb).
One of the first historical steps towards programming appeared in 1725 on a weaving machine. The French "Lyonnais" Basile Bouchon first gives instructions to a weaving machine using a perforated paper. His assistant Mr Falcon will replace the fragile paper by more robust perforated cards. After that, Mr Vancanson will replace the cards by a metallic cylinder and a complex hydraulic system, which gives the machine a cyclic flow of instructions a program!
But History keeps in mind Joseph-Marie Jacquard who creates and commercialises the first automatic weaving machine during the beginning of 19th century. The machine was so precise that Joseph-Marie Jacquard designs a program that weaves his own face on a fabric. Joseph-Marie 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 for 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 these 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 CORBA Scripting Language 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 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:
- to 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.
- to define a complete design and technical environment for assembling of components and aspect, via a dedicated modelling tool for composition and a dynamic component and aspect oriented platform that will be a next step of our aspect 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 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 LGPL software accessible at http://openccm.objectweb.org. 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 is related to other works on open middleware: the Fractal model for component middleware (ObjectWeb, Inria Sardes project, France Telecom), reflexive middleware approaches (Dynamic TAO , Flexinet , OpenCorba , OpenORB ), adaptable middleware approaches (ARCAD RNTL project ), virtual machines (VVM) and QoS driven Midleware .
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 for 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 inherit 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 or 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 several problems. For instance, 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 constructed on demand with 'Components Off 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 concern (e.g., 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 concerns 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 in accordance with the context. Changes can occur in an asynchronous manner and the behaviour has to be adapted without human actions and without stopping the application. 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 three directions.
The first one deals with the study of separation of concerns from the first steps of analysis to the implementation and to be able to trace the evolution of this concerns in these various stages. The second one is related to dynamic features of Architecture Description Languages (ADL) . The last one focuses on Aspect Oriented Programming in which one can capture a specific concern of a behaviour.
Finally, this project part enhances specifications of component assemblies in the goal of designing adaptable applications. We introduce integration contracts for specifying the impact of components on the application and its context. Our approach is based on AOP to specify connection and integration schemas. We also work on the JAC (Java Aspect Components) platform that provides dynamic weaving of aspects.
Business applications are faced with two main challenges. On one side they are mostly developed with an iterative process where business functionalities are added to the core application as the project requirements evolve. On the other side, the non-functional requirements (in terms of security, remote communication and transaction, data persistence, etc.) are also high and need to be incorporated as seamlessly as possible. Both the component-based and the aspect-oriented approaches separatively provide directions for these challenges. However no integrated software process exists to take both into account. The goal of this work is thus to propose such a process and some tools to support it since the early stages of analysis and to provide features to trace their evolution them from user requirements until deployment and run-time. This work is done in the context of Dolores Diaz's PhD thesis.
Software architects and designers have a reasoned frame to iteratively integrate functional and non-functional concerns into their projects, and to adapt them to unforseen functional or non-functional requirements. For helping them, analysis methods support modelling and verification tools from functional to technical architecture. Their main advantages are capacity of modelling large-scaled distributed systems that require interoperability between system parts and the separation of concerns between business functionality and communication mechanisms.
However, no standard and universal definition of the software architecture was accepted by all the community. Various points of view on different studies bring to several approaches. These approaches focus on only one or two concerns such as component interfaces specification, behavioural analysis or software reconfiguration. So we argue that, in order to increase benefits of software architecture approaches, one may need to use an architecture centric approach with a global reasoning: From software architecture design to software architecture management to software architecture building, deployment and refinement. However, these different concerns of a software architecture definition must be kept consistent.
Our first goal is to propose enhancements of a component model for specifying dynamic evolution of an software architecture. It concerns three points of view: structural, functional and behavioural points of view. We use Model Driven Architecture approach with Context Independent Model and Context Specific Model. Our second goal is to introduce non functional aspects - and then connexions between components and containers - in languages for software architectures. We extend contracts between components to contracts between components and non functional components.
In distributed environments, applications run in an open context. They use networks and their associated services where quality of service is not always guaranteed and may change quickly. In these environments, several concerns must be considered, including fault tolerance, data consistency, remote version update, runtime maintenance, dynamic lookup, scalability, lack of rate. Addressing these issues may require dynamic and fast reconfiguration of distributed applications.
We have defined the Java Aspect Components (JAC) framework for building aspect-oriented distributed applications in Java . Unlike other languages like AspectJ, JAC allows dynamic weaving of aspects (aspects can be weaved or unweaved at run-time) and proposes a modular solution to specify the composition of aspects. We defined on aspect-oriented programming model and the architectural details of the framework implementation. The framework enables extension of application semantics for handling well-separated concerns. This is achieved with a software entity called an aspect component (AC). ACs provide distributed pointcuts, dynamic wrappers and metamodel annotations. Distributed pointcuts are a key feature of our framework. They enable the definition of crosscutting structures that do not need to be located on a single host. ACs are dynamic. They can be added, removed, and controlled at runtime. This enables our framework to be used in highly dynamic environments where adaptable software is needed.
Software Engineering helps in increased productivity by re-usability. Component oriented design is a recent step towards that productivity. It allows the composition of "off the shelf" 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 addressed by these ideas around composition.
After being considered only as documentation elements for a long time, models are gaining more and more importance in the software development lifecycle, as full software artefacts. The UML standard contributes a lot to this mutation, with the identification and the structuration of models space dimensions and constructs. Models can nowadays be explicitly manipulated through metamodeling techniques, dedicated tools or processes such as the MDA transformation chains. This is "Model Driven Engineering" .
The main motivation is the reduction of delays and costs by the capitalization of design efforts (models) at each stage, and the automation, as far as possible, of transitions between these stages. So it would be possible to separate high level business oriented models from low level architectural and technological ones, but also to reuse these models from one application to another. Indeed, once it is clear that models are full software ingredients, we are faced with new problems (needs!) such as the possibility of their reusability and composability. As a consequence, models stand more and more as good candidates for the "design for reuse" quest and specific constructs are introduced to make them generic.
We want to investigate the idea that functional decomposition of models is a way for increased re-usability. Our interest takes place in the use of functional aspects which represent the various dimensions of a tackled domain. It is related to aspect oriented structuring, and design plans like the Views, SOP and Catalysis approaches. 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 in order 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 than simple interfaces of objects or software components.
As a first step, we formalized such a component model and its associated design and assembly rules as an extension of the UML meta-model. We obtain adaptable model components that can be targeted to the EJB platform and the CORBA component model. We realized an implementation of this work via a UML profile. The corresponding UML Objecteering module is available at http://www.lifl.fr/~mullera.
Model parameterization is related to templates notions, such that found in the UML scope. We are exploring this notion in order to compare it to our component model. A first study shows that our model components can be expressed by UML template packages. We also identify that the UML specification needs to be extended in order to make templates parameterizable by complex models. We are defining a set of OCL constraints which formalizes this extension.
We plan to use this extension in order to define a process where package templates are composed to build a system, the way our components must do. This will lead us to define new operators for composing templates. This is related to the work of Clarke around composition operations (e.g., override, merge).
A second dimension of our work is concerned with the preservation of the 'functional aspects oriented design style' 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. In , we present a composition-oriented approach grounded on the splitting of entities according to views requirements. Two original design patterns are formulated and capture the main issues of the approach. The first one is concerned with the management of the split component and its conceptual identity. The second offers a solution for relationships among such components. These patterns improve evolution and traceability of views and can be applied to different technological platforms.
At a practical stage, all this work is gradually integrated in Case Tools (Objecteering, Eclipse Plugin), as functional aspect oriented modelling and design facilities.
The Jacquard project addresses the large problem of designing complex distributed applications composed of numerous cooperative and distributed software components. Our application domains are numerous. First, our component models and platforms target information systems. These software need properties such as functional and technics and they must evolve. Second, component models tackle several specific domains needing adaptability of process context such as mobility or ubiquitous computing. We apply it in transportation or communication domains, for example in MOSAIQUES project or AOSD NoE. Finally, we participate to platforms definition for grid computing.
Apollon is a model driven software framework to generate Java-based graphical editors for XML documents.
According to a XML DTD given as input, the Apollon's code generator generates a set of Java Data classes and Java Swing components implementing graphical editors for XML documents. The Java Data classes are a strongly typed reification of the XML DTD: Each XML DTD element is reified as a Java class, XML DTD children and attributes are reified as getter and setter Java methods. The Java Swing components implement the graphical representation of the Java Data classes. The graphical representation of any XML element and attribute could be customized at the generation time according to users' graphical requirements.
The Apollon's code generator is built as an extension of the open source Zeus software. The Apollon's runtime is based on the Fractal Explorer software framework described below. Apollon is already used in OpenCCM to automatically generate graphical editors for the XML DTDs defined in the OMG's CORBA Components Specification.
Apollon is a LGPL open source software available at http://forge.objectweb.org/projects/apollon.
Fractal Explorer is a generic Fractal component-based software framework to build Java-based graphical explorer and management consoles.
Fractal Explorer is composed of the Explorer Description Language, the plug-in programming interface, and the Fractal component-based explorer framework. The Explorer Description Language (a XML DTD) allows users to describe at a high level the configuration of graphical explorer consoles to build, i.e. icons, menu items and panels associated to resources to explore/manage and according to end-user roles. Reactions associated to these described graphical elements could be implemented by Java classes which must be conform to the plug-in programming interface. Finally, the explorer framework implements the interpretation of explorer configurations and executes plug-in classes according to users' interactions. This framework is implemented as an extensible set of software components conform to the ObjectWeb Fractal component model defined by Inria and France Telecom. Moreover a set of plug-ins is already provided to explore and manage any Java objects and Fractal components.
Fractal Explorer is already reused and customized by our Apollon, FAC, GoTM, and OpenCCM software to provide respectively explorer consoles for XML documents, Fractal aspect components, component-based transaction services and CORBA objects/components.
Fractal Explorer is a LGPL open source software available at http://fractal.objectweb.org.
GoTM is a Fractal component-based software framework to build middleware transaction services.
GoTM is composed of an extensible set of Fractal components providing basic building blocks (Transaction, Resource, Coordination, Concurrency, etc.) to build various transaction models and services (OMG OTS, JTA, etc.). A JTA personalisation of this framework is already implemented.
The GoTM component-based software framework is designed on top of the ObjectWeb Fractal component model and is implemented on top of the ObjectWeb Julia reference implementation.
GoTM is a LGPL open source software available at http://gotm.objectweb.org.
OpenCCM is a middleware platform for distributed applications based on CORBA components.
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. Moreover, one CCM application could be deployed and run on several distributed nodes simultaneously.
OpenCCM allows users to design, implement, compile, package, assemble, deploy, install, instantiate, configure, execute, and manage distributed CORBA component-based applications. For these purposes, OpenCCM is composed of a set of tools, i.e. UML and OMG IDL model repositories, compilers, code generators, a graphical packaging and assembling tool, a distributed deployment infrastructure, extensible containers integrating various services (communication, monitoring, transaction, persistency, security, etc.), and a graphical management console.
OpenCCM is a LGPL open source software available at http://openccm.objectweb.org.
JAC (Java Aspect Components) is a project consisting in developing an aspect-oriented middleware layer. JAC current version is 0.12.1. 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 http://jac.objectweb.org
Implementation of the UML profile for Corba Component Model.
This software enables to design a UML model corresponding to the standardized UML profile for CCM. It both checks the validity of the model and generates IDL description. This software is available as a UML Objecteering module at the following address :
http://www.lifl.fr/jacquard/software/Profil-UML-CCM/index.html.
The definition of a common component middleware which can be specialized with some technical services is a major stake in the endeavour to capitalize operational systems' functions. However, modern middleware do not provide such a specialization function, i.e. a way to build extensible containers.
In we define a unified approach to build specialized component middleware by assembling software services. The analysis of the Sun Microsystem's Java 2 Enterprise Edition (J2EE) and the Object Management Group (OMG)'s CORBA Component Model (CCM) standard middleware has led us to the characterization of the specialization function. Then, we apply the software component concept to services themselves with a mind to covering the services' integration, composition and use needs. We also document a system of patterns targeted to services' architectural needs. This latter meets the quality attributes of the specialization function's architecture. This approach was implemented in CCM and we delivered a prototype in the OpenCCM platform in partnership with the European IST COACH project.
The use of software components and patterns, combined with a empirical and incremental method, rationally divides the inherent complexity of the specialization between the middleware provider, the service provider and the end-user. We note a noteworthy benefit in terms of reuse and efficiency in practice.
Deployment of software components for building distributed applications consists of the coordination of a set of basic tasks like uploading component binaries to the execution sites, loading them in memory, instantiating components, interconnecting their ports, setting their business and technical attributes. The automation of the deployment process then requires the presence of a software infrastructure distributed itself on the different execution sites.
presents the specification of such an infrastructure for the deployment of CORBA component-based applications. This latter is designed and implemented in the context of our OpenCCM platform, an open source implementation of the CORBA Component Model. The main characteristic lays on the fact that this infrastructure is itself designed as a set of CORBA component assemblies. This allows its dynamic assembly during its deployment over the execution sites.
Component middleware allow the automatization of applications deployment process. This function, called deployment machine, instantiates applications from their architectural descriptions. Unfortunately, currently each middleware implements its own deployment machine. Thus no capitalization is proposed as far as conceptual or implementation aspects are concerned.
To promote this capitalization, in we propose a model driven approach to build component middleware deployment machines. This approach introduces a UML profile of workflow which allows us to define deployment models independently of any targeted component middleware. Such a model is then refined for each targeted middleware and the obtained model is mapped to different execution platforms. The models and transformations of this approach are illustrated on a CORBA Components deployment machine implemented using the Fractal component model.
The multiplication of architecture description languages, component models and platforms implies a serious dilemma for component based software architects. On the one hand, they have to choose a language to describe concrete configurations which will be automatically deployed on execution platforms. On the other hand, they wish to capitalize their software architectures independently of any description languages or platforms.
To solve this problem, we propose a multi personalities environment for the configuration and the deployment of component based applications. This environment is composed of a core capturing a canonical model of configuration and deployment, and a set of personalities tailored to languages and platforms. details the architecture of such an environment and describes the personalities for the CORBA and Fractal component models.
Transactions have always been involved in various applications since they have been introduced in databases. Many transaction services have been developed to address various transaction standards and various transaction models. Furthermore, these transaction services are more and more difficult to build since the complexity of the transaction standards is increasing constantly. Each transaction service implements pieces of code that has already been written in another transaction services. As a consequence, there is no code factorization between the transaction services and the added values of each transaction service, such as extensibility or performance, are never reused in another transaction service.
In and , we present GoTM, a Component-Based Adaptive Middleware (CBAM) software framework. This framework enables to build various transaction services compliant with existing transaction standards. GoTM provides adaptive properties to support different transaction models and standards in the same transaction service. GoTM supports also the definition of new transaction models and standards as new components of the framework. Finally, GoTM provides (re)configurability, extensibility and adaptability properties as added values. The implementation of the GoTM framework is based on the Fractal component model.
Nowadays, distributed Java-based applications could be built on top of a plethora of middleware technologies such as Object Request Brokers (ORB) like CORBA and Java RMI, Web Services, and component-oriented platforms like Enterprise Java Beans (EJB) or CORBA Component Model (CCM). Choosing the right middleware technology fitting with application requirements is a complex activity driven by various criteria such as economic costs (e.g. commercial or open source availability, engineer training and skills), conformance to standards, advanced proprietary features, performance, scalability, etc. Regarding performance, a lot of basic metrics could be evaluated like round-trip latency, jitter, or throughput of twoway interactions according to various parameter types and sizes.
Many projects have already evaluated these middleware performance metrics. Unfortunately, they have not compared different kinds of middleware platforms simultaneously. This could be helpful for application designers requiring to select both the kind of middleware technology to apply and the best implementation to use.
In , we present an experience report on the design and implementation of a simple benchmark to evaluate the round-trip latency of various Java-based middleware platforms, i.e. only measuring the response time of twoway interactions without parameters. Even if simple, this benchmark is relevant as it allows users to evaluate the minimal response mean time and the maximal number of interactions per second provided by a middleware platform. Empirical results and analysis are discussed on a large set of widely available implementations including various ORB (Java RMI, Java IDL, ORBacus, JacORB, OpenORB, and Ice), Web Services projects (Apache XML-RPC and Axis), and component-oriented platforms (JBoss, JOnAS, OpenCCM, Fractal, ProActive). This evaluation shows that our OpenCCM platform already provides better performance results than most of the other evaluated middleware platforms.
First, 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 SafArchie and TranSAT (Transform Software Architecture Technologies), an abstract component model for designing software architectures . With SafArchie, we based our approach on architecture types that are points of reference at each step of our reasoning . We develop SafArchie Studio , an architecture centric tool based on three-view perspective and driven by the component life cycle. In TranSAT , we extend the classical concepts of the software architecture models to describe technical concerns independently from a design model and integrate them step by step. These refinement steps are highly inspired by Aspect Oriented Programming (AOP), where the designer defines all the facets of an application (business and technical). To ensure a correct component composition and a correct weaving of technical components, we add behavioural information on components. These information are used to specify temporal communication protocols and check properties such as deadlock freedom or synchronization between components.
ODP (Open Distributed Processing) model provides five viewpoints where each one represents one concern. They are Enterprise viewpoint (describes client needs and organisation policy), Information viewpoint (describes systems data), Computational viewpoint (describes business functionality), Engineering viewpoint (describes mechanism supporting distributed communication) and Technology viewpoint (describes technology utilisation). However, ODP is limited because it provides rich concepts for modelling distributed systems in accordance with the different viewpoints but it does not provide languages and tools for modelling and analysing software qualities and it does not guide an architect from one viewpoint to another viewpoint.
We propose a methodology for supporting modelling and analysing in the change from Computational viewpoint to Engineering viewpoint. First, we create a component model to build functional architectures in the Computational viewpoint. This component model is improved with assembly and composition concerns. Second, the Engineering viewpoint needs some concepts as hosts and channels to represent technical architectures.
Finally, one of the difficult tasks is to define non-functional properties in technical architectures. These properties such as transaction, persistence or security come from non-functional requirements. The transformation from functional to technical architecture must take into consideration these properties in order to specify the complete execution platform architecture. We have developed an architectural figure concept that represents some solutions to address these non-functional requirements . These figures can be reused and help in the transformation from functional architecture to technical architecture. Moreover, we require efficient methods in order to analyze technical architecture's qualities about three analysis requirements, which are behaviour, deployment and non-functional properties . Our models for constructing and analysing software architecture can apply not only in ODP but also in the architectural level of any proposed model following IEEE1471's viewpoint. Within our approach, architecture is evaluated following three principal criteria: system behaviour, deployment correctness, and non-functional qualities. The capacity of analysing software architecture with the three criteria allows for building efficient quality software.
Software architectures need to accomodate both functional and non functional concerns. Functional concerns encompass pieces of code coming from the application domain being analyzed, and the non functional ones relate to the services provided by the environment (OS, network, application server, ...) that need to be integrated.
Component-based approaches and their associated architecture description languages are good at addressing functional software assemblies but do not provide dedicated concepts for integrating non functional needs. Conversely, aspect-oriented programming is well suited for adding some non functional crosscutting concerns into an application but does not address the issue of assembling functional parts. As both facets are almost always present in applications we then believe that there is a strong need for an approach that address both. This is the topic of the FAC action that we begun in 2004.
The goal of the FAC (Fractal Aspect Component) action is to define a model for components and aspects. We envision a symmetric model in which there is only one kind of entity, component, and in which aspects are themselves components. Treating aspects as components leads to model that can be better and more easily integrated in the various stages (building, packaging, deploying, managing, debugging, ...) of the software life cycle: e.g. packaging an aspect is not different than packaging a component. The question of whether AOP should be symmetric or not (see the debate AspectJ vs Hyper/J) is open in the international research community. We believe that the asymmetric approach taken by AspectJ and others simplified the acceptance of AOP at the early stages, but that for the longer term the seamless integration of AOP requires to come back to a symmetric approach.
The second main feature of the FAC model deals with bindings. In existing ADL and component models, a binding links a client component requiring a service to a server component providing that service. Binding are most of the time dynamic in the sense that a component can be unbound and rebound to another one at runtime. This kind of binding is well suited for representing functional dependencies within an application. The FAC model supports a second kind of binding that we call crosscut binding. It links an aspect component with the components being aspectized (for instance, it links the transaction aspect with all components requiring some transactions). This binding is associated as in any other AOP tool, with a crosscut regular expression that defines the component aspectized. Hence, an application with FAC owns two kinds of binding: functional ones and crosscut ones. All these bindings can be dynamicaly introspected and modified. The advantage of such an approach is that the software architecture is made clearer and that the dependencies, both functional and crosscutting, are expressed, which is not the case with other approaches.
The FAC model is designed and developped in the context of a contract with France Telecom R&D.
The design of information systems remains at the present time a difficult task which requires that great number of entities and concerns be taken into account whether they are functional or not. Consequently, approaches supporting a decomposition of systems according to their functional dimensions were thus proposed at the programming level with AOP (Aspect-Oriented Programming) but also at the design level with the SOD (Subject-Oriented Design) or with views approaches .
The problem of the reuse of these functional aspects arises now. Indeed, this reuse must make it possible to improve the productivity and reliability in the field of information systems design. Various approaches propose the reuse of functional aspects in various forms, like the design of reusable frameworks or in the form of UML templates .
In we compare techniques for composing and parameterizing models and keep the advantages of the later ones to specify reusable functional aspects.
Parameterization capabilities are offered by the UML Template notion. Applications are numerous and various, with the result that its initial introduction in UML1.3 was deeply revisited and strengthened in the UML2 standard. Though its specification remains much more structural and verbal in . Particularly, constraints lack for the precise definition of the related "binding'' relation which allows to obtain models from templates. These constraints are needed to verify the correctness of the resulting models. That is why we propose in a set of OCL constraints which could strengthen the notion of model templates and facilitate the above verification. An Eclipse plugin was realized. This new plugin enables to build new metamodels with OCL constraints and then generate Java implementations of these metamodels which both support the creation and verification of models based on these OCL constraints.
At a design level, we have defined an independent platform model of view-components which enables to describe complex information systems involving numerous functional dimensions. To target this model on specific platforms, we propose an approach which is based on several design patterns. We start from our patterns supporting views through split representation of entities . A first experimentation in the Fractal component model is presented in which allows to envision the usage of Fractal controllers to manage split components. In we focus on the reuse of functional aspects or views at the implementation level using adaptation techniques. The reuse of views is ensured by applying the adapter pattern . We show how to compose the views pattern and the adaptation one. The result provides an implementation of reusable functional aspects that can be composed at the exploitation stage.
In the context of model driven engineering (MDE), model are the corner stone of software engineering processes. Then, model have to be properly defined in order to be useful and to be the basis of software production. In order to assist the designer in defining a model as well as to control the result, we have studied the chaining and composition of model transformations.
A modeling process is made of several steps (for example identifying components, then their relations, and finally the services used and provided by each component). Delta-trans framework has been defined to support such well defined modeling processes. Defining a model is then seen as a set of transformations (like creating model elements, defining relations between existing model elements) applied on an empty model. Based upon the definition of a modeling process, tools are automatically produced in order to support the process. The modeling tool is dedicated to a process .
In order to easily support software processes in a particular domain (like telecoms or health care) product lines are factorizing the common concerns of application while supporting their adaptation to particular needs using configurable concerns. The goal of our study regarding the composition of model transformations is to support the building of software production lines. Transformations are primitive or composite (composition of transformations). Transformations are provided as executable components, then easily composable to define MDE-based product lines. Our experimental framework picotin provides modeling means for defining and composing model transformations. A set of tools rely on these definitions to generate transformation component implementations. Finally, a prototype environment support the execution of these transformations .
Both studies are complementary in that the first one provides means
for modeling a system respecting domain constraints, and the second
provides means for actually building the system from its definition.
This approach is currently studied together with Alicante (a company
working in the field of health care) in order to build tools for GPs
based upon their basic data items (person, medical act, temperature,
etc) and specific constraints (36C< temperature< 42C).
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.
This contract is a CRE ("Contrat de Recherche Externe") that takes place in the context of the "accord-cadre" between Inria and France Telecom R&D. This is a 3-year contract that begun in October 2004. The scientific teams involved in the project are for Inria, the Jacquard project-team, and for France Telecom R&D, the ASR/Polair department. The contract goal is to study and construct component and aspect based software architectures. The Fractal component model from France Telecom R&D and the JAC AOP framework from Jacquard form the background of this work. The expected result is a model (FAC for Fractal Aspect Component) that merges and unifies aspects and components. Nicolas Pessemier PhD thesis work is directly related to this contract.
This contract is associated to a CIFRE PhD thesis between the Jacquard project-team and the NorSys service company. The goal of the contract is to study the aspect-orientation in the early stages of software development. AOP emerged as a programming technique but the question is now open in the international research company to tell whether it can also bring to innovations into the early stages of requirement engineering, analyze and design. This contract begun in January 2004. Dolores Diaz PhD thesis work is directly related to this contract.
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.
The MOSAIQUES Project ("MOdèles et infraStructures pour Applications ubIQUitairES" or Models and middleware for ubiquitous applications) defines a design and programming framework for application definitions that run in ubiquitous environment. The project includes The University of Lille with LIFL Laboratory (STC and SMAC teams) and Inria projects Jacquard and POPS, TRIGONE laboratory, INRETS, Ecole des Mines de Douai and The University of Valenciennes and of Hainaut-Cambrésis. Application domains are transportation and e-learning systems. Laurence Duchien is headed of this project
The specific action MDA, created in June 2003 et funded by CNRS, studies the interest of the Model Driven Architecture approach. The standard promoted by OMG is only one example. The aim of this AS is to organize the research community in this domain in order to understand and to help the industrial community in an approach that it can be a significant evolution on the middle and long term. This AS includes IRIN, LIFL, LSR, IMAG, I3S, PRIM and CEA laboratories.
ObjectWeb is an European 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, and Fractal Explorer, GoTM, JAC, and OpenCCM are projects hosted by the consortium.
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 OBASCO, Pop-Art and Triskell Inria projects. 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 CORBA Scripting Language chapter of CORBA 3.x) 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 a UML profile for CORBA Components.
Philippe Merle is:
Chair of the OMG Components 1.2 Revision Task Force (RTF).
Member of the OMG Deployment Revision Task Force (RTF).
Member of the OMG UML Profile for CCM Finalization Task Force (FTF).
Member of submission team for the OMG UML Profile for CCM RFP.
Member of the voting list for the OMG MOF 2.0 IDL RFP.
Member of the voting list for the OMG MOF 2.0 Query/View/Transf. RFP.
Member of the voting list for the OMG MOF 2.0 Versioning RFP.
Member of the voting list for the OMG QoS for CORBA Components RFP.
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 <http://aopalliance.sourceforge.net>. This initiative has been launched and is led by Jacquard's members (R. Pawlak and L. Seinturier). The goal is to bring together several aspect framework creators, to analyse the functional requirements that are shared by all these frameworks, and to set up a common API. This API allows to modularise the writing of aspect weavers, and promotes the reuse of common building blocks between AOP frameworks. AOP Alliance brings together leaders of international recognized AOP projects such as JAC, Spring, PROSE. The API is in beta-stage but is already implemented in JAC and PROSE.
Jean-Marc Geib was in the examination committee of the following PhD thesis :
M. Vadet, November 2004, University of Lille (adviser)
E. Renaux, December 2004, University of Lille (adviser)
D. Touzet, March 2004, University of Rennes (referee)
C. Nebut, November 2004, University of Rennes (referee)
H. Zheng, November 2004, University of Lille (chair)
M. Figeac, December 2004, University of Lille (chair)
K. Drira (HDR), December 2004, University of Toulouse (referee)
Laurence Duchien was in the examination committee of the following PhD thesis :
A.-T. Le, January 2004, University of Grenoble (referee)
K. Macedo, March 2004, University of Rennes (referee)
D. Fauthoux, June 2004, University of Toulouse (referee)
L. Quintian, July 2004, University of Nice (referee)
R. Lenglet, November 2004, University of Grenoble (referee)
O. Nano, December 2004, University of Nice (referee)
Philippe Merle was in the examination committee of the following PhD thesis :
M. Vadet, November 2004, University of Lille (co-adviser)
H Cervantes, March 2004, University of Grenoble (referee)
A. Ribes, December 2004, University of Rennes (referee)
Olivier Caron was in the examination committee of the following PhD thesis :
E. Renaux, December 2004, University of Lille (co-adviser)
Jean-Marc Geib has been a member of the following programm committees:
DECOR 2004, 1st Francophone conference on software Deployment and (Re)configuration, October 2004, Grenoble
NOTERE 2004, Les Nouvelles technologies de la répartition, June 2004, Sadia, Maroc
Laurence Duchien has been a member of the following programm committees:
JC 2004, Journées composants, March 2004, Lille
JFPLA 2004, Journées Francophones sur le développement de logiciels par aspects, September 2004, Paris
Workshop ECOOP Abstract Communications on Distributed Systems, Oslo, June 2004
ADVICE Journal
Philippe Merle has been a member of the following programm committees:
DECOR 2004, 1st Francophone conference on software Deployment and (Re)configuration, October 2004, Grenoble
LMO 2004, Langages Models and Objects conference, March 2004, Lille
JC 2004, Journées Composants, March 2004, Lille
IJCA, special issue, June 2004
JMAC 2004, Journées Multi-Agents et Composants, November 2004, Paris
Bernard Carré has been a member of the following programm committees:
LMO 2004, Langages Models and Objects conference, March 2004, Lille
Lionel Seinturier has been a member of the following programm committees:
JC 2004, Journées Composants, March 2004, Lille
JFPLA 2004, Journées Francophones sur le développement de logiciels par aspect, September 2004, Paris
DECOR 2004, 1st Francophone conference on software Deployment and (Re)configuration, October 2004, Grenoble
ADVICE Journal
Renaud Pawlak has been a member of the following programm committees:
workshop AOSD ACP4IS, AOD Conference March 2004, Lancaster, UK.
ADVICE Journal
The Jacquard Team has organized the LMO Conference and The JC Workshop in Lille (15-18 March 2004).
Bernard Carré and Jérome Euzenat (INRIA Rhône-Alpes) are co-editors of the Special volume of the journal 'L'Objet' (Vol 10/2-3, 2004).
Renaud Pawlak gives an invited seminar on Recombining programming at Demeter research unity of Northeastern University, Boston, US.
Jean-Marc Geib teaches Object Oriented Design and Programming and Distributed Application Design in L3 and M1 at USTL, UFR IEEA.
Laurence Duchien teaches Distributed Applications Design - Master Professionnel Sciences et Technologies Mention Informatique - M1 and Master Professionnel Sciences et Technologies Mention Informatique - M2 - Spécialité IAGL et TIIR at USTL, UFR IEEA. She is in charge of the Master Professionnel Sciences et Technologies Mention Informatique - M2 - Spécialité IAGL at USTL, UFR IEEA.
Raphaël Marvie Object Oriented Design, Distributed System Design and C++ programming in Master GMI, Distributed System Design in Master MIAGE-FC, Advanced Technologies for Distribution in Master Pro IPI NT at USTL, UFR IEEA.
Anne-Françoise Le Meur teaches Databases and the Internet, Design of distributed application, and C programming at USTL, UFR IEEA.
Bernard Carré teaches OO design and programming at Polytech'Lille (USTL Engineer school). He is in charge of the Computer Sciences and Statistics Department of Polytech'Lille.
At Polytech'Lille Engeneering school, Olivier Caron is in charge of the following modules: Data Bases and Distributed Software Components. He also teaches Object-Oriented Programming and Operating Systems.
Gilles Vanwormhoudt teaches Algorithms and Programming in C, 1th year of the engineering program, Design and Programming of Distributed Applications, 3rd year of the engineering program and Technologies for Web development, 5th year of the engineering program, ENIC Telecom Lille 1. He is in charge of Multimedia computing and engineering specialization, 5th year of the engineering program, and the Project-Conferences-Report module for the "Multimedia computing and engineering" specialization, ENIC Telecom Lille 1.
Jacquard team's members participate to some Research Masters of Computer Science (University of Lille, University of Paris 6, University of Montpellier, University of Valenciennes and RPI University, Hartford, US) on the CCM, MDE and on AOP.
Jean-Marc Geib is the head of the LIFL laboratory CNRS 8022, the head of the CIM axis, member of the UFR board at USTL, member of CSE 27nd section of Universities of Lille 1, Lille 2 and Littoral. He is member of the management commitee TACT (Technologies Avancées pour la Communication et les Transports) of the Etat-Region Contract Nord-Pas-de-Calais and the coordinator of the communication program since 2004. He is IRCICA cofounder (Intitut de Recherche sur les Composants matériels et logiciels pour l'information et la communication avancée) that is a research federation between LIFL (Science computing), l'IEMN (electronics) and the PhLAM (photonique). He is in charge of the RTP Distributed Systems of the CNRS STIC Dept.
Laurence Duchien is member of the UFR board at USTL, member of the LIFL scientific board, member of CSE 27nd section of Universities of Lille 1, CNAM and Paris 6. She is member of scientific commitee of the national ACI Security.