Model-driven engineering with domain-specific meta-modelling languages


Domain-specific modelling languages are normally defined through general-purpose meta-modelling languages like the MOF. While this is satisfactory for many model-driven engineering (MDE) projects, several researchers have identified the need for domain-specific meta-modelling (DSMM) languages. These provide customised domain-specific meta-modelling primitives aimed at the definition of modelling languages for a specific domain, as well as the construction of meta-model families. Unfortunately, current approaches to DSMM rely on ad hoc methods which add unnecessary complexity to the realization of DSMM in practice. Hence, the goal of this paper is to simplify the definition and usage of DSMM languages. For this purpose, we apply multi-level meta-modelling for the systematic engineering of DSMM architectures. Our method integrates techniques to control the meta-modelling primitives offered to the users of the DSMM languages, provides a flexible approach to define textual concrete syntaxes for DSMM languages, and extends existing model management languages (for model-to-model transformation, in-place transformation and code generation) to work in a multi-level setting, thus enabling the practical use of DSMM in MDE. As a proof of concept, we report on a working implementation of these ideas in the MetaDepth tool.

This is a preview of subscription content, access via your institution.

Fig. 1
Fig. 2
Fig. 3
Fig. 4
Fig. 5
Fig. 6
Fig. 7
Fig. 8
Fig. 9
Fig. 10
Fig. 11
Fig. 12
Fig. 13
Fig. 14
Fig. 15
Fig. 16
Fig. 17
Fig. 18


  1. 1.

    Potency for models is termed “level” in [8].

  2. 2.

    In a multi-level setting, we use the term “field” instead of “attribute” or “slot” as fields have both a type and an instance facet.

  3. 3.

    The linguistic meta-model shown in Fig. 3 is a simplification of a prototypical one. We will provide more details for the linguistic meta-model of our MetaDepth tool in Sect. 4. The models in this figure are also simplified/adapted with respect to Fig. 2.

  4. 4.

    Linguistic extension comes from the fact that we use the linguistic meta-model to create an element, which therefore has only linguistic type, but no ontological type.

  5. 5.

  6. 6.

  7. 7.

    Although final has potency 2, it can be assigned a value at level 1, acting as default value for all instances at level 0.

  8. 8.


  1. 1.

    Abadi, M., Cardelli, L.: A Theory of Objects. Monographs in Computer Science, Springer, New York, USA (1996)

  2. 2.

    Aschauer, T., Dauenhauer, G., Pree, W.: Representation and traversal of large clabject models. In: MoDELS’09. LNCS, vol. 5795, pp. 17–31. Springer (2009)

  3. 3.

    Asikainen, T., Männistö, T.: Nivel: a metamodelling language with a formal semantics. Softw. Syst. Model. 8(4), 521–549 (2009)

    Article  Google Scholar 

  4. 4.

    Atkinson, C.: Meta-modeling for distributed object environments. In: EDOC, pp. 90–101. IEEE Computer Society (1997)

  5. 5.

    Atkinson, C., Gerbig, R., Kennel, B.: Symbiotic general-purpose and domain-specific languages. In: ICSE’12 (New Ideas and Emerging Results track), pp. 1269–1272 (2012)

  6. 6.

    Atkinson, C., Gerbig, R., Tunjic, C.: Towards multi-level aware model transformations. In: ICMT’12. LNCS, vol. 7307, pp. 208–223. Springer (2012)

  7. 7.

    Atkinson, C., Gutheil, M., Kennel, B.: A flexible infrastructure for multilevel language engineering. IEEE Trans. Soft. Eng. 35(6), 742–755 (2009)

    Article  Google Scholar 

  8. 8.

    Atkinson, C., Kühne, T.: The essence of multilevel metamodeling. In: UML, LNCS, vol. 2185, pp. 19–33. Springer (2001)

  9. 9.

    Atkinson, C., Kühne, T.: Rearchitecting the UML infrastructure. ACM Trans. Model. Comput. Simul. 12(4), 290–321 (2002)

    Article  Google Scholar 

  10. 10.

    Atkinson, C., Kühne, T.: Model-driven development: a metamodeling foundation. IEEE Softw. 20(5), 36–41 (2003)

    Article  Google Scholar 

  11. 11.

    Atkinson, C., Kühne, T.: Reducing accidental complexity in domain models. Softw. Syst. Model. 7(3), 345–359 (2008)

    Article  Google Scholar 

  12. 12.

    de Lara, J., Guerra, E.: Deep meta-modelling with MetaDepth. In TOOLS’10, LNCS, vol. 6141, pp. 1–20. Springer (2010). See also

  13. 13.

    de Lara, J., Guerra, E.: From types to type requirements: genericity for model-driven engineering. Softw. Syst. Model. (2011, in press)

  14. 14.

    de Lara, J., Guerra, E.: Domain-specific textual meta-modelling languages for model driven engineering. In: ECMDA-FA’12. LNCS, vol. 7349, pp. 259–274. Springer (2012)

  15. 15.

    de Lara, J., Guerra, E., Cobos, R., Moreno-Llorena, J.: Extending deep meta-modelling for practical model-driven engineering. Comput. J. (2012, in press)

  16. 16.

    Demuth, A., Lopez-Herrejon, R.E., Egyed, A.: Cross-layer modeler: a tool for flexible multilevel modeling with consistency checking. In: SIGSOFT FSE, pp. 452–455. ACM (2011)

  17. 17.

    Drivalos, N., Kolovos, D.S., Paige, R.F., Fernandes, K.J.: Engineering a DSL for software traceability. In: SLE’08, LNCS, vol. 5452, pp. 151–167. Springer (2008)

  18. 18.

    Epsilon: (2012)

  19. 19.

    Espinazo-Pagán, J., Tortosa, M.M., Molina, J.G.: Metamodel syntactic sheets: an approach for defining textual concrete syntaxes. In: ECMDA-FA’08. LNCS, vol. 5095, pp. 185–199. Springer (2008)

  20. 20.

    Gonzalez-Perez, C., Henderson-Sellers, B.: A powertype-based metamodelling framework. Softw. Syst. Model. 5(1), 72–90 (2006)

    Article  Google Scholar 

  21. 21.

    Gonzalez-Perez, C., Henderson-Sellers, B.: Modelling software development methodologies: a conceptual foundation. J. Syst. Softw. 80(11), 1778–1796 (2007)

    Article  Google Scholar 

  22. 22.

    Günther, C.W.: Xes 1.0 extensible event system standard definition. Technical report (2009). See also

  23. 23.

    Herrmannsdörfer, M., Hummel, B.: Library concepts for model reuse. Electron. Notes Theor. Comput. Sci. 253, 121–134 (2010)

    Article  Google Scholar 

  24. 24.

    Holt, J.: A Pragmatic Guide to Business Process Modelling (2nd edn). British Informatics Society Ltd, Chippenham, UK (2009)

  25. 25.

    Jablonski, S., Volz, B., Dornstauder, S.: A meta modeling framework for domain specific process management. In: COMPSAC’08, pp. 1011–1016. IEEE Computer Society (2008)

  26. 26.

    Jarke, M., Gallersdörfer, R., Jeusfeld, M.A., Staudt, M.: ConceptBase—a deductive object base for meta data management. J. Intell. Inf. Syst. 4(2), 167–192 (1995)

    Article  Google Scholar 

  27. 27.

    Jouault, F., Bézivin, J., Kurtev, I.: TCS: a DSL for the specification of textual concrete syntaxes in model engineering. In: GPCE’06, pp. 249–254. ACM (2006)

  28. 28.

    Kelly, S., Tolvanen, J.-P.: Domain-Specific Modeling: Enabling Full Code Generation. Wiley-IEEE CS, Hoboken, New Jersey, USA (2008)

  29. 29.

    Kolovos, D.S., Paige, R.F., Polack, F.: The Epsilon Object Language (EOL). In: ECMDA-FA’06. LNCS, vol. 4066, pp. 128–142. Springer (2006)

  30. 30.

    Kolovos, D.S., Paige, R.F., Polack, F.: The Epsilon Transformation Language. In: ICMT’08. LNCS, vol. 5063, pp. 46–60. Springer (2008)

  31. 31.

    Kühne, T., Schreiber, D.: Can programming be liberated from the two-level style? Multi-level programming with DeepJava. In: OOPSLA’07, pp. 229–244. ACM (2007)

  32. 32.

    Langer, P., Wieland, K., Wimmer, M., Cabot, J.: From UML profiles to EMF profiles and beyond. In: TOOLS’11. LNCS, vol. 6705, pp. 52–67. Springer (2011)

  33. 33.

    Liu, L., Jeusfeld, M.A.: Suitability of active rules for model transformation. In: CAiSE Forum, CEUR Workshop Proceedings, vol. 855, pp. 131–138 (2012)

  34. 34.

    Murata, T.: Petri nets: Properties, analysis and applications. Proc. IEEE 77(4), 541–580 (1989)

    Article  Google Scholar 

  35. 35.

    Mylopoulos, J., Borgida, A., Jarke, M., Koubarakis, M.: Telos: representing knowledge about information systems. ACM Trans. Inf. Syst. 8(4), 325–362 (1990)

    Google Scholar 

  36. 36.

    Odell, J.: Power types. JOOP 7(2), 8–12 (1994)

    MathSciNet  Google Scholar 

  37. 37.

    OMG: MOF 2.4.1. (2011)

  38. 38.

    OMG: OCL 2.3.1. (2012)

  39. 39.

    OMG: MDA home page. (2013)

  40. 40.

    Rose, L.M., Paige, R.F., Kolovos, D.S., Polack, F.: The Epsilon Generation Language. In: ECMDA-FA’08, LNCS, vol. 5095, pp. 1–16. Springer (2008)

  41. 41.

    Sánchez Cuadrado, J.: Towards a family of model transformation languages. In: ICMT’12, LNCS, vol. 7307, pp. 176–191. Springer (2012) See also

  42. 42.

    Sánchez Cuadrado, J., de Lara, J., Guerra, E.: Bottom-up meta-modelling: an interactive approach. In: MoDELS, LNCS, vol. 7590, pp. 3–19. Springer (2012)

  43. 43.

    Sánchez Cuadrado, J., Guerra, E., de Lara, J.: Generic model transformations: write once, reuse everywhere. In: ICMT, LNCS, vol. 6707, pp. 62–77. Springer (2011)

  44. 44.

    Sánchez Cuadrado J., Guerra E., de Lara J.: Flexible model-to-model transformation templates: an application to ATL. J. Object Technol. 11(2), 4:1–28 (2012)

  45. 45.

    Sen, S., Moha, N., Mahé, V., Barais, O., Baudry, B., Jézéquel, J.-M.: Reusable model transformations. Softw. Syst. Model. 11(1), 111–125 (2012)

    Google Scholar 

  46. 46.

    Steel, J., Duddy, K., Drogemuller, R.: A transformation workbench for building information models. In: ICMT. LNCS, vol. 6707, pp. 93–107. Springer (2011)

  47. 47.

    Steel, J., Jézéquel, J.-M.: On model typing. Softw. Syst. Model. 6(4), 401–413 (2007)

    Article  Google Scholar 

  48. 48.

    Volz, B., Jablonski, S.: Towards an open meta modeling environment. In: 10th Workshop on Domain-Specific Modeling (2010)

  49. 49.

    Wimmer, M., Kappel, G., Kusel, A., Retschitzegger, W., Schönböck, J., Schwinger, W., Kolovos, D., Paige, R., Lauder, M., Schürr, A., Wagelaar, D.: Surveying rule inheritance in model-to-model transformation languages. J. Object Technol. 11(2), 3:1–46 (2012)

    Google Scholar 

  50. 50.

    Zschaler, S., Kolovos, D.S., Drivalos, N., Paige, R.F., Rashid, A.: Domain-specific metamodelling languages for software language engineering. In: SLE’09. LNCS, vol. 5969, pp. 334–353. Springer (2009)

