In MDE, design of systems can be improved and accelerated thanks to reusable models which are made available in model repositories or libraries. This paper focuses on the construction and exploitation of \o -the-shelf" model template bases. Model templates are parameterized models which are adaptable to various application contexts. Due to their parameterization, model templates have their own modeling space. In this paper, we present the main modeling activities that underlie this space, their dedicated engineering processes and their actors, and we contribute to the model reuse improvement by detailing new template operators for the described modeling activities. A software environment is shown to illustrate template based engineering in Eclipse.
In MDE, model reuse is a big challenge that aims to facilitate the
capitalization of design e orts and logics (\o -the-shelf" model component libraries [
Starting from these works, we focus now on the construction and exploitation of model template bases and the related engineering processes. Our objective is to increase the capacities for creating, composing and reuse templates within such bases by proposing new template operators. Resulting model spaces must be systematically characterized to master and exploit their structuring properties. After a reminder on model templates (Section 2), we present our vision of model template spaces (Section 3) and the related operators (Section 4). Then, we describe a software environment in Eclipse to construct and exploit model template spaces in UML (Section 5).
UML Templates [
In UML, template parameters form an unstructured set of model elements
so that the construct is general and permissive enough to render much of model
parameterization needs such as the modeling of generic classes (such as C++
templates) [
Figure 1 gives an example of such an enhanced template: the observer pattern template is applied to a base model (the CarHiringSystem application context) for installing functionalities between an agency and a client for observing car availability. Each substitution in the binding follows the same mechanism as the one described for the Subject and Agency bound elements: Subject is bound to Agency, so all constituents of Subject are injected in Agency.
One can observe that (1) the template parameters (see the superimposed dashed box) form the parameter model and (2) its structure is well-preserved by the substituted elements in the binding.
Subject
The previous template construct and application mechanism allow to design complex systems from assemblies of templates but also to obtain richer templates from existing ones.
On the basis of the previous model template technique, speci c modeling spaces with their engineering practices and automatic processes emerge. Fig.2 shows an illustration of such a modeling space with involved actors and activities around a model repository containing templates and models that they share.
Model Repository
In this modeling space, designers of model templates are mainly concerned with \design for reuse" and the constitution of libraries. They have to identify candidate models of functionnalities and render them as model templates for enabling their reuse. Several activities (see Fig.2) are of interest for this engineering task : { New template creation by the parameterization of unparameterized models from the selection of model constituents (activity (A)). { Composition of existing templates in order to build richer ones, by template merging or template-to-template binding (activity (B)). { Decomposition of a previously identi ed complex template which leads to identify ner ones (activity (C)). { Induction of new templates from previously designed models of systems which share common functionalities (activity (D)).
Application modelers are much concerned with \design by reuse" methodology (right of Fig.2). From template designers, they get the possibility to exploit model templates for their application needs in a safe manner through \template binding". This latter allows complex system construction by successive application of templates.
All these practices must be controlled in an homogeneous and consistent manner. This requires a precise formalization and characterization of model templates as well as their relationships and dedicated operators.
To support activities described previously, we can think of many useful
template operators. To our knowledge, there are approaches using templates [
In our previous work, we deeply studied the operators for applying templates
through substitutions of their parameters that are the apply [
Both previous operators are useful to allow a template designer to create various versions of a template, i.e. templates with the same constituents, but with di erent parameter models. This is interesting for applications designers to compose a template 1 with a model which does not need a binding with all parameter constituents. Concerning the third new operator, extract, it allows a template designer to obtain a part of template, which can be useful to extract, for instance, design patterns from others (e.g. a singleton from a factory).
We are implementing a software environment dedicated to template based model engineering in Eclipse, with plugins based on the o cial EMF (Eclipse Modeling Framework), UML and OCL plugins. They o er core functionalities to specify and verify templates well-formedness and their binding in a compliant way with UML thanks to a speci c pro le. In addition, these plugins provide original facilities to support other modeling tasks targeting templates or user assistance (e.g. signatures and bindings inference and automatic completion). All these functionalities are reusable for modeling tools handling model templates.
1For instance, representing a design pattern.
In our case, they are experimented through an in-progress case study2 in a CASE tool prototype3 (see Fig. 4).
Following main features are currently under study to support plain template
based engineering:
{ An engine for determining inclusion and typing relationships between
templates and their constituents. Such relationships should permit template
hierarchical structuring, useful to template-based activities. We are developing
this by exploiting our generic submodel engine [
In this paper, starting from our previous work, we sketch the model template modeling space and its associated engineering. This work presents new operators, a general method for developing and using the templates, and describes a workin-progress tool to support the management and use of templates.
De ning the envisioned set of operators raises a large number of issues, and
rst results with the in-progress case study shown that there are still many open
questions: the operator semantics and usages, their algebraic properties and
composition. However, more Fundamental issues need to be investigated to the
help of full template-based modeling and engineering, especially the questions
of model inclusion and model typing within the same meta-modeling space [
2The case study concerns the modeling of a REST News Server using design patterns.
3http://www.cristal.univ-lille.fr/caramel/MBE_Template/ This work will contribute to better theoretical understanding and generalization of templates for the quest of model reuse and model space structuring.