IFVM Bridge: A Virtual Machine for IFML Models Execution in
Combination with Domain Models
Sara Gotti and Samir Mbarki
MISC Laboratory, Faculty of Science, Ibn Tofail University, Kenitra, Morocco
Keywords: Interaction Flow Modeling Language IFML, Model Execution, Mda, Bytecode, Virtual Machine, Model
Interpretation, Model Compilation, User Interfaces, Front End, Content Dependency, Input-Output
Dependency.
Abstract: Many software systems are executable on various computing devices. No one denies that each of these devices
has its own user interfaces. Nevertheless, this trend of computing everywhere is not accompanied by a solution
that can be used to abstractly express the content, user interaction and control behavior of the software
application front end without focusing on the implementation platform. Applying the concept of abstract
models to user interfaces become a necessity. Accordingly, OMG adopted (in March 2013) the new
Interaction Flow Modeling Language (IFML) for abstractly describing the system front end. It ensures
executability in order to be mapped into executable applications for different kind of devices. In this paper,
we propose a new model driven development approach to execute the logical description of UIs components
and their interactions captured with IFML. We define IFVM, a virtual machine for executing IFML models
with focus on the content-dependent navigation specification for passing parameters between the
ViewElements, and the Data binding specification to specify the source of the published content.
1 INTRODUCTION
In the last few years, there has been an extensively
increase in the complexity of computer systems in
order to guarantee an efficient production respecting
the time to market. Besides, technologies are widely
evolving. In order to benefit from technological
advances, it is necessary to adapt the applications to
these technologies. But this operation is expensive for
companies because it is often necessary to rewrite the
code entirely. To solve this issue, several approaches
have been proposed, in the context of model driven
engineering (MDE), to software design and
implementation via what we call models. Among
these proposals we cite model driven architecture
(MDA) (Blanc and Salvatori, 2005); it is the object
management group’s (OMG) vision of MDE.
Therefore, modeling has been used more and more to
try to control system's complexity to easily produce
valid software.
Consequently, MDE has recently been presented
in the building of software back-end through the
UML language. However, several practical questions
arise when dealing with the building the system's
front-end. It should be noted that with the emergence
of devices and technological platforms, front-end
development become a complex task in which several
requirement, perspectives, and disciplines intersect
(Brambilla et al., 2014). So, to guarantee this trend of
computing everywhere, it is recommended to create a
platform independent representation for expressing
user design and interaction to facilitate the generation
and the execution on different computing platforms
and technologies. To answer all these questions and
needs, OMG group has adopted a solution in March
2013 as a standard which is the Interaction Flow
Modeling Language (IFML) (Omg.org, 2018).
IFML is a modeling language used for expressing
user interactions and front-end behavior of software
systems regardless the implementation specific issue
of their realization. IFML was designed considering
many rules in which we site implementability which
means that it supports code generation via model
transformations and code generators. In other words,
it could be mapped to executable applications for
multiple devices.
In this present study, a new technique for
executing IFML model is suggested. we propose a
design of IFML virtual machine for directly executing
IFML models without code generation in the hope of
Gotti, S. and Mbarki, S.
IFVM Bridge: A Virtual Machine for IFML Models Execution in Combination with Domain Models.
DOI: 10.5220/0007581604890494
In Proceedings of the 7th International Conference on Model-Driven Engineering and Software Development (MODELSWARD 2019), pages 489-494
ISBN: 978-989-758-358-2
Copyright
c
2019 by SCITEPRESS Science and Technology Publications, Lda. All rights reserved
489
elaborating interactive graphical user interfaces. the
proposed IFVM (IFML Virtual Machine) considers
not only the UI general structure, but also the
different types of events that could be triggered as
well as the caused navigations between the views
especially the content-dependent ones.
The remainder of the paper is organized as
follows. We start out, in section 2, with the related
work on model execution approaches. In section 3,
we explore conceptual modeling of Human Computer
Interactions (HCIs) by presenting the user interface
description language IFML and its executability. The
section 4 is devoted to the proposed process of IFVM
virtual machine for executing IFML models. Future
works are presented in section 5. Section 6 concludes
the paper.
2 RELATED WORK
In this work and in related references, it was observed
that many researches have been proposed for directly
executing models, without code generation, as those
based on UML for the design of the back-end. Here
(Gotti and Mbarki, 2016), the authors discuss many
proposed works in this field through a comparative
study.
The literature on front-end development shows a
variety of model-based approaches for GUIs
generation. As for (Frajták, Bures and Jelinek, 2015),
authors discuss the automatic generation of
automated application front-end from the IFML
model. (Laaz et al., 2018) studied many other related
solutions or tools for modeling IFML by providing a
comparative analysis while considering various
criteria.
Besides, other model driven solutions, based on
IFML, were emerged for the development of code
generators by affording extension for the IFML
language, among these solutions we cite (Brambilla,
Mauri and Umuhoza, 2014).
(Gotti and Mbarki, 2016) offer a new utilization
of IFML language in the software modernization
field. they propose an architecture-driven
modernization (ADM) based approach to obtain
knowledge of the structure and behavior of source
code by generating three independent platform
combined models: KDM to capture the knowledge
discovery, IFML to extract the structure of the
presentation and TaskModel for tasks aspect needed
for the construction of the future user interface (UI).
However, to the authors' best knowledge, most of
the previous studies do not take into account the
IFML executability, while we refer to our previous
work (Gotti and Mbarki, 2016), the focus is different.
Although several solutions have suggested code
generation of IFML, little or no one have proposed a
direct execution of IFML without code generation
except (Gotti and Mbarki, 2016).
Nevertheless, in this paper, we explore the
possibility of executing IFML models by providing a
new model driven design of a virtual machine called
IFVM for directly executing the abstract models.
3 CONTEXT
A human can control and communicate with a
machine by means of what we call Human-Computer
Interaction (HCI). Engineers in this field are studying
how humans interact with computers or with each
other using computers, as well as how to design
systems that are ergonomic, efficient, easy to use, or
more generally adapted to their context of use.
Quite recently, considerable attention has been
paid to the new trend of computing everywhere in the
modern communication. It consists of the merging of
various technologies to allow people to work
everywhere in different devices. There is a need to
adapt the UIs with their context of use, i.e., plasticity
(Jean-Sébastien, Gaëlle and Jean-Marie, 2006). To
solve this issue many solutions have been proposed.
We focus on those model-based that permit plasticity
by elaborating platform independent models
describing the UIs and then it could be easy to
generate the implementation via model
transformations and code generators.
In fact, abstract modeling of UIs become a
necessity to adapt platforms and technologies
changes. So, the answer of how to permit UIs
presentation at a high level of abstraction is by
defining a language for abstractly describing the UIs
regarding many criteria as described here (Selic,
2003). We call this language a User Interface
Description Language (UIDL) (Orit et al., 2008).
OMG in its turn has adopted IFML in March 2013
as its vision of UIDL. IFML is designed to capture the
user interaction, the content and the control behavior
of the software systems front-end.
3.1 IFML Language
IFML allows the system modeler to design the
structure of the general view part of the system in
terms of ViewContainers with navigation relations,
and what ViewContainers could contain in terms of
ViewComponents. ViewComponents enable content
display and data entry, they could be associated with
MODELSWARD 2019 - 7th International Conference on Model-Driven Engineering and Software Development
490
a ContentBinding to express the source of the
displayed content.
IFML ensure the events management that could
be produced by user interactions, by actions in the
application or by the system.
Events engender actions that could change the
state of the UI and they can be associated with
ParameterBinding that expresses the input-output
dependency between the ViewElements.
Many aspects that could help understanding
IFML language are presented in (Brambilla et al.,
2014). we focus on the IFML language definition
aspect through the IFML metamodel artifact, and the
IFML executability aspect.
The IFML meta-model is the best definition
artifact presented to describe the IFML language. It is
divided into three packages: The Core package, the
Extension package, and the DataTypes package, as
shown in Figure 1.
Figure 1: IFML Packages.
The Core package contains the abstract and general
concepts for building the infrastructure of the
language such as InteractionFlowElements,
InteractionFlows, and Parameters. These defined
concepts are extended by concrete concepts in the
extension package to treat more complex behaviors.
The IFML metamodel incorporates the basic data
types defined in the UML metamodel into the third
DataTypes package. It specializes some UML
metaclasses as the origin for IFML meta-classes, and
presumes that the IFML domain model is represented
in UML.
the IFML model admits IFMLModel as a top level
metaclass for including the InteractionFlowModel;
that affords the general ViewElements, action and
events of the system, and the Domain model; that
specifies the main objects, their attributes and
associations.
Model driven development processes start by
elaborating models and then generate executable code
(such as C, C++, Ada, Java, Forth, even VHDL)
through a series of model transformations and code
generators. To ensure this automatic generation, it is
recommended to use executable models.
To execute models, i.e. generate executable code
from it, they must have a complete definition in terms
of executability respecting two kinds of elements as
described in (Eric et al., 2011) which are: the static
part; that could define the static view elements of a
model, and the dynamic part; that describes behavior
of the model.
IFML has been designed with executability
aspect. This is obtained through model
transformations and code generators already exist that
ensures an easy mapping between conceptual IFML
constructs and executable applications for various
platforms and devices.
User interaction, within a view, produces events
that could affect the state of the views and then
execute actions that could signal another event and
that are what the execution semantics of IFML.
The IFML execution semantics describes any
IFML diagram as a machine that takes as input the
interaction of the user and updates the state of the
interface for the user to continue the interaction.
3.2 Content and Input-Output
Dependency
Actually, the specification of the content and
navigation aspects plays an important role in the
description of the system front end. This is done
through the using of ViewContainers, Events and
NavigationFlows.
First, we consider the content dependency
allowing the display of a data in the interface. In fact,
the content to be published within ViewComponents
could be provided from a different source. It is then
important to identify the source of the content in each
publishing ViewComponent. We use for this purpose
the DataBinding concept associated with
ViewComponent element.
The DataBinding concept expresses the source of
the retrieved content from objects of the domain
model. It ensures the automatic generation of data
from classes and attributes of UML Class diagrams,
Entity-Relationship models, ontologies, or other
elements.
Figure 2 shows an example of a simple
DataBinding. The “MovieList” ViewComponent
retrieves its content from the “Movie” entity of the
domain model of type UML Class model.
Besides, ViewComponents may allow user
interaction that could produce a navigation, this
navigation results in changing the content of
ViewComponent to display other ones. We talk about
the content dependent navigation specification
expressed by means of Event and NavigationFlow
view elements.
IFVM Bridge: A Virtual Machine for IFML Models Execution in Combination with Domain Models
491
Figure 2: DataBinding for Movie List content.
This specification permits the expression of the
dependency in which one ViewComponent publishes
content that relies on a precedent ViewComponent
content after a user interaction is performed. This
dependency is expressed by associating one or more
ParameterBinding specifications to the
NavigationFlow.
For example, as shown in Figure 3, a user accesses
a list of movies published inside the List
ViewComponent. He may select one object of the
movie list and reach another ViewComponent that
displays the detailed information of the selected
movie.
4 APPROACH OVERVIEW
This present paper presents a modest contribution to
overcome front end development problems. It
proposes a new approach for model execution based
on the definition of a virtual machine for the
implementation of abstract UIs definition with IFML.
The approach exploits the IFML language as the input
for the virtual machine to cover the content and the
user interactions of the software front end, as well as
the binding to external sources for extracting
information. We choose the acronym IFVM for
designate the proposed IFML Virtual Machine.
Figure 4 illustrates the general process of the
approach. It can be seen that we present a model
driven process that allows the execution of IFML
models. During this process, the focus of attention
was on the two concepts provided by IFML which are
the DataBinding and the content dependent
navigation described in section before.
For building the virtual machine, several technics
are suggested to ensure automatic execution of the
IFML models. As can be seen from Figure 4, the
process encompasses two major units: (i) the
compilation unit and (ii) the interpretation unit. We
suggest to merge the two concepts of implementation
which are the compilation and the interpretation to
benefit from their advantages.
In general, the hybrid approach of an interpretive
compiler allows fast execution (Aggarwal, K. Singh
and Jain, 2014), since it is based on virtual machine
instructions of bytecode that has simple format to be
quickly analyzed by an interpreter.
4.1 Compilation Unit
Here we start the process of execution, in a first stage,
by elaborating the IFML model conforming to IFML
metamodel. It captures the general structure and
behavior of the different views of the system. As well,
it will be accompanied with a UML model
referencing the domain model that provides the
content to be displayed in the interface.
Figure 3 gives an example of an IFML model
expressing two views associated with a
NavigationFlow for a movies manager system. As
depicted in the figure, there are two windows, one for
listing the set of movies, and a second one for
publishing the details of the selected movie. The first
window uses the List ViewComponent to display the
movies list including some parameters:
DataBinding referencing the Movie UML class
(see Figure 5),
Figure 3: Example of List and Details ViewComponents of movies manager app.
MODELSWARD 2019 - 7th International Conference on Model-Driven Engineering and Software Development
492
Figure 4: IFVM Process.
VisualisationAttribute to locate the data to be
shown in the interface,
Parameter including the value of the selected
movie,
The second window is devoted to the display of
detailed information of the selected movie from the
“MovieList” ViewComponent including some
parameters as well.
The NavigationFlow is associated with a
parameterBindingGroup that contains the declaration
of an input–output dependency between the two
windows. The value of the parameter
“SelectedMovie” (output of the “MovieList”
ViewComponent) is associated with the value of the
parameter “Movie” (input of the “MovieDetails”
ViewComponent).
Figure 5: Example of UML domain model for movies
concepts.
The purpose of this present work is to express the
bytecode model elements in a bytecode format to be
interpreted by a corresponding virtual machine in
order to obtain the machine instructions understood
by a computer's processor. Actually, there are a plenty
of virtual machine architectures available on the
market. However, in this paper we propose a new
definition, through a metamodel, of IFVM bytecode
form for the desired IFVM virtual machine. It has a
similar syntax of Java bytecode with additional
instructions for expressing events and navigations for
example.
So, once the IFML and the UML models are built,
we launch a M2M transformation that maps their
elements to elements of IFVM bytecode model.
4.2 Interpretation Unit
IFVM has been chosen as an abstract intermediate
form in order to permit its representation in the other
forms of bytecode. So, after the execution of the
compilation unit, that is to say getting the IFVM
bytecode model, we begin the interpretation unit
dedicated to firstly mapping via a M2M
transformation the IFVM model to the other models
of bytecode of existing virtual machines; the JVM
bytecode model, the android Dalvik model and the
Python bytecode model, in order to gain optimization
and portability.
After getting the three bytecode models, we
launch a model to text transformation, in a second
IFVM Bridge: A Virtual Machine for IFML Models Execution in Combination with Domain Models
493
time, for each generated bytecode model in order to
generate the corresponding bytecode files.
Finally, the Bytecode files will be then treated by
their corresponding virtual machines to be executed.
5 FUTURE WORK
On the basis of the IFVM process, we will build a
framework based on the proposed process to enable
the automatic front end execution of a system. It will
provide both a textual and graphical model editor for
designing the IFML and UML models. We will
elaborate our own IFVM bytecode metamodel with
all the required instructions according to bytecode
instruction set of the existing virtual machines.
Compilation will be done via a model to model
transformation designed with QVTo language
(Omg.org, 2016). In the interpretation unit we launch
a second M2M transformation that will be designed
with QVTo as well. For the model to text
transformation, we will opt for a code generation
using the open source Acceleo (Eclipse.org, 2005).
Finally, we will extend the framework to support
additional bytecode forms for other existing virtual
machines.
6 CONCLUSION
In this position paper, we presented a model driven
process for automatically executing the abstract
representation of user interfaces with content
provided by domain models. Our contribution reveals
the possibility of building and maintenance of
software front end easier and less expansive via
transformations and model tools in comparison to the
code driven contributions.
REFERENCES
Blanc, X. and Salvatori, O. (2005). MDA en action. Paris:
Eyrolles.
Brambilla, M., Fraternali, P., Elliot, S., Herbert, K.,
Kumaraguruparan, P. and Rogers, M. (2014).
Interaction flow modeling language.
Omg.org. (2018). The Interaction Flow Modeling
Language. [online] Available at: https://www.omg.org/
ifml/ [Accessed 22 Nov. 2018].
Gotti, S. and Mbarki, S. (2016). UML Executable: A
Comparative Study of UML Compilers and
Interpreters. In: Information Technology for
Organizations Development (IT4OD).
Frajták, K., Bures, M. and Jelinek, I. (2015).
Transformation of IFML Schemas to Automated Tests.
In: Conference on research in adaptive and convergent
systems.
Laaz, N., Wakil, K., Mbarki, S. and N.A. Jawawi, D.
(2018). Comparative Analysis of Interaction Flow
Modeling Language Tools. Journal of Computer
Science, 14(9).
Brambilla, M., Mauri, A. and Umuhoza, E. (2014).
Extending the interaction flow modeling language
(ifml) for model driven development of mobile
applications front end. In: International Conference on
Mobile Web and Information Systems.
Gotti, Z. and Mbarki, S. (2016). Java Swing Modernization
Approach Complete Abstract Representation based on
Static and Dynamic Analysis. In: ICSOFT-EA.
KENITRA.
Gotti, S. and Mbarki, S. (2016). Toward IFVM Virtual
Machine: A Model Driven IFML Interpretation. In:
ICSOFT-EA.
Jean-Sébastien, S., Gaëlle, C. and Jean-Marie, F. (2006).
Models at runtime for sustaining user in-terface
plasticity. In: Models@ run. time workshop (in
conjunction with MoDELS/UML 2006 conference).
Selic, B. (2003). The pragmatics of model-driven
development. IEEE Software, 20(5), pp.19-25.
Orit, S., Robert JK, J., Mark, G. and K., L. (2008). User
interface description languages for next generation user
interfaces. In: CHI'08 Extended Abstracts on Human
Factors in Computing Systems.
Eric, C., Cyril, B., Alexandre, F. and F., B. (2011).
Contracts for model exe-cution verification. In:
European Conference on Modelling Foundations and
Applications.
Aggarwal, A., K. Singh, D. and Jain, S. (2014). A Hybrid
Approach of Compiler and Interpreter. International
Journal of Scientific & Engineering Research, 5(6).
Omg.org. (2016). About the MOF Query/View/
Transformation Specification Version 1.3. [online]
Available at: https://www.omg.org/spec/QVT/About-
QVT/ [Accessed 23 Nov. 2018].
Eclipse.org. (2005). Acceleo | The Eclipse Foundation.
[online] Available at: https://www.eclipse.org/acceleo/
[Accessed 23 Nov. 2018].
MODELSWARD 2019 - 7th International Conference on Model-Driven Engineering and Software Development
494