Towards a Visualization of Multi-level Metamodeling Techniques

andor B

acsi and Gergely Mezei

Department of Automation and Applied Informatics, Budapest University of Technology and Economics,

Magyar tud

osok krt. 2., H-1117 Budapest, Hungary

Keywords:

Multi-level Modeling, Metamodeling, Dynamic Instantiation, Visual Language, Visualization.

Abstract:

In the recent decade, a wide range of tools and methodologies have been introduced in the ﬁeld of multi-level

metamodeling. One of the newest approaches is the Dynamic Multi-Layer Algebra (DMLA). DMLA incor-

porates a fully self-modeled textual operation language above the tuple-based model entity representation.

This textual language simpliﬁes editing the models, but it has its drawbacks especially in following evolv-

ing requirements. In this paper, we introduce a visualization concept, which can support the more effective

manipulation of the particular model and facilitate the process of multi-level metamodeling within DMLA.

1 INTRODUCTION

In the software industry, the development of applica-

tions routinely begins with setting up the most rele-

vant design aspects based upon the main requirements

of the given project. Stakeholders and customers try

to specify their needs and expectations at the begin-

ning of the project, but in most cases these initial re-

quirements change during later phases of the devel-

opment. Nevertheless, the most relevant design deci-

sions must be made at this early stage of the develop-

ment leaving concrete implementation later.

In the early phase of the development, the soft-

ware model is ﬂexible because of the high-level speci-

ﬁcation. As the project evolves, the requirements may

change, thus new constraints and properties may re-

duce the original ﬂexibility of the software model. In

many domain problems, it would be useful to support

this evolutionary nature of software development by

applying model-based solutions.

Mainstream metamodel based methods and tech-

niques have been applied in real industrial cases sev-

eral times, for example in the ﬁeld of IoT and manage-

ment of telecommunication systems. It turned out that

these approaches may have their drawbacks, since

several problem settings cannot be solved expres-

sively and ﬂexibly with classic metamodeling tech-

niques. Most of the current metamodel based solu-

tions have difﬁculties with supporting the evolution

of the domain-model during the lifecycle.

One of the new branches of metamodeling focus

on multi-level metamodels. By increasing the num-

ber of modeling levels, we can obtain an environ-

ment, where the deﬁnition of domain concepts are

composed of ﬁne graded steps simplifying thus the

customization of the domain. However, there is no

consensus in the literature on the exact meaning of the

methodology and there are no widely accepted prin-

ciples, which makes practical application hard.

In the recent years, several new approaches and

methodologies have been introduced or suggested

by researchers to support the process of multi-level

metamodeling. One of these approaches is the Dy-

namic Multi-Layer Algebra (DMLA), which is a ﬂex-

ible, self-validation and formal multi-level modeling

framework. In DMLA, all model elements are stored

as 4-tuples and all operations are applied on these tu-

ples. DMLA incorporates a fully self-modeled textual

operation language (DMLAScript) above the 4-tuple

representation, which provides a user-friendly inter-

face to reach and manipulate the tuples. Due to the

initial concepts and the textual representation, DM-

LAScript has its drawbacks in the effective manipu-

lation of the domain model, especially when focus-

ing on realistic, evolutionary model editing. In this

paper, we point out these drawbacks and introduce a

visualization concept, which can facilitate the process

of multi-level metamodeling on a higher abstraction

level. Although the concept is related to DMLA, the

main principles are more general and can be beneﬁ-

cial for any multi-level visualization environment.

The paper is organized as follows: Section 2

presents the background and the related work. Sec-

tion 3 introduces the DMLA approach in order to give

Bácsi, S. and Mezei, G.

Towards a Visualization of Multi-level Metamodeling Techniques.

DOI: 10.5220/0006915603550362

In Proceedings of the 13th International Conference on Software Technologies (ICSOFT 2018), pages 355-362

ISBN: 978-989-758-320-9

355

clear and precise understanding of the main concepts.

Section 4 elaborates our method, while concluding re-

marks are outlined in Section 5.

2 RELATED WORK

In this section, we summarize the most relevant ap-

proaches in the ﬁeld of multi-level metamodeling and

we give a general overview on advantages of visual

languages in different problem domains. We also

summarize existing visualization approaches regard-

