Mapping features to models is a necessary step when developing software product lines of
models. In such product lines, we need to relate objects from feature models (i.e. features) to
objects from model templates. In this use case we show an extension to the AMW platform to
specify those relations through weaving models.
This use case was developed by OpenCanarias company.
One of the possible synergies between software product lines and model driven engineering is the use of
software product lines of models [1, 2]. In these product lines, family members are models, which are
characterized using features from a feature model.
The superimposed variants approach  is a technique to implement such product lines. It is based on the
creation of a model template containing the family members in a superimposed way. The specialization of
the template gives rises to the different members. This specialization is done by purging model template
objects following the selection of features from a feature model (feature configuration). This technique
requires mechanisms to relate features from the feature model to model template objects.
One approach consists in annotating model template objects with presence conditions and meta-expressions referring to
However, this raises several problems, such as the pollution of the model template
with annotations . An alternative approach is to use a domain-specific language to describe mappings
between features and model template objects; that is the case of MTTL (Model Template Transformation
Language) , a domain specific transformation language that specifies the specialization of model
templates following feature configurations.
In this use case we present WMM_MTTL, an extension to a core weaving metamodel
that implements MTTL using the AMW plug-in. The general approach is shown in the figure below.
Let's call Request Management Systems (RMS) those systems which, within the public
administration domain, manage citizen's requests. In our experience, those systems share many
commonalities; therefore, we can improve productivity by reusing software artifacts in their
development. In this case study we propose to take advantage of our knowledge about
commonalities and variabilities between UML use case models in the RMS domain. In this document
we show a first step towards the development of a software product line for the maintenance of a
family of use case models that covers any variant of RMS.
The infrastructure of a software product line is created during the domain engineering (or software
product line engineering). The first step is a domain analysis, performed by the
domain engineer through a commonality and variability analysis in order to set the scope of the
product line. The result is a feature model.
The second step is the domain design and implementation, where the domain engineer designs and
implements reusable assets that will help in the development of every member of the model family.
Following a superimposed variants approach, the domain engineer creates a model template
containing all use case model variants in a superimposed form.
At the same time, the domain
engineer especifies how to transform or to specialize such a template as to obtain every family
member. We use WMM_MTTL, our implementation of MTTL , as a metamodel extension
of AMW. Following a MDA (Model-Driven Architecture) approach, the domain engineer
transforms instances of WMM_MTTL into any general-purpose transformation language (GPTL), such as ATC  or ATL .
We address an intentionally reduced scope for our software
product line. In particular, only eight use case model variants will be taken into account during the
domain analysis. We characterize them using a feature model with six mandatory, optional and
alternative features. The feature model conforms to the Cardinality-Based Feature Model from .
Cardinality [0..1] identifies optional features and cardinality [1..1]
mandatory ones. There is only one feature group, with cardinality <1-1>, i.e. made of two alternative
features where one and only one of them must be selected. By selecting alternative and optional
features from this feature model we obtain eight different feature configurations, each of them
corresponding to a member of the use case model family.
Taking a superimposed variants approach to model template creation, we include within the same
use case model the eight use case model variants in a superimposed form. In other words, we
include in the model template all objects belonging to any of the members of the model family. The
use case model depicted below represents such a model template, whose specialization gives
rise to the different family members.
Feature model (CBFM)
The screenshot below depicts a WMM_MTTL weaving model with six mappings between the feature model
(left) and the model template (right). For example, the first mapping (highlighted) specifies the purge of the
relation between objects Staff Member and Validate Request from the
model template when the feature Request Validation is not found in a
Use case model template (UML2)
WMM_MTTL model edited in AMW
This technical report explains this use case in more details, with the feature models and use case template models.
This is a complete example with a WMM_MTTL transformation developed in the AMW plug-in.
 K. Czarnecki and M. Antkiewicz: Mapping Features to Models: A Template Approach Based on
Superimposed Variants. In GPCE'05: Proceedings of the Fourth International Conference on Generative
Programming and Component Engineering. Springer-Verlag, LNCS 3676, pages 422-437. September 2005.
 O. Avila-García, A. Estévez García, E.V. Sánchez Rebull and J.L. Roda García: Using Software Product
Lines to Manage Model Families in Model-Driven Engineering. In ACM SAC 2007: Proceedings of The 22nd
Annual ACM Symposium on Applied Computing - Model Transformation Track. ACM Press, pages 1006-
1011. March 2007.
 K. Czarnecki, S. Helsen, and U. Eisenecker. Staged Configuration Through Specialization and Multi-Level
Configuration of Feature Models. Software Process Improvement and Practice, special issue on "Software
Variability: Process and Management”, 10(2), 2005, pp. 143 – 169.
 A. Estévez García, J. Padrón, E.V. Sánchez Rebull and J.L. Roda García: ATC: A Low-level model
transformation language. In MDEIS 2006: Proceedings of the 2nd International Workshop on
Model Driven Enterprise Information Systems. May 2006.
 F. Jouault and I. Kurtev: On the Architectural Alignment of ATL and QVT. In ACM SAC 2006:
Proceedings of The 21st Annual ACM Symposium on Applied Computing. ACM Press. April 2006.