Download references


We thank the referees for their detailed and useful comments. This work has been funded by the Spanish Ministry of Economy and Competitivity with project “Go Lite” (TIN2011-24139), and the R&D programme of Madrid Region with project “eMadrid” (S2009/TIC-1650).

Author information



Corresponding author

Correspondence to Juan de Lara.

Additional information

Communicated by Dr. Antonio Vallecillo and Dr. Juha-Pekka Tolvanen.


Appendix A

This appendix provides a formal definition of potency, linguistic typing, and ontological typing. For simplicity, we just consider clabjects and fields, which suffices to illustrate the main concepts of our framework.

Definition 1

(Model) A model \(M=\langle CL, fields, FI \rangle \) is made of:

  • a set \(CL\) of clabjects,

  • a set \(FI\) of fields,

  • a total function \(fields :CL \rightarrow 2^{FI}\) assigning to each clabject \(c\) a (perhaps empty) set \(fields(c)\) of its owned fields, s.t. \(\forall f \in FI~\exists _1 c \in CL\) with \(f \in fields(c)\) (every field belongs to exactly one clabject).


We use \(2^{FI}\) to denote the set of all subsets of \(FI\) (its powerset). We sometimes use \(cl(M)\) to denote \(CL\), the set of clabjects of \(M\), and \(fi(M)\) to denote \(FI\), the set of fields included in clabjects of \(M\).