ing multi-level metamodeling.

2.1 Multi-level Metamodeling

Approaches

OMG’s Meta-Object Facility (OMG, 2005) (MOF)

is often referred to as the de-facto standard for imple-

menting metamodel based solutions. MOF provides

a four-layer architecture, which can be satisfying for

most of the problems. However, alternative as multi-

level solutions pointed out (Atkinson et al., 2014), it

is not always enough neither in ﬂexibility nor focus-

ing on the preciosity. To overcome the weaknesses

of MOF, n-level metamodeling has gained increasing

popularity in the last decade. Here, it is worth to ex-

plicitly differentiate between linguistic and ontologi-

cal metamodeling based upon separate linguistic and

ontological instance-of relations. Several approaches

also differentiate between shallow and deep instanti-

ation. Shallow instantiation means that the domain

information is available exactly one modeling layer

below its deﬁnition. In opposition to shallow instanti-

ation, deep instantiation means that the domain infor-

mation may be used at layers below as well according

to its parametrization.

One of the most relevant deep instantiation tech-

niques is the so called potency notion (Atkinson and

uhne, 2001). Here, a potency is assigned to each

model entities. The assigned potency value represents

the number of model levels the certain element can

get through before reaching its fully instantiated state.

Melanee (Atkinson and Gerbig, 2016), (Gerbig et al.,

2016) is a deep modeling tool based upon the concept

of orthogonal classiﬁcation and potency notion.

Another remarkable deep modeling methodol-

ogy is the Lazy Initialization Multilayered Modeling

Framework (Golra and Dagnat, 2011). This frame-

work provides an object oriented modeling language,

which is based on lazy instantiation. Lazy initializa-

tion can facilitate to manage the instance-of relation-

ships between the layers and their classiﬁcation.

The (metaDepth (de Lara and Guerra, 2010) and

XModeler (XModeler, 2014)), are also multi-level

metamodeling approaches. Besides the modeling

structure, they provide an operation language as well,

which allows the creation of operations within the

multi-level metamodeling workbench. In metaDepth,

both Java and EOL (EOL, 2007) can be used to spec-

ify actions and constraints. XModeler provides an ex-

ecutable programming language, XOCL (Clark and

Willans, 2012), which is based on OCL.

2.2 The Beneﬁts of Visualization

Domain-speciﬁc languages (DSLs) are specialized

modeling languages that allow the effective manage-

ment of the behavior and the structure of software

programs and systems in a speciﬁc domain. DSLs

provide an improved abstraction of the problem that

allows the rapid development of the targeted domain.

Visual DSLs, compared to textual DSLs, can further

improve the expressiveness and the usability of the

model.

There are several advantages of using a visual

DSL. The richness of the visual representation can

simplify the modeling process and increase ﬂexibil-

ity, thus visual DSLs can be intuitively usable even for

complex language constructs. Visual DSLs also pro-

vide high-level abstractions to manipulate the struc-

ture and the functioning of the given model. On the

other hand, visualization can facilitate to understand

the concepts and the main relations in the targeted do-

main. It can be easier to explain the main characteris-

tics of a domain problem by using visual notations.

There are visual DSLs e.g., (Simon et al., 2017),

(Bottoni and Ceriani, 2015) which can ensure that

users without technical skills can be more closely

involved in the targeted domain. In other domains

(Wienands and Golm, 2009), it can be beneﬁcial to

use the combination of a textual and a visual DSL.

The visual form of the well-known UML diagrams

can facilitate the customization of the modeling ele-

ments and interactions in a more ﬂexible way, espe-

cially in design-time.

To sum up, a visual DSL can be beneﬁcial to rep-

resent and manage existing abstractions. Each prob-

lem domain requires a different visual representa-

tion to meet the requirements of the targeted domain,

therefore it is essential to choose the most appropriate

representational concepts in design-time. Obviously,

not all domain problems can be solved expressively

and ﬂexibly using visual DSLs. Hence, it is worth

considering the use of visual DSLs depending on the

characteristics of the targeted domain.

Recently, the demand for an appropriate visual-

ICSOFT 2018 - 13th International Conference on Software Technologies

356

ization has arisen also in the ﬁeld of multi-level meta-

modeling. XModeler (Clark et al., 2015) provides

