Model-Driven Engineering of a General Policy Modeling Language

Nima Kaviani1, Dragan Gašević2, Milan Milanović3, Marek Hatala4
1University of British Columbia, Canada
2Athabasca University, Canada
3FON-School of Business Administration, University of Belgrade, Serbia
4Simon Fraser University Surrey, Canada
nimak@ece.ubc.ca, milan@milanovic.org, dgasevic@acm.org, mhatala@sfu.ca


Abstract
Despite many efforts in developing policy languag-
es which work in different logical domains and with
various reasoning engines, there has been limited
attention paid to bringing policy definition, design, and
integration into the realm of the mainstream software
development process. There seems to be a lack of ap-
propriate software development tooling that can allow
for easy representation and integration of policies with
other pieces of software at the design time. This paper
presents a General Policy Modeling Language
(GPML), following the rationale of Model Driven
Engineering (MDE), as a means to design policies and
integrate them to the software development process.
We describe the logical foundation and the modeling
rationale behind GPML and show how it is adjustable
to the existing policy languages.
1 Introduction
Inventing and offering more and more business
services through the Web have created highly-dynamic
environments in which today’s software systems have
to work. To address the challenges of such environ-
ments, software engineers need to use novel software
development and maintenance techniques. This in-
cludes techniques that address increased needs for
software changes coming from either software’s inter-
nal business logic updates or external factors such as
involved parties. We believe policies are promising
solutions to address these problems from both internal
and external perspectives.
Although policies have brought a lot of benefits in-
to the realm of software development, the main chal-
lenge is how to integrate policies into the development
process of software systems. This means that policies
should be considered starting from the very beginning
of software lifecycle stages, e.g. requirement engineer-
ing, to the last stages of software deployment and
maintenance. Throughout the development process,
various software languages (e.g., UML and WSDL) are
used and policy languages need to be used in combina-
tion with all of them. The best way to do so is to pro-
vide an appropriate software development tooling [1]
that facilitates the specification and integration process.
That is, policies should complement existing languag-
es, so that software engineers can easier comprehend a
system under study, as they already have to deal with
the burden of the complexity of systems.
In this paper, we propose the use of Model-Driven
Engineering (MDE) [1] to address this problem. The
goal of MDE is to focus on the problem under study,
while hiding the complexities coming from the imple-
mentation details of different deployment platforms.
Levering the MDE features, we define the general
policy modeling language (GPML) by extracting
common policy concepts from several policy languag-
es and grounding them on the sound theoretical foun-
dation of deontic logic, while keeping it away from the
paradoxes known for deontic logic [6].
2 Model-Driven Engineering
The main goal of MDE is to switch the focus from
low-level implementation details to problem-specific
concepts [10]. The core activity is then to define lan-
guages for particular problem domains (in our case
policies). Metamodeling is an approach used in MDE
for defining languages. A metamodel is a model of a
modeling language, that is, a metamodel defines a set
of sentences that can be expressed in a modeling lan-
guage [5]. As such, a metamodel can be regarded as an
abstract syntax of a language.
Usually, a metamodeling architecture (e.g., OMG’s
Model-Driven Architecture) is organized in a layered
fashion, where typically there are three layers. The top
most layer is called metametamodel (and tagged with
M3 or L3), and on this layer a metamodeling language
is defined. Meta-Object Facility [7] and Ecore [2] are
instances of this layer. The Definition of modeling
languages (i.e., metamodels) is done on the metamodel
layer (i.e., M2). To define a metamodel of a modeling