Bernard Carré

The point of view notion for multiple inheritance

We examine several problems related to the preservation of the Independence Principle inheritance. This principle states that all the characteristics of independent superclasses must be inherited by subclasses, even if there are name conflicts. In this context, a conventional approach is to use explicit class selection. We show that this mechanism suffers from serious limitations, and leads to inhibition of refinement and genericity. Our experimental object-oriented language ROME introduces the “Point of View” notion (using an “as-expressions” mechanism) which solves these problems.

A Framework for Supporting Views in Component Oriented Information Systems

The Component Oriented Design of Information Systems is spreading. After being used for gaining in reusability at the architectural level, components are nowadays applied at the business logic level. We focus here 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 notion of view-schemas applied to a database schema. 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. Finally, we apply these patterns to the EJB framework. This framework improves evolution and traceability of views.

Contextualization of OODB Schemas in CROME

View Mechanisms, widely used in the relational databases, pose new questions in the object model which captures much more semantics. In this paper, we will focus on inheritance and inter-objects relationships. two main semantic aspects of the object model. Like in the relational model, most of the current works about object-oriented views assume a fine granularity of the views. View classes are defined by the application of a query operator to one or two classes of the base schema. View schemas are defined as sets of view classes. These sets are explicitly chosen by the database administrator. We present the solutions produced by the application of our CROME model. In CROME, view classes extend the descriptions of the domain objects supplied by the base schema. The relationships introduced in the base schema are shared and preserved in view schemas. By adapting them locally, each view schema contextualize these relationships. We will show that this contextualization of the base schema gives it generic properties which enforce a stronger coherence of the view schemas.

From subsets of model elements to submodels

Model-driven engineering (MDE) generalized the status of models from documentation or model-driven architecture (MDA) modeling steps to full artifacts, members of a so-called structured “model space”. We concentrate here on the submodel relationship which contributes a lot to this structuring effort. Many works and MDE practices resort to this notion and call for its precise characterization, which is the intent of this paper. A typical situation is model management through repositories. We start from the definition of a model as a set of model elements plus a set of dependency constraints that it asserts over these elements. This allows to isolate the notions of closed, covariant and invariant submodels. As a major result, we show that submodel transitivity can be guaranteed thanks to submodel invariance. This formalization offers keys to analyze operations which manipulate submodels. For example, we deeply study the operator which consists in extracting a model from another one, when selecting some subset of its elements. The same can be applied to many other model operations and the last part of the paper is dedicated to a synthesis on related works which could profit from this characterization. More practically, we show how the results were exploited in our Eclipse modeling environment.

An OCL Formulation of UML2 Template Binding

After being considered only as documentation 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 model transformation chains. This is Model Driven Engineering. 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, specific constructs are introduced in order to facilitate this, such as the template notion initiated by UML1.3. Applications of this notion are growing more and more so that it was deeply revisited and strengthened in UML2. Though, its specification still lacks precision, particularly concerning the binding mechanism that allows to obtain models from templates. We propose a set of OCL constraints which strengthens the definition and helps in verifying the correctness of resulting models. These constraints apply to the UML2 metamodel and were implemented in an OCL verifier that we integrated in the Eclipse environment.

Aspectual templates in UML

UML Templates allow to capture reusable models through parameterization. The construct is general enough to be used in many ways, ranging from the representation of generic components (such as Java generics or C++ templates) to aspectual usage, including pattern-, aspect- and view-oriented modeling. We concentrate on this last usage and so-called aspectual templates which require that parameters must form a model of systems in which to inject new functionalities. Starting from this strict constraint, we derive an in-depth semantic enhancement of the standard. It is formalized as a fully UML-compliant interpretation in OCL of the template construct and its binding mechanism. In particular, this aspectual interpretation must be ensured in case of partial binding (not all parameters are valued). Partial binding of UML is a powerful technique which allows to obtain richer templates from the composition of other ones. As a major result, the present semantic enhancement is consistent with this capacity so that partial binding of aspectual templates produces aspectual templates. Finally, at an operational level, an algorithm for aspectual template (partial) binding operation is formulated and consequent reusable technology made available in EMF (Eclipse Modeling Framework) is presented.