a visual editor to support the process of multi-level

modeling. As a concrete syntax, there is a named

box notation in XModeler’s visual editor, which rep-

resents the class of the given entity. Hence, it is pos-

sible to navigate among instances and class declara-

tions. XModeler has a color node notation as well in

order to be able to distinguish the levels of type ab-

straction. The header of each class has a speciﬁed

background color to express the appropriate level of

type abstraction.

Melanee provides a diagrammatic workbench to

facilitate the process of deep-modeling. The Mela-

nee workbench uses clabject (Gerbig et al., 2016) no-

tations and provides a wide range of tools to build

a deep-model. The main advantage of the Melanee

workbench is the dynamic display of the currently us-

able types. The deep-model can be edited by using

both the textual and the visual editor.

3 DMLA IN A NUTSHELL

Dynamic Multi-Layer Algebra (DMLA) (DMLA,

2015) is a multi-level modeling framework based on

the Abstract State Machines (ASM) (Egon Brger,

2003) formalism. DMLA consists of two major parts:

(i) the Core, a formal deﬁnition of the modeling struc-

ture and its management functions; (ii) the Boostrap,

an initial set of pre-deﬁned modeling entities.

Each model is represented as a Labeled Directed

Graph, where all model elements have four labels. Ta-

ble 1 shows the labels with their short descriptions.

Table 1: 4-tuple representation.

Label Description

globally unique ID of model element

Meta

a reference to the meta of the element

Values

a list of concrete values

Attributes

a list of contained attributes

Besides the 4-tuples representing the model en-

tities, there exist functions to manipulate the model

graph, for example, to create new model entities.

These deﬁnitions form the Core of DMLA, which

is speciﬁed over an Abstract State Machine (ASM).

Thus, in DMLA, the states of the state machine are

snapshots of the dynamically evolving models, while

transitions (e.g. deleting a node) represent modiﬁca-

tion actions between those states.

The elements of the Boostrap can facilitate the

adaptation of DMLA’s modeling structure to existing

domains. The main idea behind separating the Core

and the Bootstrap is to improve ﬂexibility, but also to

keep the approach formal. This way, the Bootstrap

becomes swappable, thus even the semantics of valid

instantiation can be re-deﬁned. Namely, each particu-

lar bootstrap seeds the metamodeling facilities of the

generic DMLA formalism.

The modeling entities of the current bootstrap

(Fig.1) can be categorized into four groups: (i) ba-

sic types (blue boxes) providing a basic structure for

multi-level metamodeling, (ii) built-in types (purple

boxes) representing the primitive types available in

DMLA, (iii) entities facilitating the introduction of

operations into DMLA (green boxes), and (iv) vali-

dation related entities (red boxes).

For the sake of compactness, we give only a short

overview of the modeling structure here. For more

details check the DMLA website (DMLA, 2015). Ba-

sic entities are the basic building blocks of the mod-

eling process. The most important among them is the

Base entity, which is at the root of the meta hierar-

chy. Hence, all other model entities are instantiated

from Base entity. ConstraintContainers (and the Con-

straints contained) are used to customize instantiation

validation. At this point, we should discuss the vali-

dation mechanism: whenever a model entity claims

another entity to be its meta, the framework auto-

matically validates if there is indeed a valid instan-

tiation between the two. The validation formulae can

be modularized by introducing them directly into the

Bootstrap. Since these formulae directly inﬂuence the

actual semantics of instantiation, every model valida-

tion gets modularized and DMLAs instantiation be-

comes effectively self-deﬁned by the model per se.

The SlotDef entity is a direct instantiation of Base. It

is used to deﬁne slots, which represent substitutable

properties, in syntactically similar manner to class

members in OO languages. Slots can contain Con-

straintContainers, which grants them the capability

to attach constraints to the containment relations de-

ﬁned by the slot. Base deﬁnes that entities can have

slots, thus any direct or indirect instance of Base will

inherit this behavior. The Entity entity is another di-

rect instance of Base. Entity is used as the common

meta of all primitive and user-deﬁned types. Entity

has two instances: Primitive (for primitive types) and

ComplexEntity (for custom types).

The core entities needed to represent the universes

of ASM in the bootstrap are: Bool, Number and

