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. The challenge is to facilitate the production of software that are more and more complex, robust, maintainable and evolutive. Component oriented design is a recent step towards that productivity through re-usability. 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 [20] 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 [19] transformation chains. This is "Model Driven Engineering" [12].
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 [7] and Catalysis [10] approaches. We start from our previous works on the application of view structuring to object-oriented programming [24], databases [9,2] and software architectures [4,13].
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. Several approaches propose the reuse of functional aspects in various forms, like the design of reusable frameworks [10] or in the form of UML templates [7].
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 [16] 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 an UML profile.
The corresponding UML Objecteering module is available at
http://www.lifl.fr/~mullera
In [17] we compare techniques for composing and parameterizing models and keep the advantages of the later ones to specify reusable functional aspects. Model parameterization is related to templates notions, such that found in the UML scope. Applications of templates 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 [20]. Particularly, constraints lack for the precise definition of the related template binding relationship. That is why we propose in [5] a set of OCL constraints [26] which strengthen the notion of model templates and facilitate its exploitation in construction processes. 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 use this extension in order to define a process where package templates are composed to build a system, the way our components must do.
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. 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.
We identify some structural patterns which allow to target functional decomposition onto component platforms. In [3], 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 one offers a solution for relationships among such components. These patterns improve evolution and traceability of views and can be applied to different technological platforms. An experimentation in the Fractal component model is presented in [1] which allows to envision the usage of Fractal controllers to manage split components. In [6] 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 [11]. 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.
At a practical stage, all this work is gradually integrated in Case Tools (Objecteering, Eclipse Plugin), as functional aspect oriented modelling and design facilities to support model driven processes.
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.
Eclipse Modeling Framework, OCL support
This project extends the Eclipse Modeling Framework (EMF) with an OCL
support. EMF is a set of development tools that provides a metamodeling approach for
the Eclipse environment based on Essential MOF. It enables to define metamodels and generate
Java implementation of theses metamodels which both support the creation and manipulation
of model instances. The proposed extension gives the abilities to attach OCL constraints (pre/postcondition, invariant) to any metamodel defined with EMF, to verify their coherence and to translate these contraints into Java code for evaluating them on instance models. Thanks to the OCL capabilities, developpers exploiting EMF can specify their models and metamodels in a more precise and coherent way.
This software is available as an Eclipse plugin at the following address :
http://www.enic.fr/people/Vanwormhoudt/siteEMFOCL/index.html.
UML Case Tool, Parameterized Model Application, Targeting Strategies
Cocoa Modeler is a modeling tool based on the Eclipse Modeling Framework and the UML2 Eclipse plugin.
It adds a graphical representation and allows defining generic models
as UML2 template packages. It provides the functionality of composing these generic models and applying them in order to build a complete system.
This work in progress includes different code generation strategies.
Cocoa Modeler is available at the following address :
http://www.lifl.fr/~ mullera/cocoamodeler.
We focus on how to define model driven engineering construction processes with such parameterized models. This needs to express complex compositions of parameterized models which must be applied in a coherent way. Such building processes raise open issues: Is the result influenced by the application order ? Can we compose independent parameterized models ? Is it possible to define composition chains and find equivalent ones that express the same resulting model ?
To support such processes, we introduce an operator (apply) to express the application of a template to an existing model [18]. This operator allows to specify how to obtain a model from an existing one by the application and composition of generic ones. It also allows the combination of generic models in order to design richer ones. Thanks to this operator, sequences of applications can be expressed in a coherent way. Alternative composition sequences of parameterized models can be elaborated to build the same system model.
We have formalized the semantics of this operator and proved some properties which guarantee the correctness of application chains and their alternative ordering capacities. Our formalization is deliberately independent from any specific usage or existing methodologies. This gives the ability to provide stategies to transform composition of parametrized models into platform specifc models.
At a practical stage, we are developping a design tool based on the Eclipse Modeling Framework extended with the OCL support [25] and the Eclipse UML2 plugin. Our tool called Cocoa Modeler allows defining generic models as UML2 template packages and provides the functionality of composing these generic models and applying them in order to build a complete system. Strategies to transform composition of parameterized models into platform specific models are also offered. This tool will give the ability to manage libraries (design, composition, import,...) of parameterized models as standard UML2 templates.
Decomposing a system architecture into views has also been studied in the definition of system architectures [13]: after identifying the core concepts of a domain, concerns are specified one by one before explaining their integration. In the continuation of this work, we have studied the definition of modeling processes [8]. In this second stage we have proposed a framework for assisting the user in its modeling activity[15]. First, the modeling process is defined as steps with a subset of the modeling operations available and constraints that states when the step can be started and considered terminated. Second, based upon this specification the modeling environment controles the user activity: providing concern modeling only when possible, and evaluating the modeling constraint to drive the move between modeling steps. We have studied this approach both in the context of iterative development and software evolution of 3-tiers applications [14]. Finally, this work is a source of collaboration with the Triskell Research Project (IRISA) as we are implementing our proprosal using KerMeta[23]. This implementation is intended to contribute to the KerMeta environnement in the Modelling Processes sub-project.
Raphael Marvie is in charge of Object Oriented Design (Master 1 and 2) and Programming (Bachelor 3), Distributed Computing (Bachelor 3), Model Driven Engineering (Master 2 and Master Research), at USTL, UFR IEEA. He is co-responsible for Master 2 IAGL, assisting L. Duchien for projects and training periods. He regularly teaches Component Based Software Engineering and Model Driven Engineering to Master 2 students / engineers outside of USTL (University of Montpellier and ESSI in Nice).
Bernard Carré teaches OO Design and programming at Polytech'Lille Engineering School (USTL). He is in charge of the Computer Science and Statistics Departement of Polytech'Lille. He also teaches Software Technologies.
At Polytech'Lille Engineering 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. He also manage the final year engineering students projects of the Computer Science and Statistics Departement of Polytech'Lille.
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
We also 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, MDA and on AOP.
Bernard Carré is member of CSE27nd section of university of Valenciennes. Olivier Caron is member of CSE27nd section of university of Lille. Raphaël Marvie is member of CSE27nd section of university of Nice and is also member of the LIFL scientific board.