An original view mechanism for the CORBA middleware

For the last few years, the middleware industry, and particularly the CORBA project, have strongly integrated several aspects issued from databases: persistence, transaction management, security, etc. However, most object-oriented database management systems (OODBMS) and CORBA middleware have not integrated an essential component: the notion of views which allows various users to see and manage data from different viewpoints. Views provide a semantic structuring of a schema of classes. A lot of application domains are interested in this feature; data mining is a well-known example. The paper focuses on CORBA and proposes a complete software architecture in order to provide an efficient view mechanism for this middleware. This new software architecture provides solutions about evolution problems of available data. We experienced an original use of the IDL language and the IDL compiler which consists of defining for each client (view) a subset of the global server IDL description.

A Coding Framework for Functional Adaptation of Coarse-Grained Components in Extensible EJB Servers

Separation of functional concerns is a major step for managing the complexity of large scale component systems. It allows the identification of well defined functional or non-functional dimensions in order to facilitate their assembly, adaptation and finally their reuse. Current component-based middleware and application servers offer container services that much more facilitate the reuse of the functional core throughout technical concerns, such as persistence, components distribution, transactions, security management, and so on. But they rarely offer facilities for the separation of functional concerns within this core itself. This contribution is dedicated to this question, specifically within the field of ”coarse-grained view components”. In the Information System domain, these components are common and capture ”real-world semantics”, that is a structured set of entities related to a specific functional concern. Inspired by previous works on Subject-Oriented or View-Oriented Modeling, we retain model templates as good candidates for the definition of coarse-grained reusable view components. We propose a framework to provide such components onto the EJB technology. It takes advantages of extensible containers and exploits their Aspect-Oriented Programming facilities in order to inject specific view services compatible with standard J2EE/EJB ones.

Isolating and Reusing Template Instances in UML

In MBE, design of systems can be improved and accelerated thanks to reusable models which are made available in model repositories or libraries. One answer for designing reusable models is parameterization as offered by UML templates and their binding relationship. The standard aims at embracing under the same constructs two distinct kinds of template usages, namely template instantiation and aspectual binding. Template instantiation is concerned with the capacity of UML templates to model generic components like C++ templates or Java generics and produce new models from their binding. Aspectual binding is much more concerned with the capacity of UML templates to specify functionalities to inject into models of systems contexts which must conform to a required parameter model. In this paper, we focus on the generative interpretation of UML template binding. On the basis of a deep analysis of the standard, it will be shown that template binding consists in template instantiation plus context merging. This allows to isolate the capacity of instantiating templates under their generative view to get reusable models coming from applicative contexts. Then the possibility of partial instantiation inspired by partial binding as promoted by the standard is studied. At a practical level, related functionalities are offered within Eclipse.

On submodels and submetamodels with their relation: A uniform formalization through inclusion properties

Model-driven engineering (MDE) recognized software models as first-class objects with their own relationships and operations, up to constitute full structured model spaces. We focus on inclusion capacities through the concepts of submodel and submetamodel which contribute a lot to the structuring effort. Submodels and submetamodels underlie many MDE practices which require their precise characterization for plain control. A typical application is model management as offered by model repositories. On the basis of results on submodel inclusion we stated in a preceding paper, we concentrate on the special form of submodels which are submetamodels and their specific role in model space structuring. Pointing out that relating submodels and submetamodels is two ways, their respective inclusion hierarchies will be systematically characterized and symmetrically compared under the logical relationships of metamodel membership and model well-formedness. As a major result, it will be shown that submodel well-formedness w.r.t submetamodels closely relates to submodel invariance (a property which guarantees transitive structure preservation) applied at both levels. The uniform formalization offers algebraic grounding to better comprehension and control of model spaces which underlie MDE activities. At a much more practical level, reusable technology which takes advantage of established results will be offered.