String. All these types refer to sets of values in the

corresponding universe. For example, we create en-

tity Bool so that it could be used to represent Boolean

type expressions. Built-in types are relied on when

a slot is ﬁlled by a concrete value and that value is

not a reference to another model entity, however it is

Towards a Visualization of Multi-level Metamodeling Techniques

357

Figure 1: The elements of the current Bootsrap.

a primitive, atomic value. All built-in types are in-

stances of Primitive.

Operations are responsible for changing the be-

havior of the entities in their sub-branches of the

meta-tree. In other words, new entities within the

model may provide their own specialized deﬁnition

of valid instantiation, provided they do not contradict

the standard validation rules imposed by Base.

DMLA incorporates a fully self-modeled textual

operation language above DMLA’s 4-tuple represen-

tation, DMLAScript, which has its drawbacks in the

manipulation of the operations within DMLA. In this

paper, we introduce a visualization concept, which

can facilitate the process of multi-level metamodeling

in DMLA.

4 TOWARDS VISUALIZATION

In this section, we summarize the most relevant con-

cepts regarding the visual workbench for DMLA. In

the ﬁrst subsection, we show the justiﬁcation of the

visualization, while the main concepts are outlined in

the latter subsections.

4.1 The Justiﬁcation of the Visualization

As the number of multi-level metamodeling ap-

proaches is increasing, there is growing debate in

the literature about the exact meaning of the multi-

level metamodeling methodology and there are no

widely accepted principles. Hence, there is no de-

facto standard for multi-level metamodeling and ev-

ery approach has different capabilities. This is the

main reason why the multi-level committee has cre-

ated the so called Bicycle challenge (MULTI 2017,

2017) to investigate the strengths and drawbacks of

the different multi-level approaches. The challenge is

also intended as a basis for demonstrating the beneﬁts

of multi-level modeling. Recently, we have resolved

the Bicycle challenge, to investigate the capabilities

of DMLA. While working on this challenge with DM-

LAScript, we have realized several drawbacks of the

practical application of DMLAScript. Different sce-

narios show different problems regarding the use of

the textual DMLAScript. In the following, we sum-

marize the relevant scenarios and drawbacks which

we have investigated.

The drawbacks can be categorized into two

groups: (i) The management of the relations among

entities; (ii) Refactoring and editing of certain enti-

ties. Group (i) contains drawbacks which affect the

management and the manipulation of the relations

among entities. Group (ii) contains drawbacks regard-

ing the effective editing of certain entities.

4.1.1 Managing the Relations Among Entities

Here, we present the drawbacks regarding the man-

agement of the relations among entities:

• Lack of fragmentation: In a textual description

document of the model, it can be inconvenient

to trace relations between modeling entities based

upon speciﬁcation or the containment because of

the lack of fragmentation and structuralism.

• Navigation through meta-hierarchy: In design-

time, it can be essential to navigate up or down

on the relevant part of the hierarchy in order to

get more information about a certain entity. In

a textual description, it is not possible navigat-

ing through the meta-hierarchy in a seamless way,

therefore the modeling process can be uncomfort-

able in design-time.

ICSOFT 2018 - 13th International Conference on Software Technologies

358

• Semantics based grouping: Having met with a

large number of modeling entities can be confus-

ing and impenetrable. It would be advantageous

to have a precise view of the relevant entities in

design-time.

A visual DSL can provide a set of features to solve

the problems mentioned in this section. The Lack

of fragmentation and the Navigation through meta-

hierarchy can be easily resolved, because a well-

established concrete syntax of a visual DSL can pro-

vide structuralism and facilitate the seamless navi-

gation through the meta-hierarchy. Different views

and ﬁlters can display the expected set of modeling

elements, thus Semantics based grouping can be re-

solved by applying appropriate views.

4.1.2 Refactoring and Editing Certain Entities

Here, we present the drawbacks regarding the refac-

toring and editing of certain entities:

• Relocating the features: In design-time, it can be

important to move some parts (e.g. the children of

a certain entity.) up or down on the hierarchy. It

can be uncomfortable to update references to meta

elements the children elements are deﬁned at.

• Keep ﬂexibility: It is easy to forget to keep the

ability to add any kind of children to entities es-

pecially in a deep meta-hierarchy.