We write \(U = \{ M_i=\langle CL_i, fields_i, FI_i \rangle \}_{i \in I}\) for the set of all possible models, which we sometimes call the universal set of models.

Next, we define the potency for models, clabjects, and fields as a family of functions to the natural numbers, including zero. The potency of clabjects should not be bigger than the potency of their enclosing model, and the potency of fields should not be bigger than the potency of their owner clabject. Having fields with potency bigger than their owning clabject may be useful in models with inheritance [15], but we omit inheritance in this formalization for simplicity.

Definition 2

(Potency) Given the universal set \(U\), the potency \(pot_U=\langle pot, \{ pot^i \}_{i\in I}\rangle \) is defined as:

  • a total function \(pot :U \rightarrow \mathbb N _0\) assigning each model \(M_i\) a positive number, or zero;

  • a family of total functions \(\{pot^i :CL_i \cup FI_i \rightarrow \mathbb N _0\}_{i \in I}\) for each model \(M_i \in U\), assigning each clabject and field a positive number or zero, s.t. \(\forall c \in CL_i\), \(pot^i(c) \le pot(M_i)\), and \(\forall f \in fields_i(c)\), \(pot^i(f) \le pot^i(c)\).


Potency for models is named level in [8].

In order to define the linguistic typing, we assume a very simple linguistic meta-model \(L_{MM}=\{MODEL, CLABJECT, FIELD\}\). Then, the linguistic type is a family of total functions with co-domain \(L_{MM}\), as shown in the next definition.