• Mandatory in-between placeholders: There can

be elements, which must be cloned (or instanti-

ated) by a large number of meta-levels. It can be

inconvenient to manually copy these elements to

the appropriate meta-levels. It would be useful to

have a feature to extend particular elements to up-

per and lower levels.

Automation and refactoring can be used both in a

textual and visual DSL, thus all of these drawbacks

can be resolved. Nevertheless, these issues are rather

editor dependent problem settings.

4.2 The Visualization of the

Meta-hierarchy

Our ﬁrst approach in creating the visual language to

edit DMLA models was to create a simple demon-

stration for the visualization of the meta-hierarchy by

constructing a tree of the model showing the instance-

of hierarchy. We created a visual DSL using the

Eclipse Modeling Framework (EMF, 2016) and Sir-

ius (Sirius, 2018). With the help of the modeling

framework of the EMF project we built the meta-

model of the visual DSL. Sirius allows to effectively

manipulate a certain part of the model graphically in

order to focus on what really matters. Sirius can sim-

plify the graphical representations and highlight the

elements of interest. These are the main reasons why

we decided to use Sirius, because these features can

facilitate the more effective manipulation of the par-

ticular model. Fig.3 shows the relevant part of the Bi-

cycle challenge.In this simple demonstration, we used

a rectangular box notation for each entity. The meta-

entity can be set for each entity (Entity:MetaEntity).

Besides the header label, the instantiation relationship

is visualized by an arrow as well. Slots of the enti-

ties are represented as Slot:MetaSlot. Note that the

metaslot is also important, since it determines the val-

idation rules of the slot.

Although it looks beneﬁcial to visualize the whole

meta-hierarchy, it has its limitations and drawbacks.

Due to a large number of model entities, the depth of

the instance tree can be large, thus the diagram may

become over-complicated and it can make the model-

ing process harder in design-time. On the other hand,

there are containment relationships in the model as

well, which should also be visualized in order to get a

better overview of the model. By realizing the short-

comings of our ﬁrst attempt, we re-built our visual

language from scratch.

Figure 2: Expansible visual pivot point.

4.3 Combining Meta-, and Containment

Hierarchy Views

We have created a new visualization concept which

supports both the meta-hierarchy view and contain-

ment view in a more ﬂexible and expressive way. As

it is not usable to display the whole model in one in-

stance tree, visual pivot points are needed in order to

make the diagram extensible vertically by the meta-

hierarchy and horizontally by the ownership. Hence,

it is possible to navigate only on the relevant part

of the model by traversing the appropriate upper and

Towards a Visualization of Multi-level Metamodeling Techniques

359

Figure 3: The visualization of the meta-hierarchy.

lower levels and displaying entities by containment

relationships. Fig.2 illustrates the concept of com-

bining meta-hierarchy and containment views. We

believe that both Lack of fragmentation and Navi-

gation through meta-hierarchy drawbacks can be re-

solved with the combination of meta-hierarchy view

and containment view.

4.4 Package View

In order to make the visual representation more modu-

larized and structured, a new view is required. Instead

of following the structural connections as in case of

instantiation and containment relations, the package

view reﬂects a logical grouping among model ele-

ments. The following advantageous points can fa-

cilitate the modeling process by applying a package

view:

• The package view can be used to to categorize

particular entities in the model, therefore they can

be easily maintained and used.

• Built-in bootstrap entities and user-deﬁned enti-

ties can be distinguished by applying the appro-

priate concrete syntax (i.e. using different color

notations)

• Logically related modeling entities can be encap-

sulated in a named package. Each package is easy

to understand, and the interface between packages

can be simple, clear, and well-deﬁned.

• The relevant entities can be displayed easily, non-

relevant entities can be hidden.

To sum up, all of the aforementioned points

strengthen the need for package view. This is the rea-

son why we support the introduction of package view

in our visualization concept. The Semantics based

grouping drawback can be easily resolved by using

an appropriate package view.

4.5 Testing the Approach

In this subsection, we present a simple example to

give a better overview of the advantages of our vi-

sualization concept. Let us follow the process of de-

signing a domain step-by-step.

1. A bicycle is built of components. A component

is a bicycle entity. – We create an entity called

Component by instantiating the previously created