Definition 3

(Linguistic typing) Given the universal set \(U\), the linguistic typing \(ltype_U=\langle ltype, \{ltype^i\}_{i\in I}\rangle \) is defined as:

  • a total function \(ltype :U \rightarrow L_{MM}\), s.t. \(\forall M_i \in U, ltype(M_i) = MODEL\);

  • a family of total functions \(\{ltype^i :CL_i \cup FI_i \rightarrow L_{MM}\}_{i \!\in \! I}\) for each model \(M_i \in U\), s.t. \(\forall c\in CL_i~ltype^i(c)=CLABJECT\), and \(\forall f\in FI_i~ltype^i(f)=FIELD\).


For the potency and the linguistic typing, we sometimes use \(pot\) and \(ltype\) (without the superindex) for clabjects and fields when no confusion arises.

Next, we define the ontological typing as a family of partial functions.

Definition 4

(Ontological typing) Given the universal set \(U = \{ M_i=\langle CL_i, fields_i, FI_i \rangle \}_{i \in I}\), with \(CL=\uplus _{i \in I} CL_i\), \(FI=\uplus _{i \in I} FI_i\), the ontological typing \(otype_U=\langle otype, \{ otype^i \}_{i\in I}\rangle \) is made of:

  • a partial function \(otype :U \rightarrow U\) assigning each model \(M_i\) its ontological model type \(otype(M_i)\);

  • a family of partial functions \(\{otype^i :CL \cup FI \rightarrow CL \cup FI\}_{i \in I}\),

s.t. \(otype_U\) fulfils the following well-formedness rules, \(\forall M_i \in U\):

  1. 1.

    \(otype(M_i)=M^{\prime } \Rightarrow pot(M_i)+1=pot(M^{\prime })\),

  2. 2.

    \(\forall c \in CL_i\), \(otype^i(c)=c^{\prime } \Rightarrow \) \(~~~~c^{\prime } \in CL\) (clabjects are typed by clabjects),

  3. 3.

    \(\forall f \in FI_i\), \(otype^i(f)=f^{\prime } \Rightarrow \) \(~~~~f^{\prime } \in FI\) (fields are typed by fields),

  4. 4.

    \(\forall c \in CL_i\), \(otype^i(c) = c^{\prime } \Rightarrow \) \(~~~~[ c^{\prime } \in cl(otype(M_i)) \wedge pot(c)+1 = pot(c^{\prime })~\wedge \) \(~~~~~~\forall f^{\prime } \in fields(c^{\prime })~s.t.~pot(f^{\prime })>0\) \(~~~~~~~~\exists _1 f\in fields(c)\) s.t. \(~~~~~~~~~[otype^i(f)=f^{\prime }~\wedge ~pot(f)+1=pot(f^{\prime })]~]\)

  5. 5.

    \(\forall f \in FI_i\), \(otype^i(f)=f^{\prime } \Rightarrow \) \(~~~~[~\exists c, c^{\prime }~s.t.~otype(c)=c^{\prime }~\wedge ~\) \(~~~~~~~f\in fields(c)~\wedge ~f^{\prime }\in fields(c^{\prime })\) \(~~~~~~~~\wedge ~pot(f)+1=pot(f^{\prime })]\)

  6. 6.

    \(pot(M_i)=0 \Rightarrow \exists M^{\prime } \in U~s.t.~otype(M_i)=M^{\prime }\)

  7. 7.

    \(\forall c \in CL_i~[~pot^i(c)=0\Rightarrow \) \(~~~~\exists c^{\prime } \in cl(otype(M_i))~s.t.~otype(c)=c^{\prime }~]\)

  8. 8.

    \(\forall f \in FI_i~[~pot^i(f)=0\Rightarrow \) \(~~~~\exists f^{\prime } \in fi(otype(M_i))~s.t.~otype(f)=f^{\prime }~]\)


We use \(\uplus \) for disjoint union.


The first condition states that the potency of \(M_i\) is one less than the potency of its ontological model type \(M^{\prime }\). The second and third conditions state that clabjects and fields should be typed by clabjects and fields, respectively. The second condition is subsumed by the fourth, but we explicitly state it for clarity. The fourth condition states that if a clabject \(c\) has \(c^{\prime }\) as ontological type, then its potency is one less. As the codomain of the potency is \(\mathbb N _0\), we have that elements with potency zero cannot be instantiated. The fourth condition also requires every field of \(c^{\prime }\) with potency bigger than zero to be instantiated in \(c\). The fifth condition is a compatibility condition specifying that if the ontological type of a field \(f\) is \(f^{\prime }\), then the ontological type of the owner of \(f\) is the owner of \(f^{\prime }\). The last three conditions state that elements with potency zero should have an ontological type.

The previous definition of ontological typing reduces to the standard conformance relation in a two meta-levels setting, if we restrict the potency function to the set \(\{0, 1\} \subset \mathbb N _0\), where models with potency 1 are the meta-models and those with potency 0 the models. However, model self-typing (i.e. a model whose ontological type is itself, as suggested in the OMG’s MDA [39]) is not allowed in this formalization due to the requirement of the potency decrease in the model instances. Instead, we require top-level models to lack an ontological type and have a linguistic type only. Hence, the linguistic meta-model plays the role of the MOF in this architecture.

Next, we use the previous definitions to characterize linguistic extensions as elements with no ontological type.

Definition 5

(Linguistic extension) Given the universal set \(U = \{ M_i=\langle CL_i, fields_i, FI_i \rangle \}_{i \in I}\), and an ontological typing \(otype_U=\langle otype, \{ otype^i \}_{i\in I}\rangle \), the linguistic extensions \(LE_j\) of \(M_j \in U\) are defined as the tuple \(LE_j =\langle CL^{\prime }_j \subseteq CL_j, fields_j|_{CL^{\prime }_j}, FI^{\prime }_j \subseteq FI_j\rangle \) s.t.:

  • \(\forall c^{\prime } \in CL^{\prime }_j\) \(otype(c^{\prime })\) is undefined,

  • \(\forall c \in CL_j {\setminus } CL^{\prime }_j\) \(otype(c)\) is defined,

  • \(\forall f^{\prime } \in FI^{\prime }_j\) \(otype(f^{\prime })\) is undefined,

  • \(\forall f \in FI_j {\setminus } FI^{\prime }_j\) \(otype(f)\) is defined.


Function \(otype^i\) partitions \(CL_i\) and \(FI_i\) into the set of ontologically typed clabjects and fields (\(CL_i {\setminus } CL^{\prime }_i\) and \(FI_i {\setminus } FI^{\prime }_i\)) and the linguistic extensions (\(CL^{\prime }_i\) and \(FI^{\prime }_i\)). Note that \(LE_j\) may fail to be a model, according to Definition 1, because some field without ontological type (belonging to \(FI^{\prime }_j\)) may be owned by a clabject with ontological typing (not belonging to \(CL^{\prime }_j\)). In any case, every element \(M_i\in U\) is a correct model according to our framework.

Due to the fifth condition in Definition 4, we have that if a clabject has no ontological type, then no owned field can have an ontological type. Conversely, it is allowed to have fields with no ontological type, owned by clabjects with ontological type.

Appendix B

This appendix provides complete listings for the running example presented in Sect. 5.


Rights and permissions

Reprints and Permissions

About this article

Cite this article

de Lara, J., Guerra, E. & Cuadrado, J.S. Model-driven engineering with domain-specific meta-modelling languages. Softw Syst Model 14, 429–459 (2015).

Download citation


  • Model-driven engineering
  • Multi-level meta-modelling
  • Domain-specific meta-modelling
  • Textual concrete syntax
  • MetaDepth