BicycleEntity entity.

2. There are several types of components, e.g.

Frame or Wheel. –We set our pivot to Component

and instantiate it to create the two entities.

3. The XZ32 frame is a concrete frame – We instanti-

ate Frame and create the new entity. Fig. 4 shows

the actual state of the process after the third step.

4. A Frame has a color. – We add a new slot to

Frame, but Component has no (meta)slots to be

instantiated to create the color slot. We have two

options: we can add a universal slot to Component

granting the ability to add any kind of slots to its

instances (including color), or we can add a spe-

ciﬁc Color slot to Component. In the latter case,

we say that all components can have colors. Now,

we choose this option. Note that we also need to

add the Color slot to Wheel and to XZ32. These

ICSOFT 2018 - 13th International Conference on Software Technologies

360

Figure 4: The actual state after adding XZ32 frame.

additions are applied automatically by the frame-

work as we used the features Keep ﬂexibility and

Relocating the features. We can also specify that

XZ32 frame is always painted to red thus setting

the concrete value of the slot. Fig. 5 shows the

actual state of the process after the fourth step.

Figure 5: The actual state after adding Color slot.

5. The weight of the XZ32 frame is 10kg – We need

to create a new slot in XZ32 and similarly to the

previous case, we need to create its metaslot and

in this case also its meta-metaslot (in Component).

Note that Frame is a mandatory in-between place-

holder in this case. Adding the Weight slot to it

is only required because our validation is strict

and does not allow any element not enabled by

its meta-element.

It is worth to mention that in design-time, it can be

convenient to move the Color and Weight attributes

up or down on the hierarchy automatically by the de-

cisions of the user. Our visualization approach can

effectively simplify the process of deﬁning and mov-

ing slots. Fig. 6 shows the end result of the process.

Figure 6: The end result of the process.

5 CONCLUSIONS

Model-driven development has become a feasible op-

tion to create and maintain complex systems. How-

ever, static modeling solutions are not always sufﬁ-

cient any longer in the modern era of industrial appli-

cations. On the other hand, it is not always acceptable

to create a language deﬁnition ﬁrst and create mod-

els conforming to it afterward. Models and even the

modeling languages evolve continuously. Thus, the

demand for dynamic modeling techniques became a

natural tendency in many ﬁelds. It is one of the chal-

lenges in supporting this trend is to facilitate the pro-

cess of dynamic modeling with the appropriate visu-

alization techniques. The richness of the visual rep-

resentation can simplify the modeling process and in-

crease ﬂexibility.

Managing the complexity of the dynamic model-

ing requires breaking down a domain problem into

simpler parts. We believe that our visualization ap-

proach allows the user to easily manipulate sub-parts

of a model in order to focus on what really mat-

ters. The approach automatically simpliﬁes several

key processes and graphically highlight the elements

of interest while editing a certain domain in design-

time.

Towards a Visualization of Multi-level Metamodeling Techniques

361

In this paper, we classiﬁed and identiﬁed the most

relevant difﬁculties that can occur in a particular

multi-level modeling design process. We also intro-

duced visualization solutions, which can support the

evolutionary nature of domain models and facilitate

the dynamic editing of certain models. Our visual-

ization approach can provide a ﬂexible and expres-

sive way of multi-level modeling within DMLA. Al-

though the presented concept is related to DMLA, we

believe that the main principles are much more gen-

eral and can be beneﬁcial for any multi-level visual-

ization problem settings.

In the future, we aim to ﬁnish the implementa-

tion based upon the new concepts we introduced in

this paper. We plan to create more detailed case stud-

ies to prove the utility of our visualization concept.

We plan to investigate our visualization concept in

the context of other relevant multi-level metamodel-

ing approaches by creating a comparison between the

proposed method and relevant existing methods in a

visual way. The comparison would provide a better

overview of the real advantages of our visualization

approach.

ACKNOWLEDGEMENTS

This work was performed in the frame of FIEK 16-

1-2016-0007 project, implemented with the support

provided from the National Research, Development

and Innovation Fund of Hungary, ﬁnanced under the

FIEK 16 funding scheme. The research has been sup-

ported by the European Union, co-ﬁnanced by the Eu-

ropean Social Fund. (EFOP-3.6.2-16-2017-00013).

REFERENCES

Atkinson, C. and Gerbig, R. (2016). Flexible deep mod-

eling with melanee. In Modellierung 2016 - Work-

shopband : Tagung vom 02. M

arz - 04. M

arz 2016

Karlsruhe, MOD 2016, volume 255, pages 117–121,

Bonn. K

ollen.

Atkinson, C., Gerbig, R., and Khne, T. (2014). Comparing

multi-level modeling approaches. In CEUR Workshop

Proceedings, volume 1286.

Atkinson, C. and K

uhne, T. (2001). The essence of mul-

tilevel metamodeling. In Gogolla, M. and Kobryn,

C., editors, łUML 2001 — The Uniﬁed Modeling Lan-

guage. Modeling Languages, Concepts, and Tools,

pages 19–33, Berlin, Heidelberg. Springer Berlin Hei-

delberg.

Bottoni, P. and Ceriani, M. (2015). Sparql playground: A

block programming tool to experiment with sparql. In

VOILA@ISWC.

Clark, T., Sammut, P., and Willans, J. S. (2015). Super-

languages: Developing languages and applications

with XMF (second edition). CoRR, abs/1506.03363.

Clark, T. and Willans, J. (2012). Software language engi-

neering with xmf and xmodeler. In Formal and Prac-

tical Aspects of Domain-Speciﬁc Languages: Recent

Developments, volume 2, pages 311–340.

de Lara, J. and Guerra, E. (2010). Deep meta-modelling

with metadepth. In Vitek, J., editor, Objects, Mod-

els, Components, Patterns, pages 1–20, Berlin, Hei-

delberg. Springer Berlin Heidelberg.

DMLA (2015). Dmla website. aut.bme.hu/Pages/Research/

VMTS/DMLA. Accessed: 2018-04-20.

Egon Brger, R. S. (2003). Abstract State Machines.

Springer-Verlag Berlin Heidelberg.

EMF (2016). Emf. Accessed: 2018-04-20.

EOL (2007). Epsilon object language. http://www.eclipse.

org/epsilon/. Accessed: 2018-04-20.

Gerbig, R., Atkinson, C., de Lara, J., and Guerra, E.

(2016). A feature-based comparison of melanee and

metadepth. In MULTI 2016 : Proceedings of the 3rd

International Workshop on Multi-Level Modelling co-

located with ACM/IEEE 19th International Confer-

ence on Model Driven Engineering Languages & Sys-

tems (MoDELS 2016) Saint-Malo, France, October 4,

2016, volume 1722, pages 25–34, Aachen. RWTH.

Golra, F. R. and Dagnat, F. (2011). The lazy initializa-

tion multilayered modeling framework: Nier track. In

2011 33rd International Conference on Software En-

gineering (ICSE), pages 924–927.

MULTI 2017 (2017). Bicycle challenge multi 2017. https://

www.wi-inf.uni-duisburg-essen.de/MULTI2017/. Ac-

cessed: 2018-04-20.

OMG (2005). Omg metaobject facility. http://www.omg.

org/mof/. Accessed: 2018-04-20.

Simon, G., Palatinszky, D., and Mezei, G. (2017). Demon-

stration of using a domain-speciﬁc visual modeler for

building semantic queries. In Joint Proceedings of

the 2nd RDF Stream Processing (RSP 2017) and the

Querying the Web of Data (QuWeDa 2017) Workshops

co-located with 14th ESWC 2017 (ESWC 2017), Por-

toroz, Slovenia, May 28th - to - 29th, 2017., pages

51–54.

Sirius (2018). Sirius. https://www.eclipse.org/sirius/. Ac-

cessed: 2018-04-20.

Wienands, C. and Golm, M. (2009). Anatomy of a visual

domain-speciﬁc language project in an industrial con-

text. In Sch

urr, A. and Selic, B., editors, Model Driven

Engineering Languages and Systems, pages 453–467,

Berlin, Heidelberg. Springer Berlin Heidelberg.

XModeler (2014). Xmodeler website. https://www.wi-inf.

uni-duisburg-essen.de/LE4MM/xmodeler-ml/. Ac-

cessed: 2018-04-20.

ICSOFT 2018 - 13th International Conference on Software Technologies

362