ChapterPDF Available

Ptolemaic Metamodelling?: The Need for a Paradigm Shift

Authors:

Abstract and Figures

By consideration of scientific paradigm shifts, in this chapter the authors evaluate possible parallels in the evolution of modelling, and particularly metamodelling and modelling language construction, as a basis for evaluating whether or not the time is ripe for a similar change of direction in model language development for software engineering. Having identified several inconsistencies and paradoxes in the current orthodoxy, they then introduce a number of ideas from outside software engineering (including language use, philosophy, and ontology engineering) that seem to solve many of these issues. Whether these new ideas, together, are sufficient to create a shift in mindset or whether they are simply the stimulus for others to create new and orthogonal ideas remains to be seen. The authors urge the modelling and metamodelling communities to search out that new orthodoxy (i.e. instigate a paradigm shift) that will, necessarily, ensure that the science will offer simpler and more satisfying solutions in the years to come.
Content may be subject to copyright.
90
Copyright © 2013, IGI Global. Copying or distributing in print or electronic forms without written permission of IGI Global is prohibited.
Chapter 4
Ptolemaic Metamodelling?
The Need for a Paradigm Shift
ABSTRACT
By consideration of scientific paradigm shifts, in this chapter the authors evaluate possible parallels in
the evolution of modelling, and particularly metamodelling and modelling language construction, as a
basis for evaluating whether or not the time is ripe for a similar change of direction in model language
development for software engineering. Having identified several inconsistencies and paradoxes in the
current orthodoxy, they then introduce a number of ideas from outside software engineering (including
language use, philosophy, and ontology engineering) that seem to solve many of these issues. Whether
these new ideas, together, are sufficient to create a shift in mindset or whether they are simply the stimulus
for others to create new and orthogonal ideas remains to be seen. The authors urge the modelling and
metamodelling communities to search out that new orthodoxy (i.e. instigate a paradigm shift) that will,
necessarily, ensure that the science will offer simpler and more satisfying solutions in the years to come.
1. INTRODUCTION
Model-Driven Engineering (MDE) focuses on
models and model transformations. At the very
heart of modelling is the need for models to be
depicted in some way by using modelling lan-
guages (e.g. Selic, 2011), typically specified by
a metamodel (e.g. Sanchez Cuadrado, de Lara, &
Guerra, 2012). Metamodels are thus a (or maybe
the) core element in MDE current and future
metamodelling approaches are the topic of this
chapter.
The scientific approach to knowledge creation
and acquisition has been the topic of many books
and papers. It embodies a combination of theory
building and theory testing and the ability to re-
Brian Henderson-Sellers
University of Technology, Australia
Owen Eriksson
Uppsala University, Sweden
Cesar Gonzalez-Perez
Spanish National Research Council (CSIC), Spain
Pär J. Ågerfalk
Uppsala University, Sweden
DOI: 10.4018/978-1-4666-4217-1.ch004
91
Ptolemaic Metamodelling?
place old theories when newer data and/or newer
theories offer a more consistent and scientific
explanation of the topic under consideration.
The framework in which the theory resides also
implies a philosophical underpinning, a paradig-
matic choice that is seldom discussed or even
appreciated. This interaction between theory and
empirically obtained data for testing that theory is
crucial in science and, hence also, in all branches of
computing (e.g. Genova, 2010). Notwithstanding,
there is an unfortunate trend in journal reviewing
of software engineering research to reject papers
that have little or no empirical support (as observed
by Genova, 2010). Indeed, Broy (2011) observes
that “in the long run, software engineering cannot
be established without a solid body of scientific
theory.When scientific frameworks are totally
reconstructed, often because they have degraded
to a point where their coherence is challenged, it
is said that a paradigm shift has occurred (Kuhn,
1962).
In this chapter, we focus on models and
metamodels. Models have a long history in sci-
entific research: “If you want to understand some
aspect of the Universe, it helps if you simplify
it as much as possible, and include only those
properties and characteristics that are essential
to understanding. If you want to determine how
an object drops, you don’t concern yourself with
whether it is new or old, is red or green, has an
odour or not. You eliminate those things and thus
do not needlessly complicate matters. The simpli-
fication you can call a model or a simulation and
you can present it either as an actual representa-
tion on a computer screen, or as a mathematical
relationship” (Asimov, 1988). However, even
with this illustrious and lengthy history, Ritchey
(2012) argues that there is still no general theory
of modelling.
Here, we take a largely theoretical approach,
where our evaluation approach uses examples
taken from considering the real world and asking
whether each model provides a good or a better
appreciation of the target problem domain. In
order to create such a comprehensive modelling
approach, we integrate knowledge from various
sub-fields of computing: software engineering,
modelling (especially the use of UML and, more
generally, conceptual modelling), as well as
considering research knowledge from outside
the traditional context of computing: ontology
engineering, philosophy, mathematics, language
use (especially speech acts) and cognitive linguis-
tics. For the non-computing fields, we note that
each has its own conferences and journals and,
importantly, their own communities, which tend
often to be ‘clubs’ or ‘closed shops’ with their own
internal terminology immediately understandable
by members of the club but unintelligible to those
outside (e.g. Kuhn, 1962). To improve our models
and our modelling axioms and constraints, we
need to break into each and every of these clubs.
In this chapter, we will argue that the time is
ripe for a paradigm shift in software language
engineering and in particular in the model we use
to understand multilevel metamodel architectures,
especially relevant for MDE. Firstly, we will out-
line a parallel in the history of science: that of the
Copernican Revolution (Section 2.1). In Section
2.2, we will give a brief overview of the history
of software engineering metamodelling. Whilst
Section 2 describes some of the problems and some
of the fixes made at a high level, Section 3 delves
into the detail of each of these proposed solutions.
In particular, we explore the generalization1 and
instantiation relationships, the potential value
of powertypes, and how ontology engineering
and language use can add value to the creation
and use of modelling languages. Despite these
new additions to software language engineering,
problems remain; in Section 4 we propose that the
time is ripe for a minor revolution in thinking with
respect to the relative positioning of metamodels,
modelling languages and multilevel frameworks.
92
Ptolemaic Metamodelling?
2. DRAWING PARALLELS
WITH HISTORY
This section will thus set the scene for our argu-
ment that current ‘solutions’ to the various issues
identified and agreed upon in contemporary
software modelling languages and, especially,
metamodelling are more akin to the Ptolemaic
model with its many ‘fixes’ and lead into our
proposal that what is needed for this important
topic in modern-day modelling is a brand-new
approach i.e. a new approach that results from
a conceptual deconstruction and reconstruction
(Kuhn, 1962).
2.1. History: From Ptolemy
to Copernicus (Science)
In ancient Greece, despite Pythagoras2’s argument
that the Earth and other heavenly bodies moved
around a ’central fire’, a rough consensus emerged
(e.g. by Plato ca. 428-347 BC) that the Earth was
the centre of the universe and that all the other
astronomical bodies revolved in circular orbits
around the Earth – as observed by the naked eye.
Aristotle (384-322 BC) (see Stocks, 1922), Plato’s
student, argued for a crystal sphere carrying each
such astronomical body where the gaps between
spheres were filled with solid aether, the spheres
themselves being concentric. Less predictable
movements of nearby planets required an em-
bedded sphere to account for their more erratic
observed behaviour. Ptolemy (150) removed this
constraint of concentricity, introducing a second
sphere for each planet. Each planet moved around
this sphere (actually a circle as shown in Figure 1).
This is called an epicycle, formalized by Ptolemy
but used much earlier by e.g. Apollonius of Perga
and Hipparchus of Rhodes in the second century
BC. The centre of this circle moves around a cen-
tral point that is displaced from the Earth itself,
the motion again being circular, the circle being
known as the deferent. Its centre (cross in Figure
1) is halfway between the Earth and a point known
as the equant, introduced by Ptolemy to account
for variations in velocities of the planets (see also
Peurbach & Regiomontanus, 1496). The system
model required of the order of 30-40 epicycles
and was standard for around a thousand years until
heliocentric models became accepted.
The idea that the Sun and not the Earth was
the centre of our solar system was first proposed
by Aristarchus of Samos (310-ca. 230 BC) but
was then abandoned until resurrected in the 16th
century by Nicolaus Copernicus (1473-1543)
(Figure 2) after a careful and detailed analysis of
planetary models (Swerdlow & Neugebauer,
1984). However, his initial models, whilst remov-
ing the contentious equant, needed additional
epicycles, creating a system of greater complex-
ity than that of Ptolemy3. Indeed, it was not until
Johannes Kepler replaced Copernicus’s circular
orbits by elliptical ones that observations, espe-
cially those by Tycho Brahe, and theory (as de-
veloped by Newton (1687), based to a large degree
on the work of Kepler) became both aligned and
less complicated.
Despite Copernicus’s continued use of epi-
cycles, his change of mindset (paradigm shift)
Figure 1. Ptolemy’s geocentric model showing
the deferent (large dashed circle), the epicycle
(smaller dashed circle) with the cross marking the
centre of the deferent and the large dot denoting the
equant (public domain image, author Fastfission:
http://en.wikipedia.org/wiki/File:Ptolemaic_ele-
ments.svg)
93
Ptolemaic Metamodelling?
from a geocentric to a heliocentric solar system
model is usually taken to denote the beginnings
of a revolution and of modern astronomy (Coper-
nicus, 1543). After his death, his work was deni-
grated as foolish and with no solidity by Tolosani
in 1544 (in an appendix to the treatise On the
Truth of Holy Scripture). Indeed, it could be argued
that the paradigm shift was not completed until a
combination of Brahe’s (1546-1601) observation
of the Great Comet of 1577, which condemned
the idea of solid celestial spheres4, Kepler’s (1571-
1630) use of Brahe’s observations, from which
he deduced the elliptical nature of orbits (Kepler,
1596, 1609, 1617-21, 1627) and predicted the
transit of Venus, first observed by Jeremiah Hor-
rocks in 1639, and, finally, Galileo Galilei (1564-
1642), who recognized that, with the recent advent
of the telescope, the cytherean phases could not
be accommodated in the Ptolemaic system
(Galilei, 1610, 1632), thus providing observa-
tional support for the heliocentric model of Co-
pernicus5. Together, the work of Galilei and
Copernicus became the “dangerous idea” respon-
sible for the overthrow of nearly 2000 years of
Aristotelian physics. According to Bhathal (2012),
Butterfield (1957) argues for the new scientific
revolution “in which experiment and measurement
are the arbiters of truth” – following in the steps
of Husserl who advocated the prime importance
of empiricism above a positivistic orientation of
science and philosophy of his day (Wikipedia,
2012).
Similarly, although we will not pursue equiva-
lent detail here, is the story of the development of
Darwin’s masterpiece On the Origin of Species
(Darwin, 1859). Other contemporary scientists
had very similar insights, especially Alfred Russel
Wallace (Wallace, 1855). Beddall (1968) docu-
ments in detail the interactions between these two
scientists, noting that Patrick Matthew and William
Wells were also contenders for the discovery of
the theory of natural selection. As with the Coper-
nican revolution, Darwin, as Copernicus before
him, built on the knowledge already created6, for
instance by Sir Joseph Dalton Hooker (1817-
1911), Sir Charles Lyell (1797-1875), and Asa
Grey as well as conducting many conversations
and communications with these contemporary
thinkers. He read widely, including influential
works by Lamarck (1809), Paley (1809), and
Chambers (1844). But it was the ability of Darwin
to synthesis all this on a large and fully integrated
scale that created the paradigm shift. However,
such a change in mindset does not/did not occur
overnight. Indeed, as late as 1862, the presidential
address of George Bentham to the Linnean Society
was hugely negative on the topic, as was Thomas
Bell’s presidential address three years earlier (see
Beddall, 1968, p304), the latter at the meeting
on 1 July 1858 at which Darwin and Russell first
published their theories in a joint presentation
(Darwin & Wallace, 1858).
Figure 2. Copernicus’s house in Gdansk
94
Ptolemaic Metamodelling?
2.2. History: Multilevel Architectures,
Strict Metamodelling, and
an Ontological Viewpoint
(Modelling Languages)
Whilst modelling has an extensive history, extend-
ing back over several millennia, its application in
computing sciences did not begin until the 1970s
(e.g. Wieringa, 2011). However, prior to the intro-
duction of object-oriented modelling languages
in the early 1990s, formal definition in terms of
metamodels7 were rare (but see CDIF standards
as a counterexample, e.g. Flatscher, 2002) al-
though formalizations equivalent to metamodels,
such as the schemata used in creating ER models
(for recent examples, see Pastor, Levin, Celma,
Casamayor, Virrueta, & Eraso, 2011), had indeed
been widely used. Nevertheless, here we devote
our historical study to begin with the introduction
into object modelling techniques of metamodels
used to underpin and even define such modelling
languages as OML (Firesmith, Henderson-Sellers,
& Graham, 1997) and UMLTM (OMG, 2011a,
2011b)8. We begin with the supposition, as a
basic ‘axiom’, of the type-instance relationship.
This was taken over from (typed) object-oriented
programming languages as an initial framework
and turns out to be both a fundamental basis and
also a fundamental challenge in the introduction
of a multilevel architecture that occurred in the
mid to late 1990s.
The type-instance axiom is also fundamental
to ontological thinking and of language use (see
later discussion for additional detail) and tightens
up the class-object relationship prevalent in early
published OO modelling examples. Liskov (1987)
stressed that the use of types (rather than classes)
permits type substitution in a truly object-oriented
framework – and hence polymorphism, seen by
many as a cornerstone of the object-oriented
paradigm. Although polymorphism is primarily
implementation-related, the underpinning notion
of types and relationships between types has
been adopted without change into modelling and
metamodelling. The utility and validity of such
adoption is part of our exploration and analysis
herein.
2.2.1. The Four-Level
Metamodelling Hierarchy
The use of metamodels for OO modelling lan-
guages was first promoted in 1994 (Henderson-
Sellers, 1994; Carmichael, 1994; Monarchi,
Booch, Henderson-Sellers, Jacobson, Mellor,
Rumbaugh, & Wirfs-Brock, 1994) and conse-
quently realized in Henderson-Sellers and Bulthuis
(1998) in their creation of metamodels for 14 out
of a list of 22 identified (then extant) modelling
languages (at that time often mis-called method-
ologies). Around 1997, the OMG first publicized
their strict metamodelling hierarchy (OMG, 1997)
apparently based on theoretical suggestions of
Colin Atkinson, not published until a little later
(Atkinson, 1997, 1999). The need for a multiple
level hierarchy (Figure 3), thus extending the two
level type-instance model, was seen as necessary
in order to (1) provide a clear means by which ele-
ments in the (then emergent) modelling language
of UML could be themselves defined i.e. an M3
level9 and (2) acknowledge the existence at the
M0 level of individual (instances) of the classes
designed at the M1 level – although for the OMG/
UML world these were seen as less important
because such instances only exist as ‘data’ within
the computer program and, in general, do not ap-
pear within the modelling process.
Figure 3 uses as its basis the arguments em-
bodied in ‘strict metamodelling’; strict metamod-
elling states that these four layers (of the OMG
architecture seen in Figure 3) are linked by an
instanceOf relationship and, furthermore, that
instanceOf can only occur between layers and
never within a layer (e.g. Atkinson, 1997; Atkin-
son & Kühne, 2000a). A corollary is that no
other relationship between layers is permissible.
It should be noted that these constraints impose
an artificiality on the framework that is not sup-
95
Ptolemaic Metamodelling?
ported by traditional philosophical or ontological
reasoning. Indeed, it should be noted that there is
no obvious intent to give the four levels of Figure
3 an ontological verisimilitude.
Notwithstanding this four-level architecture,
in modelling languages such as the Unified
Modeling Language (UML), it is the two-level
type-instance relationship10 that is the main focus
(e.g. Atkinson, 1999). Each entity at a given Mx
layer is regarded as an instance of a correspond-
ing entity in the layer immediately above it i.e.
M(x+1) i.e. in one philosophical terminology, a
thing that ‘exemplifies’ a universal (in modelling,
the notion of an object as an instance of a type has
a similar intent). This refers to both classes and
relationships. There are, however, two schools of
thought: (a) one that insists on relationships in a
‘type’ model (i.e. M1 model in Figure 3) being
defined by classes in a metamodel (as shown in
Figure 4) and (b) one that permits one to describe
a model-level relationship as being an instance
of a similar relationship in the metamodel (as in
Figure 5). Although both these figures are from
UML documentation (OMG, 2010), the annota-
tions of <<instanceOf>> and <<snapshot>> in
Figure 5 are said to be informal and not part of the
model (Selic, 2012a); UML uses the class-based
infrastructure of Figure 4 for all its model-level
relationships. This is just one example of ambigu-
ous modelling/metamodelling that is implicated
in the need to continually add ‘fixesto the UML.
In Figure 4, Person is an instanceOf Class and the
association between Person and Car is an instance
of a class called Association in the metamodel.
Hence, at one level higher, we can observe that
association relationships between classes in the
(M2) metamodel are in effect instances of a class
in the metametamodel (M3) (i.e. atomic ‘particu-
lars’) and cannot therefore have any instances in
the model (M1). Figure 5, showing all four Mx
layers, illustrates one well-known concern with
Figure 3. OMG four-level metamodelling hi-
erarchy based on strict metamodelling (after
Henderson-Sellers & Unhelkar, 2002) © Pearson
Education Limited
Figure 4. An example of metamodelling note
that not all instanceOf relationships are shown
(after OMG, 2010)
Figure 5. An example of the OMG four-layer
metamodel hierarchy (after OMG, 2010)
96
Ptolemaic Metamodelling?
UML: the existence and location (within the Mx
layers) of the Instance class. In earlier versions of
UML this was named Object, which led to para-
doxical situations of the need to have instances of
Object at M0 when the framework dictates that
all instances of M2 classes exist at level M1 (e.g.
Atkinson & Kühne, 2001a).
To appreciate these issues in more detail, a
diagram like that in Figure 6 can be drawn. In this
diagram, we consider the details of a model (cen-
tre) and compare it to a typical representation (left
hand side using UML’s notation) and ask what
the defining metamodel fragment should look like
(right hand side). The model states that a par-
ticular dog, called Rover, is an instance of a class
of Dogs. Of what this class Dog is an instance of
is left undefined. The attributes on any class are
arguably (see discussion below) incorrect (depen-
dent upon whether they are part of the ontological
commitment and philosophical paradigm adopted)
and can be shown as explicit links to other
classes. This is shown in the middle column where
we can see that the typed attributes are themselves
instances of classes. The metamodel aspect is
depicted in the right hand column, which shows
that a class has one or more attributes; that objects
are typed by classes; and that objects have values
that are in turn typed by their corresponding at-
tribute class. The instanceOf association between
f:Dog and Dog in the left hand column is a rep-
resentation of the isTypeOf association between
Object and Class in the metamodel. This also ties
in with foundational ontologies and language use
(Section 3) where we can equate an object (of
type Object) with a Particular, which is an instance
of a Universal (here equated to a Class).
This analysis of a modelling language infra-
structure recommends the infrastructure of Figure
5 over that of Figure 4; yet it is the class-focussed
architecture of Figure 4 upon which all versions
of UML rely. The all-critical instanceOf relation-
ship is shown (in Figure 6) to conform to the
isTypeOf association between Object and Class
in the modelling language infrastructure. This is
very similar to using an association to model
relationships such as Person Owns House or
Figure 6. Mappings between model and modelling language infrastructure (here as a metamodel frag-
ment) showing the usual UML-style representation of the model together with a more detailed exposition
(middle column) to illustrate how both classes, objects, and attributes are all defined by classes and
relationships in the modelling language infrastructure itself
97
Ptolemaic Metamodelling?
Computer Runs Application. Thus, when we in-
stantiate the model (centre), we obtain instances
of Class (actual classes) and Object (actual ob-
jects), which are connected by links that are in-
stances of IsOfType. This is analogous to having
instances of Person (actual persons) and House
(actual houses) connected by links that are in-
stances of Owns. The IsOfType links in the
centre column are depicted as plain solid lines
(i.e. with no arrowhead) connecting “: Object”
and “: Class”, for example. What happens (and
here is the twist) is that IsOfType links are usu-
ally called “instance-of” relationships in OO (and
especially UML) modelling, and depicted in dia-
grams by using a special notation, as shown in
the left-hand side column of the figure (the UML-
ish dashed line with an arrowhead). This makes
the Object IsOfType Class association a bit special
and different from, say, Person Owns House; but
it is still a plain association from the metamodel’s
viewpoint.
One problem with UML’s choice of a class to
represent a relationship as part of the modelling
language infrastructure is that this needs associa-
tions to link the RelationshipClass to the Class
and Object classes in the M2 model, which in turn
need classes in the M3 model to represent these
relationships – recursively, ad infinitum (see also
discussion in Graham, Bischof, & Henderson-
Sellers, 1997).
2.2.2. Ptolemaic Fixes to the
Four-Level Architecture
From the strict metamodelling definition and its
widespread adoption as the fundamental architec-
ture mechanism (e.g. Atkinson, Gutheil, & Kennel,
2009) flow the modifications that we here draw as
parallels to the Copernican revolution discussed
in Section 2.1.
2.2.2.1. Attributes and the Potency Fix
An additional concern is that of the existence or
otherwise of attributes as components of entities
rather than relationships, common in modelling
languages like UML (see, e.g., discussion in Shan
& Zhu, 2012) and in ontologies (e.g. the property
of Bunge, 1977, 1979 and Wand & Weber, 1993,
1995; see also Opdahl & Henderson-Sellers, 2004)
but eschewed in some contemporary philosophy
(Partridge, 2012, p.c. – see also Swoyer & Orilia,
2011 for a detailed philosophical discussion on
properties).
Attributes (often called, alternatively, proper-
ties11 or, sometimes, qualities or characteristics
e.g. Searle, 1969, p105) are assigned to particulars
(typically instances of natural kinds) by means of
predication (in language use – see Section 3.4).
They were originally identified with ‘substance
(e.g. Partridge, 1996, chapter 4), an idea that was
strongly attacked by both Locke (1690) and Hume
(1739). This resulted in a shift from a substance
paradigm to an extension paradigm (e.g. Descartes,
1637, 1644), along with which came a shift (in
philosophical thinking) from attributes to logical
classes and tuples (e.g. Partridge, 1996, page 94).
However, this necessary realignment of attributes
as extensions (e.g. the red attribute of an object is
turned into a member of a class of RedThings12)
brings its own challenges and contradictions,
which we explore in Section 3.5. Based on Searle
(1969, pp. 113–118) who shows that you cannot
understand the meaning of “red” in the speech act
“the rose is red” as a type that has the extension
of all red things, e.g. roses. Neither can it be seen
as a reference to the universal redness. It is simply
an attribute ascribed to the rose.
However, in the following we retain the notion
of attribute since this is all-pervasive in the soft-
ware and conceptual modelling and metamodelling
98
Ptolemaic Metamodelling?
literature to date. Furthermore, since we use set
theory as our basic mathematical reference (as
outlined in Section 3.1 below), we note that the
predicate used to specify set membership defines
the common property of all members of that set
(Denning, Dennis, & Qualitz, 1978, p. 13).
In the years following the OMG adoption (and
consequently widespread industry adoption) of
the 4-layer architecture of Figure 3, attention was
turned to its application for process modelling
and the depiction of lifecycle methodologies.
Whilst some authors (Kent, Evans, & Rumpe,
1999; Halpin & Bloesch, 1999; Álvarez, Evans, &
Sammut, 2001) have questioned the poor semantics
of UML in general, Atkinson & Kühne (2001b)
identified two major problems particularly relevant
to process modelling: firstly, that in many cases,
an attribute of an M2 class did not require a (slot)
value to be determined until instantiated to an M0
instance. Since strict metamodelling enshrines
two-level type-instance semantics, this is not
possible because the M2 attribute has a value at
M1 not M0. (Alternatively, one could define the
attribute at M1 giving the required slot value at
M0; but this is not acceptable since it is desired to
have the standard at M2 not M1.) Their solution
was to invent a tag on the attribute that could be
used to override such type-instance semantics by
specifying at what level beneath the definition the
attribute could acquire its value. This is called
deep instantiation using tags known as potency
(see Figure 7 and the further detailed discussion
in Section 3.1) – our first serious Ptolemaic fix!
2.2.2.2. The Alignment of Product and
Process in a Methodology Fix
Secondly, a work product such as a (UML) Class
Diagram is clearly an artefact that exists at the
(OMG) M1 level. However, if processes and
methodologies are being modelled, this is no
longer true since work products are the inputs and
outputs of elements of process (typically of tasks
that form the overall process). They are created
by people working on projects. When character-
ized in terms of a multilevel architecture for the
methodology domain (Figure 8), one can see that
the ‘M1’ level describes the methodology a.k.a.
process model – that is equivalent to a method-
ology13 described in a book or on a collection of
Webpages – while the actual process ‘enactment’
Figure 7. The use of deep instantiation and potency
to permit a value to be assigned two “levels”
below its definition
Figure 8. The “layers” of process and method
terminology (modified from Henderson-Sellers,
2006)
99
Ptolemaic Metamodelling?
occurs at the equivalent of the OMG level M0.
It is at this level that work products are created
and used. This is in effect a contradiction (or at
least a challenge) since work products are now
expected to be in both the M1 level (if viewed
as UML design diagrams) but at M0 when one
considers how they are actually created by real
people on real projects (e.g. Gonzalez-Perez &
Henderson-Sellers, 2006). In the series of papers
by Atkinson and Kühne (2001b, 2003, 2005), a
number of alternative fixes are described based on
the assumption that strict metamodelling MUST be
adhered to. If, on the other hand, it is permissible
to abandon the strict metamodelling constraints,
then other solutions become possible (as we will
discuss below).
Furthermore, as seen in Figure 8 and pointed
out by McBride and Henderson-Sellers (2011),
there is actually a static and a dynamic discrimi-
nation at the process enactment (M0) level: the
process model individualized for a particular
project (the ‘tailored process’) and its dynamic
progress in calendar time (the ‘performed pro-
cess’).
As part of the proposed reformulation of the
UML from Version 1 to Version 2, Álvarez, Evans,
and Sammut (2001) proposed the Meta-Modeling
Language (MML). Whilst deviating from strict
metamodelling, they argue it fulfils the mandatory
requirements for UML 2.0 (OMG, 2000) by ensur-
ing that exactly one element of a model conforms
to a single element in a model at a higher level.
Their deviation is that sometimes that higher level
is one level higher and sometimes two levels (Fig-
ure 9). This is essentially the same idea as that of
deep instantiation, in that it provides a mechanism
for instantiation across multiple levels. Whilst a
formal proposal based on these ideas was made
to the OMG for UML Version 2.0 (OMG, 2002),
it was not included in the standard (OMG, 2006);
although it presages proposals for a single level
model alluded to in Section 4. This is arguably,
as it stands (but not as argued in Section 4), also
a Ptolemaic fix!
2.2.2.3. The Clabject Fix
The next problem that can be identified with Fig-
ure 3 is the sole use of instanceOf between layers,
which immediately leads to a chain of instanceOf
relationships. The problem here is that, when
we take the normal modelling interpretation of
instance as an (atomic) individual or particular,
we see that instanceOf strictly relates to a pair of
layers only. This means that it is an intransitive
relationship that creates an instance (an object)
from a type (e.g. an OO class); since this instance
is indeed an individual it cannot then be further
instantiated. This is consistent with the basically
two-layer model embedded within the four-layer
architecture of Figure 3. Whilst it is of course
possible to view a class (or type) as an individual,
this is not anticipated within the OMG modelling
architecture. The consequence of such an extended
instanceOf chain would be the need to consider
its mathematical representation in terms of sets of
sets – an approach that deserves future attention
but which has historically not been considered.
However, what is often required is such a chain
of entities linked by instanceOf relationships, as
shown in the left hand side of Figure 10. The
modeller here wishes to state firstly that Prancer
is a Horse, so that it is appropriate to model the
idea of a Horse as a class but that we also wish
Figure 9. Instantiation of the MML metamodel
(after Álvarez, Evans, & Sammut, 2001) (with kind
permission of Springer Science+Business Media)
100
Ptolemaic Metamodelling?
to connect the Horse class to the definition of
Class in the metamodel – this leads to the need for
conformance of that Horse class to an entity in the
defining metamodel, here the class named Class.
As noted above, however, this double instanceOf
chain must be invalid by virtue of the essentially
two-layer nature of the traditional OO modelling
approach (as discussed above). In our preliminary
investigations (Gonzalez-Perez and Henderson-
Sellers, 2007), we suggest that what must happen,
as depicted on the right hand side of Figure 10, is
that the developer automatically inserts a mapping
from obj1:Horse (the object conformant to class
Class) to a class of the same name, Horse, from
which individual horses, such as Prancer, can be
instantiated in the model. Another interpretation
is that the middle level entity is neither wholly a
class nor wholly an object. It is an amalgam of
class and object, an entity named ‘clabject’ by
Atkinson (1999). Introduction of these clabjects
into the four level strict metamodelling hierarchy
clearly represents another Ptolemaic ‘fix’.
2.2.2.4. The Powertype “Fix”
The fourth problem results from a confusion
between, and consequent misapplication of, the
generalization relationship and the instantiation
(instanceOf) relationship. This is most clearly
seen when simple set theoretic representations
of types/classes and their instances are depicted
using Euler or Venn diagrams14. If we represent
each class as a set, then the instances of that class
(objects) are members of that set (Figure 11)
the allocation of a particular instance to a class
(set) being called classification (for an interesting
discussion of classification and categorization,
although not ontology-related, see Lakoff [1987];
a more recent detailed discussion of generaliza-
tion compared to classification in the software
modelling language context is to be found in
Kühne [2009]). A collection of a limited number
of these members creates a subset (in OO terms,
a subclass or subtype – see also Cardelli, 1988),
which is represented in an OO modelling language
by a generalization/specialization relationship
(Figure 12). As seen in Figure 12, any individual
member of the subset A is also a member of the
set B but the subset A is NOT itself necessarily
a member of set B. On the other hand, if all the
individual members of set B are grouped into a
finite number of partitions, then each partition can
be visualized as a member of a set – but this set
Figure 10. On the left-hand side, horse is shown as
a class that is also an instance of class, which is
impossible within the conventional object-oriented
paradigm. On the right-hand side, horse is shown
as a class that is specified by the objects obj1
through a forward-looking isotypical interpretive
mapping (depicted as a solid arrow).
Figure 11. Simple set membership representation
useful for OO classes and their instances (after
Henderson-Sellers, 2012) (with kind permission
of Springer Science+Business Media)
101
Ptolemaic Metamodelling?
(as shown in Figure 13) is NOT the set B. This
subtle distinction between the two different uses
of an Euler diagram showing topological inclusion
(physical containment on the two-dimensional
plane) highlights a common confusion when
depicting generalization and instantiation using
essentially the same graphical means and trying
to make logical deductions from the visualizations
alone (see also later discussion).
Such mathematical representations have been
in use in simple form for many years (e.g. Martin
& Odell, 1992) but only by a limited set of authors
discussing (object-oriented) modelling. In the last
decade, with the rise of the acceptance of
metamodelling as a formality for modelling lan-
guages, more extensive use of set theory (to-
gether with a promise of category theory) has
been made (e.g. Whitmire, 1997; Henderson-
Sellers, 2012) – see more detailed discussion in
Section 3.1.
A solution to the generalization and instantia-
tion (instanceOf) relationship misapplication has
been explored in series of papers by Henderson-
Sellers & Gonzalez-Perez (2005, 2006); Gonza-
lez-Perez & Henderson-Sellers (2006) using the
mathematical ideas of powertypes (e.g. Cardelli,
1988) - introduced into software modelling first
by Odell (1994) (see detailed discussion in Sec-
tion 3.1 below). Whether powertypes provide our
next Ptolemaic fix (as suggested by Atkinson,
Gutheil, & Kennel, 2009) or whether they are the
progenitors of a modelling revolution remains to
be assessed.
2.2.2.5. The “Orthogonal
Classification Architecture Fix”
The next concern that arose in the literature (At-
kinson & Kühne, 2003) led to the creation of two
sorts of metamodelling: linguistic and ontological.
Figure 14 shows the ‘Orthogonal Classification
Architecture’ that these authors proposed. It has
three linguistic layers: the top L3 layer being the
layer in which a Metaclass is defined. Instances
of this (in the L2 layer) are entities such as Class
and Object (although often objects are considered
to be in the L0 layer since they are instances of
classes in the L1 layer15 a well known UML
paradox, e.g. Atkinson & Kühne, 2001a). Since
this L2 layer provides the ‘metamodel’ or, arguably
(see discussion below), the ‘modelling language’
then the model (as created by software develop-
ers) contains entities representing concepts and
things in the real world (e.g. Lakoff, 1987, p. 8)
(or at least the domain under consideration). In
this example, these are Rover (an individual),
Collie (a concept or class of dogs) and Breed. The
Figure 12. Representation of a subset as an Euler
diagram (upper) and as a UML model (lower)
Figure 13. Representation of each subset of set B
as an element in a new set, C
102
Ptolemaic Metamodelling?
argument proposed by these authors is that there
is a close parallel between Rover-Collie-Breed
(left hand side of Figure 14) and Object-Class-
Metaclass (right hand side) and thus one should
deduce that Breed is in some way a metaclass.
Clearly this is not a metaclass in the way that
Class or Metaclass are on the right hand side of
this diagram since obviously one would not expect
to find a Breed entity in any standard definition (at
the ‘M2’ level of Figure 3) of a general purpose
modelling language (whether or not one could
expect it in a domain-specific modelling lan-
guage is another question that we do not address
here). The authors therefore conclude that what is
needed is a second kind of multilevel modelling
hierarchy in which Breed, Collie, and Rover can
co-exist whilst, at the same time, be described
using instanceOf relationships and hence some
kind of multilevel architecture that looks highly
similar to the OMG architecture of Figure 3. To
facilitate this, the notion of ‘ontological instan-
ceOf’ is introduced as distinct from the linguistic
instanceOf that links elements in the real world
to defining classes in the modelling language’s
metamodel. Thus, it is argued that, even though
strict metamodelling forbids instanceOf within a
layer, this is now understood to mean linguistic
instanceOf. In other words, ontological instanceOf
is permitted within such a single linguistic layer
e.g. L1, but, conversely, is not to be used between
linguistic layers
A number of authors have tried to extend these
ideas further in the search for a ‘Level-Agnostic
Language (LAL)’ (e.g. Atkinson, Kennel, & Goß,
2011a). Other authors (e.g. Seidewitz, 2003) have
argued for instanceOf within a layer based on the
assumption that such a single layer is formally a
‘theory’, which, by definition, permits instanceOf
relationships within it i.e. within a single layer
and not between layers – effectively a contradic-
tion of the assumptions underpinning strict
metamodelling.
An associated discussion is exemplified by
the challenge of modelling products and product
categories. A typical example is that of cars, their
brands (e.g. Toyota), models of a given brand
(e.g. Prius, Camry, Corolla) and variants on those
models (e.g. Prius, Prius c, Prius v). Suggestions
can be found in the early OO literature and, more
recently, in Atkinson and Kühne (2008) and Neu-
mayr, Schrefl, and Thalheim (2011). These latter
authors compare several means by which multi-
level modelling (i.e. not multilevel metamodelling
as we focus on in this chapter) can be accomplished
by means of powertypes16 (two versions), deep
instantiation and materialization, evaluating these
approaches with several functional characteristics
including accidental complexity, a topic discussed
more by Atkinson and Kühne (2008). In both these
studies, however, all classes and instances belong
to the L1 domain of Figure 14 albeit at a range of
ontological (Ox) levels. These studies, although
interesting applications of deep instantiation and
powertypes, do not consider language definitions
nor linguistic metamodels and so will not be
discussed further here.
Figure 14. Linguistic versus ontological metamod-
elling (slightly modified from Henderson-
Sellers, 2012) (with kind permission of Springer
Science+Business Media)
103
Ptolemaic Metamodelling?
2.2.3. The Need for a Copernican-
Style Revolution in Metamodelling
The conclusion one must make is that several
Ptolemaic fixes have already been applied to a
general purpose modelling language ensconced
in a multi-layer framework. To improve these
modelling languages further, other avenues have
been explored in particular suggestions to in-
corporate foundational ontologies and insights
from language use.
Over the past few years, such collaborations and
technology transfer have been attempted between
ontology engineering and software engineer-
ing, specifically software modelling languages.
For example, using the Unified Foundational
Ontology (UFO) (Guizzardi, 2005), Guizzardi,
Wagner, Guarino, and van Sinderen (2004) make
some suggestions regarding the incorporation of
ontological classes into the UML metamodel.
Such contributions reflect a slightly different
mindset in domain ontologies – that of a single
inheritance tree and precious few other relation-
ships – as compared to an object modeller who
will minimize the depth of inheritance hierarchies
and, conversely, populate their UML models with
a range of relationships such as associations and
aggregations. Linking ontologies, metamodels
and modelling languages has been explored, for
instance, by Aßmann, Zschaler, and Wagner (2006)
and Henderson-Sellers (2011a). A coalescence of
these ideas together with set theory is explored
in Henderson-Sellers (2012) and in further detail
in Section 3.4.
Even more recently, the disciplinary area of
language use (e.g. Austin, 1962) and, especially,
speech acts (e.g. Searle, 1969) have begun to be
considered in the modelling and metamodelling
literature. Eriksson, Henderson-Sellers, and
Ågerfalk (2013) show how these ideas can be
fully integrated into a modelling language whilst
in his introduction to the book The Evolution of
Conceptual Modeling, Kaschek (2011) uses not
only the term speech act but also refers tolanguage
games’ with reference to Wittgenstein. To date,
the direct influence of philosophers is limited.
However, it is becoming clear that conceptual
modelling has a Lockean basis – Locke’s (1690)
ideas (see also Armstrong, 1989) now generally
having been replaced by philosophical thoughts
of, for Brentano (1874) and Peirce (1898). Such
recent and pending influences need to be dis-
cussed in detail and evaluated in terms of their
potential applicability to conceptual modelling,
potentially offering more revolutionary ideas to
the discipline of software language engineering
(paper in preparation).
Notwithstanding, the ontological/linguistic
debate continues, linked strongly to the assertion
that strict metamodelling should be maintained
at all costs (e.g. Atkinson, Gutheil, and Kennel
[2009], who state that “Without this principle, the
definition of model levels becomes somewhat ar-
bitrary”). This need to retain strict metamodelling
is at the core of many of the ‘Ptolemaic fixes’ that
have occurred in software language engineering
since the mid-1990s. In summary, these are:
The potency fix.
The product and process alignment fix of
methodology.
The clabject fix.
The powertype fix.
The ‘Orthogonal Classification
Architecture’ fix.
It is as yet unclear whether powertypes con-
stitute a ‘Ptolemaic fix’ or whether they are the
harbingers of a new mindset in conceptual mod-
elling and metamodelling – a quandary we will
attempt to resolve in the latter part of this chapter.
The challenge (that we address below) is there-
fore the need to identify a formal (mathematical)
underpinning that permits (1) standardization
(i.e. not accessible to developers), (2) model-
ling languages (used by software developers)
for both product and process, and (3) a means
to represent the static and dynamic aspects of
104
Ptolemaic Metamodelling?
process enactment. Clearly the axioms currently
used in strict metamodelling are not helpful for
contemporary product and process modelling (i.e.
we need, at least, to be able to link the attribute
definitions of a class at ‘M2’ to the slot values of
a corresponding instance at ‘M0’: Figure 15) as
well as for linking methodologies to ontologies.
We suggest here that too many Ptolemaic fixes
have been made already; a Copernican revolution
is needed to sweep away the old and introduce a
new metamodelling mindset.
As a critical part of that impending revolution,
the equivalency of modelling language and
metamodel needs to be challenged; the underpin-
ning philosophy tenets of conceptual modelling
need to be investigated and a new paradigm needs
to be identified, developed and adopted. We sug-
gest that it is time for a Kuhnian (1962) paradigm
shift from our current Ptolemaic (read strict
metamodelling) way of thinking to a new Coper-
nican model of our particular software universe
(software language engineering and conceptual
modelling).
3. EVOLUTION: ADDITION
OF SAFETY HARNESSES
IN MODELLING
The history of computing is that of adding increas-
ing usability and safety. Early programming re-
quired significant knowledge and technical ability
in coding in machine code. Later developments
led first to assembler and then to procedural lan-
guages such as COBOL and FORTRAN that were
nearer to a human’s mode of speech – although
still stilted. Such an innovation at the same time
makes coding easier, making it harder to make
‘stupid mistakes’ in the binary code (now to be
generated) but at the same time denies the ability
of the good programmer some flexibility. The
next innovation, object technology, added addi-
tional safety by enforcing a significant degree of
modularization and information hiding (Parnas,
1972). The interfaces of the program chunks (now
objects, previously subroutines) are minimized by
default. Nevertheless, it is still quite possible to
do excellent modular programming in an older,
non-object-oriented language such as FORTRAN
but it requires some attention to detail and addi-
tional work on the part of the programmer. With
an object-oriented programming language such as
Eiffel (Meyer, 1988) it is not possible to violate
these modularization principles.
Similar comments apply to the evolution (and
potential evolution) of modelling languages and
their incarnations in the form of drawing and CASE
(computer aided software engineering) tools. A
drawing tool like VisioTM is able to support the
drawing of all the symbols of UML but has no
knowledge of the semantics of the modelling lan-
guage. A CASE tool that embodies the language
rules will ensure that the modeller does not violate
the rules of the modelling language, perhaps by
greying out inappropriate selections. With such a
contemporary CASE tool, one could quite easily
draw the two model fragments shown in Figure
16. They could readily be understood as saying (a)
that there are several kinds of customer, especially
Figure 15. The challenge of retaining a class-
instance relationship for contiguous pairs of layers
and identifying an appropriate mathematical link
between OMG levels M0 and M2 in particular
105
Ptolemaic Metamodelling?
persons and corporations; and (b) that a person
is a special kind of headache. In this chapter, we
will argue that both of these are ontologically
invalid, despite them being syntactically valid
UML models suggesting therefore that UML
itself is incomplete insofar as it permits such
invalid diagram fragments to be drawn.
In the following subsections, we explore in
detail some of the several solutions proposed in
respect to the issues raised in Section 2. We first
explore the double instanceOf relationship em-
bodied in much of the strict metamodelling lit-
erature and how powertypes appear to offer at
least a partial solution, contrasting this approach
with deep instantiation plus potency. We then
introduce foundational ontologies and examine
their support for various characteristics (notably
adjectival properties using a moment universal
and temporary properties captured in the notion
of a role) that can be said to embellish a basic
class in a conceptual model.
In Sections 3.4 and 3.5, we describe the recent
contributions that have resulted from an examina-
tion of language use its incorporation, along with
foundational ontologies, into the definition of a
software modelling language.
3.1. Metamodelling Basics
As noted in Section 2, the type-instance relation-
ship has been, for many years, taken as axiomatic
in contemporary software modelling languages.
This leads naturally, as we have seen, to represen-
tation of classes and types as sets with members
of those sets representing individuals or instances
(Figure 11). The term ‘meta’ is then often used
to refer to the type layer relative to the instance
layer (e.g. Atkinson, 1999).
Whilst this type-instance model works well
across two-layers, as we have seen, software
language engineering requires more than two lay-
ers, especially for modelling processes. We can
thus depict not only M0 instances of an M1 type
but also M1 instances of an M2 type (Figure 17)
or even M2 instances of an M3 type (not shown
here). Thus the members of an M2 level class
are in fact types/classes representable as sets.
Furthermore, it is generally accepted that, while
sets have members, these only form the extension
of the set. To create a type, we need to add some
semantics in the form of rules that determine
whether a candidate member does or does not
belong to the set. Such rules are generally in the
form of a predicate, p(x), and are said to be the
intension of the set. Kühne (2009) notes that this
approach uses ideas from Carnap (1947): a pupil
of Frege who extended the ideas on Wittgenstein
(1921) and developed the notion of a ‘concept’ as
being the entity represented by a mathematical set
or, with an intension, a type (e.g. Frege, 1892b);
although such categorization may not always be
consistent with a single set of unalterable and
readily identifiable properties (Wittgenstein,
1953, pp. 6-71)17. This notion of ‘concept’ was
also a key in the work of Martin and Odell (1992)
in explaining the theoretical ideas behind object-
oriented modelling. However, the idea of concept
has more recently been challenged on philosophi-
cal grounds – another indication that a revolution
in metamodelling thinking is due. Smith (2004)
identifies significant ambiguity in the use of the
term and recommends its avoidance, particularly
in the context of domain ontologies. Indeed, Searle
(1969) recommends that we should abandon the
use of the word concept in our current context.
Figure 17 illustrates two type-instance relation-
ships (as seen also in Figure 15). It is tempting,
but incorrect, to link these in a ‘double instanceOf’
Figure 16. Two ontologically incorrect examples,
both of which are valid UML models
106
Ptolemaic Metamodelling?
chain (Figure 18) and continue to assert that this
remains valid according to the basic type-instance
axiom. Figure 18 shows an individual dog (Rov-
er) as an instance of a Dog set combined with,
supposedly, the statement that a Dog (now a class)
is an instance of the UML (M2) class called Class
(i.e. a Fregian concept). The problem here is
simply that Dog as a set with members such as
Rover is NOT the same as the Dog class, when
considered as an instance of the M2 Class. This
is readily seen when we consider the attributes of
Dog as a class and Dog as an instance in the
model. As an object, Dog might have attributes
(instantiated from the UML V2.4 class Class) of
isActive=F; isAbstract=F;
isFinalSpecialization=F; whilst Dog as a class is
likely to have attributes such as name, height,
colour.
The only acceptable and simplistic mathemat-
ical description of data such as that in Figure 17
or Figure 18 is that of a set of sets. In other words,
in Figure 18 we could say that Class is a set con-
taining a number of members, all of which are
themselves sets (e.g. the Dog set, the Cat set, the
BankAccount set). Then the Dog set has many
members, one of which is Rover. Whilst tradi-
tional (OMG) metamodelling has focussed on
pairs of levels (simple set membership), this revi-
sion to sets of sets may provide an improved
multilevel architecture of the future, remembering
that one aim is to standardize elements at the M2
level such that appropriate attributes and their
values occur at the correct level (M1 or M0).
However, it does not provide an ability to transmit
attributes from their specification in M2 to an
attribute value at M0 i.e. a set of sets model ef-
fectively decouples the M0 and M2 levels.
Another mathematical construction in set
theory, closely aligned but potentially confused
with set of sets, is the powerset. A powerset is
defined as a set composed of all possible subsets
– a very simple example is shown in Figure 19.
In software engineering, a similar notion was
introduced by Odell (1994) and named, perhaps
a little inappropriately, ‘powertype’ since this
software version does not contain all subsets but
only sufficient subsets to partition the original
set. Strictly, this is called a ‘family of sets’ in
mathematics although for historical and continu-
Figure 17. Using set theory to represent instanceOf
Figure 18. An often seen double instanceOf chain
purportedly to represent both rover as an instance
of a dog class and, at the same time, dog as an
instance of class
107
Ptolemaic Metamodelling?
ity reasons we will continue to utilize the name
‘powertype’ for this.
Indeed, as noted in Section 2, there is a pos-
sibility of confusion when we re-look at the
members in a set and partition them into subsets.
Figure 20 shows one such example in the software
methodology domain. We can model various
activities within a methodology, grouping some
of these as Design-type activities, some as Code-
linked activities and the remainder as Testing
activities (left hand side of Figure 20). This group-
ing creates, in this example, three partitions such
that each partition in the Euler diagram can be
represented in OO fashion as one class (named
Activity) with three subclasses/subtypes as shown.
This model also uses the UML generalization
relationship to link subtypes and (super)type. If
we now consider each partition as a single entity
(right hand side of Figure 20), then we can con-
struct a new set representation which has three
members only: DesignActivity, CodingActivity
and TestingActivity. Clearly this must represent
a different class/type from the Activity class since,
obviously, there is a large disparity in the number
of elements in each of these two sets, the one on
the left being our original Activity class/set and
the one on the right with a new appellation of
ActivityKind. The relationship between Activi-
tyKind and, for example, DesignActivity is that
of instanceOf. Confusion can often arise because
the name ‘Coding Activity’ can be interpreted as
both the name of the sector (Figure 20 left hand
side) and the name of an instance (Figure 20 right
hand side). We could also say ‘a coding activity’
meaning an individual member of the Coding
Activity sector in the left hand diagram of Figure
20.
Further inspection of Figure 20 leads to the
identification of, for example, DesignActivity as
both a subtype of the type called Activity and as
an instance of a type called ActivityKind. Fur-
thermore, the members of the set ActivityKind
each represent one of the partitions of the set
called Activity. We can thus redraw this informa-
tion as a powertype pattern as shown in Figure
21. Note that this also means that DesignActivity
etc. are in fact clabjects. Thus, they have not only
an object facet but also a class facet so that, from
this class facet, further instantiation can take place.
Figure 19. A powerset D contains elements of all subsets of the original set C
Figure 20. Comparison of generalization and
instantiation for the same data set (modified from
Henderson-Sellers, 2011b) (with kind permission
of Springer Science+Business Media)
108
Ptolemaic Metamodelling?
If we now (at least loosely) place Activity and
ActivityKind in the OMG architecture’s M2
level, then DesignActivity, CodingActivity and
Testing Activity are at the M1 level (i.e. they are
part of the process model a.k.a. methodology see
discussion of Figure 8 above) and a project-spe-
cific (instanceOf) DesignActivity, say called
Brian’s design activity can be created at the M0
level. If, for the sake of argument, we wanted this
M0 level instance to have an attribute value of 2
days for an attribute called Duration whilst ac-
knowledging that all instances of DesignActivity
needed a managerial signoff, then we can represent
this as shown in Figure 22. Although this is cur-
rent state-of-the-art, in Section 2 we concluded
that clabject and powertypes were (probably)
Ptolemaic fixes. This is a major target of the
revolution proposed in Section 4 below.
Gonzalez-Perez and Henderson-Sellers (2008)
argued that powertypes have value in software
engineering metamodelling whether this is valid
or whether powertypes are a current Ptolemaic
fix such that they should be replaced remains an
open question. However, we do note that some
other authors have reservations about the use of
powertypes although this relates more to their use
in modelling than in metamodelling. For instance,
Halpin (2005) argues that for most modelling
examples he can devise (see also modelling ex-
amples in Martin & Odell, 1998), there are better
ways of accomplishing the same result without
using either powertypes or the very similar ideas
of materialization (Pirotte, Zimányi, Massart, &
Yakusheva, 1994; Dahchour & Pirotte, 2002). For
many modelling situations, this is undoubtedly true
but for the specific multilevel issue of declaring
an attribute at the metamodel/standardized level
that should not be given a value until two ‘levels
lower (as discussed above), there is no simple al-
ternative, other than potency, which, as we discuss
below, appears to have less theoretical foundation
than powertypes although at the same time being
easier to implement.
As noted above, Figure 22 shows how the use
of powertypes, themselves mathematically based
(as discussed above), can lead to a solution to the
challenge of defining attributes in the metamodel
but refraining from allocating values until the
endeavour level (i.e. at enactment). The result is
not dissimilar to the result achieved by the more
pragmatic use of potency and deep instantiation
(Figure 7) – a visual comparison of these two
approaches is shown in Figure 23. In this ap-
proach, each attribute of a class has an associated
potency value. Each time the responsible class is
instantiated, the potency value of all its attributes
Figure 21. Representation of the data of Figure
20 as a traditional powertype pattern
Figure 22. An illustration of the use of a powertype
to support attribute values at both M1 and M0 level
109
Ptolemaic Metamodelling?
is decremented. When the potency has a value of
zero, a value must be assigned.
The deep instantiation plus potency approach
was invented in order to permit multilevel model-
ling of processes and methodologies; particularly
to permit standardization at OMG level M2 for
methodology elements that had attributes that
need to have their value allocated at OMG level
M0 i.e. two levels below the metamodel standard.
Type-instance semantics is unable to provide
such support; this newer potency approach is,
although the underlying theory is either arcane
or unavailable.
These issues are also discussed in detail in
Atkinson, Gutheil, and Kennel (2009) although
in that case the context is that of insisting that
a solution fits within the strict metamodelling
hierarchy of Figure 3 (which deep instantiation
does but which powertypes do not). Indeed, the
use of powertypes necessitates a new multilevel
architecture, as shown in Figure 24. In this archi-
tecture, devised initially for use in the International
Standard ISO/IEC 24744 (ISO/IEC, 2007), the
‘levels’ (here renamed ‘domains’) are defined in
terms of what is observed in practice viz. people
work on endeavours (in the Endeavour Domain),
they use tools, methodologies etc. in the Method
Domain, all of which are defined by a metamodel
(which thus defines the scope of the Metamodel
Domain).
Gonzalez-Perez and Henderson-Sellers (2008)
note that the potency approach has the advantage
of having one less class to consider and that the
potency idea is not limited to the three layers that
we have used in this example. However, the use
of an additional class in the powertype approach
allows an explicit differentiation between the
two very different classes (xxx and xxxKind:
as we shall see later, these are a base type and a
universal – see Figure 20), that are by necessity
convoluted in the potency approach. Secondly, in
the potency approach there is an implicit intro-
Figure 23. Comparison of potency and powertype approaches (after Gonzalez-Perez & Henderson-
Sellers, 2006) (with kind permission of Springer Science+Business Media)
Figure 24. Multi-level architecture based on pow-
ertypes rather than strict metamodelling (after
Henderson-Sellers, 2006)
110
Ptolemaic Metamodelling?
duction of a generalization relationship (as noted
above), hidden within the instance-of relationship
overlain by a potency decrement whereas in the
powertype approach the necessary generalization
relationship (which after all is responsible for the
ability of either of these approaches to transmit
attributes unchanged) is explicit. According to
these two aspects, it could be argued that the
powertype approach allows for a more faithful
and explicit representation of the SUS.
3.2. The UML Metamodel: Improving
Its Modelling Language Contribution
As noted above, the current UML needs a degree
of developer discipline and expertise to use it to its
fullest potential. It is, nevertheless, still possible
to draw ontologically incorrect diagrams such as
those introduced earlier e.g. Figure 16. This is
because the finest grained ontological concept in
UML is Classifier18 (and its immediate concrete
subtypes such as Class). Although instances and
classes are differentiated in the UML, their repre-
sentation has changed over the various versions and
in all cases there is no cognizance taken of a basic
discriminant used in some schools of ontology
engineering: that of endurants and perdurants (e.g.
Johansson, 2005) (Figure 25) – these four ‘leaf’
classes being well recognized in both ontology
(e.g. Guizzardi, 2005; Laarman & Kurtev, 2010)
and philosophy (e.g. Aristotle in translation, 1984;
Smith, 1997; Lowe, 2001; Partridge, 2002); noting
that in some philosophical approaches (e.g. Quine,
1960; Lewis, 1971; Sider, 2003), only perdurants
are recognized (see also http://plato.stanford.edu/
entries/temporal-parts).
Foundational ontologies contain a much richer
classification hierarchy, subtypes of the four ‘leaf’
classes of Figure 25. For example, Figure 26
shows the hierarchy proposed by Guarino and
Welty (2000) and Figure 27 depicts a similarly
scoped proposal by Guizzardi (2005) known as
the Unified Foundational Ontology or UFO. It
is this latter that we will use in our subsequent
Figure 25. Basic structure of a foundational
ontology
Figure 26. A formal foundational ontology as
devised by Guarino and Welty (2000)
Figure 27. A formal foundational ontology as
devised by Guizzardi (2005)
111
Ptolemaic Metamodelling?
discussion since the context of its derivation was
closest to our context of modelling languages and
metamodels (e.g. Guizzardi, Wagner, Guarino, &
van Sinderen, 2004; Guizzardi & Wagner, 2005),
although as part of our ongoing philosophical and
ontological analysis of metamodelling approaches
we intend to provide an improved foundational
ontology (paper in preparation). In particular, we
will utilize instances of MomentUniversal and
RoleType, the definitions for which are given by
Guizzardi and Wagner (2005) as:
Definition 1: A MomentUniversal is a kind of
EndurantUniversal that cannot exist by itself;
that is, it depends on other EndurantUniver-
sals that are not among its parts
Definition 2: A RoleType is a “sortal type that is
anti-rigid and for which there is a relationship
type such that it is the subtype of a base type
formed by all instances participating in the
relationship type.”
Guizzardi and Wagner (2005) give as an ex-
ample of RoleType that of Student. This is clearly
anti-rigid since it can have instances (e.g. John)
that are presently members of the extension of
the Student class but could easily (at a later time)
leave i.e. remove themselves from such set mem-
bership. (A similar notion is depicted by Martin
and Odell [1995] – see Figure 28). However, since
we are depicting these ontological categories in
terms of set theory, the concern arises that sets
do not change membership (Partridge, 2012,
pers. comm.) since the set and its membership
are inextricably linked. In other words, if the
membership changes then the set is no longer
the same set. Figure 29 shows how roles could be
represented in this way, ostensibly as sets. Thus,
whilst the set B is well-defined at time t and also
at time t’ (since it contains the same members at
all times), the subset A that contains member y
at time t must be replaced by a different subset
A’ that does not contain y as a member at time t’.
In other words, the mathematics of roles cannot
be represented simply by set theory and, further-
more, can be aligned with neither classification
nor instantiation as discussed further below. Thus
it is not possible to use set theory to depict a role.
Indeed, the difficulty of adequately representing
such temporal change is recognized by Smith
(2004) who proposes the following modification
to the definition of subsumption:
Definition 3: A is-a B if and only if:
1. A and B are universals.
2. For all times t, if anything instantiates
universal A at t then that same thing
must instantiate also the universal B at
t.
Figure 28. The Brian object takes on roles at
different stages in his life – depicted here as sug-
gested in Martin and Odell (1995)
Figure 29. An individual playing a role may do so
at time t (and hence be a member of the subset A)
but at a later time t’ may be a member of the set
B but this means that the set A must be replaced
by a totally different set A
112
Ptolemaic Metamodelling?
Other important leaf classes in the UFO,
to which we will refer later, are BaseType and
MixinType. The definitions for these are given
by Guizzardi & Wagner (2005) as:
Definition 4: A BaseType is a SortalType that
is rigid (all its instances are necessarily
its instances) and that supplies an identity
criterion for its instances
Person is given as an example of a BaseType.
It is easily seen that all instances of Person (as
a class) – e.g. Brian, Owen – are necessarily in-
stances of Person and that each instance has an
identity criterion, as defined by the Person class.
Definition 5: A MixinType is an entity type that
is not a sortal type and can be partitioned
into disjoint subtypes which are sortal types
(typically role types) with different identity
criteria. Since a mixin is a non-sortal it can-
not have direct instances.
Mixins tend to describe characteristics that
are ‘adjectival’ i.e. they are concepts existentially
dependent upon a substantial universal. Examples
might be RedObject, which might refer to an
apple, a shirt or a car) and Product (television,
car, wine bottle). Interestingly, Customer can also
be said to be a mixin as it could refer to a person
or an organization – although some authors use
Customer as a prime exemplar of the RoleType (a
digression that we will not address here). Argu-
ably, mixins provide yet another Ptolemaic fix,
worthy of further analysis using a well-founded
philosophy of modelling (paper in preparation).
An important element of the above five defi-
nitions is the notion of identity. Introduced into
philosophical discussions by Frege (1884, 1950),
emphasized by Wittgenstein (1958), yet still hotly
debated (Noonan, 2011), the criterion of identity
is used to determine whether two things are the
same or not.
To augment a modelling language, like UML,
with a broader ontological basis, one could ‘hang’
a hierarchy such as that in Figure 27 beneath a leaf
class in the UML by making Universal (entity type)
a direct subtype of Class (and transitively of Clas-
sifier) (Figure 30) - together with new subtypes
of the Dependency Relationship and Association
and introducing new meronymic relationships into
the extant UML metamodel.
Such a new availability of metalevel classes
(quasi M2) such as MixinType and, especially,
MomentUniversal, offers extended modelling
capability that allows for much greater quality
modelling in the sense that no longer does ev-
erything have to be a base type (since in current
UML, base types are essentially the only kind of
class available to the modeller). Thus, for example,
moment universals such as ‘headache’ or ‘dog
breed’, which are concepts that are existentially
dependent on other concepts, can be modelled
directly. Figure 31 shows a simple association
Figure 30. The addition of a foundational ontol-
ogy into a standard modelling language like UML
113
Ptolemaic Metamodelling?
that attaches Headache to Brian (not shown) or
Collieness to Rover.
Recognition of the availability of moment
universals now also permits a re-evaluation of
the double-instanceOf conundrum as seen in the
literature and as exemplified earlier here in Figures
10 and 18. One recent example was identified in
the literature (Atkinson, Gutheil, & Kennel, 2009)
as a major running example in their evaluation of
potency as compared to powertype modelling. An
analogous example is given in Figure 32.
As well as the obvious double instanceOf, there
are several other concerns in Figure 32.
A type (e.g. MedicalPractitioner) can-
not be an instance of another type (e.g.
Profession), see the “powertype fix”
above19. If MedicalPractitioner were an in-
stance of Profession, then it is an object (an
individual) that cannot be further instanti-
ated (to Peter) – unless we extend tradi-
tional modelling to include types of types
(sets of sets).
Peter is an instance of a base type, Person,
which is not included in the model.
MedicalPractitioner is not a base type, it is
a property name (Searle, 1969).
MedicalPractitioner cannot be an instance
of Profession – either MedicalProfession
is an instance of Profession or
MedicalPractitioner is an instance of
Professional.
Figure 33 underlines some of these concerns
graphically, with the third of the four corrections
above now incorporated i.e. Profession moderated
to be Professional. Remembering that a diagram
such as this can easily confound set membership
with set partition, we can see that this is exactly
what is happening with respect to the UML double
instanceOf diagram on the left hand side of this
diagram. On the right hand side we see in the
Euler diagrammatic representation that Peter is an
individual instance of the MedicalPractitioner set
and, secondly, that the Professional set contains (at
least) three subsets (partitions), here exemplified
as the Civil Engineer, the Medical Practitioner
and the ITProfessional. To reprise earlier discus-
sions, we see that although Peter is an instance of
MedicalPractitioner and MedicalPractitioner is a
member of Professional, we CANNOT conclude
that Peter is a member of Professional.
For a better quality model, we can utilize the
ideas of moment universals as shown in Figure 31,
Figure 31. The use of a moment universal to depict
existentially dependent characteristic of base types
Figure 32. An example of a double instanceOf
chain of three linked classes
Figure 33. Slight revision of the double instanceOf
chain of Figure 32 together with a depiction in
terms of an Euler diagram
114
Ptolemaic Metamodelling?
since Profession is actually a moment universal
as it complies with Definition 1 above. Conse-
quently, Figure 34 offers a more accurate model
diagram than Figure 32. The base type of Person
has a Profession (a moment universal) and then
an instance of each is taken to represent the fact
that Peter (an instance of Person) has a profes-
sion, which happens to be the MedicalProfession.
Alternatively, we show this more mathematically
as a function that maps instances of the Person
set into instances of the Profession set (Figure
35) (the use of mathematical functions or map-
pings in this context is explored in more detail in
Henderson-Sellers, 2012).
3.3. The Challenges of
Role Modelling
Roles, which are one example where the quali-
ties of a particular may change with time, have
been long regarded as important in conceptual
modelling and, especially, in agent models. The
availability of RoleType in the UFO, once added
to a modelling language, makes available a direct
representation of roles rather than having to create
them as stereotypes of a UML class (or similar) as
is presently the case. These are shown in Figures
26 and 27 where they are depicted using UML
generalization relationships. This generalization
relationship is defined in UML.
A classifier can only specialize classifiers
of a valid type. This valid type is defined by an
operation maySpecializeType:
Classifier::maySpecializeType(c:
Classifier): Boolean;
maySpecializeType = self.
oclIsKindOf(c.oclType)
Thus, a classifier may only specialize classifiers
of the same or a more general type e.g. an associa-
tion cannot specialize a class or vice versa since
“neither of the Association or Class metaclasses
is a specialization of the other” (Seidewitz, 2012).
Consequently, a base type can specialize a rigid
sortal but not an anti-rigid sortal (e.g. phase type,
role type). This means that generalization relation-
ships between instances of two ‘leaf’ classes is not
permitted. Thus, by incorporating a foundational
ontology (here Figure 27; itself interpreted as a
UML class diagram) into a modelling language
like UML and, as a consequence, necessarily
adopting the rules of UML, we can immediately
see that the two models proposed in Figure 16
are invalid. A person cannot be a customer since
the former is (an instance of) a base type while
the latter is a role type. Similarly, a headache is a
moment universal. In both cases, the metaclass to
which these classes (in Figure 16) are conformant
Figure 34. A revised version of Figure 32 using
the moment universal as depicted in Figure 31
Figure 35. Alternative representation of the data
in Figure 34 using mathematical functions (map-
pings) between sets
115
Ptolemaic Metamodelling?
are not related in any way (other than having a
common ancestor). And intuitively, in the first
case, we would not wish a person to be modelled
as a kind of customer since there are many people,
we would argue, that in a given context are NOT
customers and, in the second case, a person being
a headache is nonsensical.
However, appealing to common sense and
intuition20 identifies one problem that is worthy
of discussion: whether it is valid to have a class
representing a role as a subtype of a base type – a
typical example is shown in Figure 36. Guizzardi
& Wagner (2005) insist that commonsense should
permit this – whilst not permitting the inverse i.e.
Person as a kind of Student. In order to do this,
they add a textual ‘override’ in their definition of
RoleType in Figure 27 as given in Definition 2
above. In essence, they are adding an association
in the UFO between RoleType and BaseType as
shown in Figure 37. Arguably another ‘Ptolemaic
fix’!
In fact, it is not even clear that the RoleType
should be the focus of our attention. Rather than
depicting a Person as moving in and out of Roles,
an alternative is to consider Person as having a
set of states, one of which is Student (Partridge,
2012, pers. comm.).
One reason for wishing to validate a diagram
such as Figure 36 is the need for identity. In the
UFO, only a base type (such as Person) can supply
an identity criterion. Clearly an instance of Student
also needs an identity but, being a role type, can
only carry identity and not supply it (Guizzardi &
Wagner, 2005). By making Student a subtype of
Person, it can acquire the ability to create identity.
Our concern is that this introduces a contradiction
since, at heart, Student is a role type that CANNOT
create identity. We suggest that another means for
Student to acquire an identity criterion should be
sought (as we do below).
Somewhat in contradiction to the common-
sense notion that a student should be a subtype
of person, Wieringa, de Jonge, and Spruit (1995)
propose an alternative model in which they require
a role instance to have identity independently of
the base type playing that role i.e. that RoleType
is a RigidSortal (in contradiction to Figure 27). In
other words, in this approach, instances of Student
obey a different principle of identity compared to
instances of Person e.g. Masolo, Guizzardi, Vieu,
Bottazzi, and Ferrario (2005). Guizzardi (2006)
suggests, instead, that the conceptualization of
role in Wieringa, de Jonge, and Spruit (1995)
more closely accords with the notion of a qua-
individual (Masolo, Guizzardi, Vieu, Bottazzi, &
Ferrario, 2005)21 in which the two participating
entities (base type and role type in Figure 27) are
constrained by one or more externally dependent
qualities for example, John-qua-husband involves
a set of rights and responsibilities flowing from
his participation (with Mary) in a marriage event.
Bock and Odell (1994) note that a qua-type is “a
convenient way of referring to subtypes that are
Figure 36. A typical generalization relationship
between a role type and a base type
Figure 37. The necessary introduction of a Sub-
TypeOf relationship linking RoleType to BaseType
in the UFO
116
Ptolemaic Metamodelling?
created solely due to a relationship with another
object type” although often a qua-type is used for
states i.e. types that change over time (Partridge,
2012, pers. com.)
Steimann (2000) also notes that a role is mean-
ingful only in the context of a relationship i.e. he
argues that it must be existentially dependent22
upon a base type (or natural type as he calls it).
Indeed, Masolo, Guizzardi, Vieu, Bottazzi, &
Ferrario (2005) summarize their approach as fol-
lows: “students existentially specifically depend on
persons but they are not persons (i.e. the instances
of Student obey a different principle of identity
than the instances of Person)”. If Steimann’s role
model is accepted, then this statement in itself
immediately precludes the generalization rela-
tionship between Person and Student as shown
in Figure 36.
In order to discriminate between these various
role models, Guizzardi (2006) proposes a harmo-
nization of the two approaches, calling the notion
of role as a moment universal (when the role is
represented as a set of properties possessed by
the substantial individual playing the role) ‘qua
individual type, whilst reserving the name ‘role’
for when the role is itself regarded as a substantial
universal. Perhaps yet another Ptolemaic fix?
Although there is, as noted above, significant
discussion in the literature about roles, especially
in terms of the ‘counting problem’ (Wieringa, de
Jonge, & Spruit, 1995; Steimann, 2000; Guizzardi,
2006), which will not concern us here, another
major aspect of roles is their temporary nature.
In Section 2.2 above (see Figure 29), we saw that
the use of Euler diagrams could be confusing
when representing generalization (classification
and subtyping) as opposed to instantiation (set
membership). Set theory, per se, is essentially
time-independent; roles, by their very nature are
context dependent (time and space).
Whilst following intuition and commonsense
(according to Guizzardi, 2011-2012, pers. comm.),
we need to ask if this Ptolemaic fix (of a textual
override to permit an instance of RoleType to be
a subtype of an instance of BaseType), whilst be-
ing pragmatically useful, is really necessary – or
whether there is a more theoretically useful means
of achieving the same result. The analysis that
follows focusses on the portion of Figure 27 that
describes RoleType as an Anti-Rigid SortalType
and BaseType as a Rigid SortalType. We inves-
tigate the validity of the hypothesis depicted by
the exemplar model in Figure 36 (i.e. that Student
is a subtype of Person).
If we use the mathematical ideas of Figure 17,
then this portion of the UFO can be depicted using
an Euler diagram as shown in Figure 38 (which for
completeness also includes PhaseType although
we will not include this in the following discus-
sion). In this diagram, we note that one member
of the SortalType is Person; whilst Student is a
member of the RoleType partition. These parti-
tions (and the inheritance structure of Figure 27)
are all non-overlapping so that it is obvious that
Person and Student are distinct types. If we now
include the relationships of Figure 36 and depict
the result using types and instances, we might
deduce from Figure 39 that Brian is both a student
and a person (Figure 40) but, more importantly
for our discussion, that Student is an instance of
both RoleType and BaseType. We might therefore
Figure 38. Euler diagram depicting the three types
of Sortals. For each subtype (each disjoint parti-
tion), several instances are depicted. SortalType
is a set with members that are themselves sets,
i.e. SortalType is a set of sets (after Henderson-
Sellers, 2012) (with kind permission of Springer
Science+Business Media).
117
Ptolemaic Metamodelling?
conclude that this means that RoleType and Ba-
seType in fact overlap (Figure 41) and, since our
original assertion was that these two types were
in fact non-overlapping, we have a contradiction.
Hence our original assumption – that Figure 36
is valid – is negated.
Whilst this argument is initially appealing, we
will now demonstrate that it is in fact fallacious.
Figure 39 shows that Brian is a student i.e. he is
a member of the Student class. Now, this Student
class is a specialization of Person (according to
this graphical depiction) so that we can also con-
clude that Brian is a Person. However, Student is
an instance of RoleType so that a diagrammatic
representation such as the right hand side of Fig-
ure 17 is valid i.e. we have no knowledge of the
internalities of this ‘point’ in the Euler diagram
(see also Figure 38 wherein student is just one
element in the set RoleType). Conversely, since
Student is shown in Figure 39 to be a subtype of
Person, then a graphical representation such as
that in Figure 12 is appropriate (Figure 40). This
representation permits us to state that an individual
student (here ‘Brian’) is a member of the Student
subset and consequently also a member of the
Person set. However, it is the Person set that is
a member of the BaseType set. In this case, Per-
son is effectively a ‘point’ (a particular) insofar
as it is not possible to perceive or represent any
internal details of Person in the representation of
Figure 38 i.e. we can make no statement linking
the Student subset (Figure 40) to BaseType, thus
negating any apparent validity of Figure 41. We
have thus used an Euler diagram in two different
topological ways (as discussed earlier with respect
to Figures 11 and 12), but not kept these two ways
separate – as we must.
The only way to extend this set-based argument
is to invoke sets of sets and interpret a ‘M2’ type
as a set of sets. In this case, BaseType in Figure 38
would be interpreted as a set containing a number
of sets, one of which is Person, one Dog and so
on. Then we could invoke Figure 40 to show that
Person is a set with instances of Student etc. But,
Figure 39. UML diagram based on the UFO for
the example of student (assumed to be a subtype
of person – Figure 36)
Figure 40. UML and Euler diagram representa-
tions of brian, the student and the person
Figure 41. Intersecting sets: RoleType and Ba-
seType purporting to show student as belonging
to both sets
118
Ptolemaic Metamodelling?
once again, Student remains a ‘point’ since we are
using type-instance semantics, which is orthogonal
to the type-subtype semantics of Figure 40, only
the latter of which could permit us to represent
Brian as both a student and a person. Thus, with
this revised understanding, we not only show that
Figure 41 is fallacious but we still fail to establish
a valid link between Student and Person i.e. we
cannot yet validate Figure 36.
Rather than a set-based argumentation, we
offer the following, based on consideration of
the practicalities of the application in real life of
permitting Student to be a subtype of Person. If
a role, like Student, is permissible as a subtype
of Person, then so equally are other roles, such as
Customer, BankTeller, Athlete and so on. Many
instances will in fact wish to take on multiple
roles such that multiple generalization is required,
leading rapidly to a combinatorial explosion. Such
modelling approaches have long been regarded
with suspicion in the object-oriented model-
ling literature (e.g. McGregor & Korson, 1993;
Henderson-Sellers & Edwards, 1994).
Consequently, a more accurate representation
of what is happening here is shown in Figure 42,
in which Student as an instance and Student as
a class are clearly differentiated. We therefore
suggest that a model more akin to the ontological
approach would not attempt to link (instances of)
roles and base types using generalization but us-
ing associations. Although the notion of role type
needs further elaboration, a simplified generic
model of such a usage is shown in Figure 43, a
model that could also be extended to other pairs of
Figure 42. A more accurate representation of student and person in the context of BaseType and RoleType
Figure 43. A template for roles, as played by base types: (upper) expressed using UML anonymous object
notation and (lower) for a particular example using UML’s stereotype notation, where the definitions
of the stereotype are undertaken via the hierarchy of Figure 27 (the UFO or an equivalent foundational
ontology)
119
Ptolemaic Metamodelling?
ontological sortal types – or even at a higher level
in the UFO between pairs of endurant universals.
Figure 31 showed how associations between
base types and non-base types can often give a
more mathematically acceptable solution than
some of the ‘Ptolemaic fixes’ that we have been
discussing. Indeed, this ‘pattern’ is also useful
for role modelling. Since Person is an instance of
BaseType and Student is an instance of RoleType,
then, using the template of Figure 43 (upper), the
example of Figure 40 can equivalently be depicted
as shown in Figure 44, analogous to Figure 34.
As before (Figure 35), we can alternatively rep-
resent the information in Figure 44 as a mapping
between two sets (Figure 45). Representing roles
by relationships is also advocated in the descrip-
tion logics approach of Baader and Nutt (2002).
Figure 16(a) presented an ontologically poor
model of customers, people and corporations. If
we now permit the override that allows instances
of RoleType to be able to be subtypes of instances
of a BaseType, then (so Guizzardi and Wagner,
2005 argue) the ontological correct version of
this modelled domain is as shown in Figure 46.
This introduces two more concerns: now, the class
Customer, often used as a typical example of a
RoleType, is represented as a mixin type; secondly,
Figure 46 uses two examples of multiple special-
ization, generally regarded in the OO modelling
literature of the late 1990s as a bad idea.
From Figure 46 we deduce that:
The class Person is an instance of the
BaseType class.
The class PersonalCustomer is an instance
of the RoleType class.
The class Customer is an instance of the
MixinType class.
The class PersonalCustomer is a subtype of
Person.
The class PersonalCustomer is a subtype of
Customer.
And so on.
If we now interpret Figure 46 in terms of an
Euler diagram for the UFO but neglecting Pha-
seType in Figure 27 (as shown in Figure 47), then
we can observe the following facts:
The set representing the class Person is an
instance of the BaseType set.
Figure 44. Application of Figure 43’s template to
the link between person and student
Figure 45. Mapping between members of the set person and the set student
120
Ptolemaic Metamodelling?
The set representing the class
PersonalCustomer is an instance of the
RoleType set.
The set representing the class Customer is
an instance of the MixinType set.
For PersonalCustomer to be a subtype of Per-
son and of Customer, we again need to invent a
relationship that permits generalization between
RoleType and BaseType (as in Figure 36) but
additionally between RoleType and MixinType.
Whilst not impossible, such overrides (as shown
in Figure 37) could quickly proliferate, thus mak-
ing the ‘clean’ structure of Figure 27 somewhat
messy. We could again label these ‘additions’ as
Ptolemaic fixes.
However, if we avoid the textual override to
permit role types to specialize base types, we can
utilize the template shown in Figure 43 to good
effect. Figure 48 shows the resultant model, which
contains only three classes to replace the five-class
structure of Figure 46.
Another Ptolemaic fix is offered by Guarino
and Welty (2001) who state that the property of
rigidity (a property of a base class) is not inherited
by its subtypes. Thus, when trying to ensure that a
diagram such as Figure 36 is ontologically valid,
the anti-rigid nature of a class like Student does
not conflict with an (inherited) rigidity from a base
class such as Person. However, this does violate
not only Liskov-style substitutability but also the
AI guidelines of Brachman (1985).
3.4. Addition of Language
Use Theory
A major motivation for our analysis of metamodel-
ling, as here, is its participation in the definition
of modelling languages. The literature offers two
distinct connections:
1. The metamodel is (defines) the language.
[This is seen in much of the OO metamod-
elling literature (e.g. Gonzalez-Perez &
Henderson-Sellers 2007) and in OMG and
ISO standards like the UML.] Similarly,
the metamodel defines (or represents) the
ontology underlying the language (e.g. Shan
& Zhu, 2012).
2. The metamodel is a model of the language
(e.g. Seidewitz 2003; Favre 2004).
(This is also seen in statements such as ‘lan-
guage is the set of all ‘sentences’ [models] that
are conformant to the metamodel [e.g. Aßmann,
Zschaler, & Wagner, 2006, p. 261; Favre &
Nguyen, 2005].)
Figure 46. Example from the literature showing
an arguably ontologically correct model (after
Guizzardi & Wagner, 2005) (with kind permission
of Springer Science+Business Media)
Figure 47. Set representations of the classes shown
in Figure 46
Figure 48. Revision of Figure 46 using the tem-
plate of Figure 43
121
Ptolemaic Metamodelling?
From a modelling language viewpoint, it
therefore seems apposite to investigate the utility
of incorporating ideas from the language use, phi-
losophy of language and linguistics communities.
In the late nineteenth century, Frege (1892a)
pondered over the assertion that the meaning of a
sentence derives solely from the words that con-
stitute the sentence. His example, much quoted,
is “The morning star [Venus] is identical to the
evening star [Venus]”23. He was the first to make
the distinction between ‘concept’ and ‘object’
(Frege, 1892b) wherein the grammatical subject
of a sentence signifies an object i.e. an individual
or a particular24 and the predicate signifies a
concept (although this latter was not accepted by
Husserl). This leads to the conclusion that gram-
matical subject refers to something in reality,
either a singular entity (a particular) or to a more
abstract and collective notion (a universal): the
referent. The predicate is often said to be ‘assign-
ing a property’ (e.g. Searle, 1969, p101) rather
than signifying a concept because, according to
Searle (i) Frege uses the term ‘concept’ in two
incompatible ways, leading to the much quoted
“The concept horse is not a concept” (see e.g.
discussion in MacBride, 2011) that is an inevitable
conclusion of Frege; and (ii) the normal usage of
the word concept is more like a universal in the
sense of being collective in nature than a single
property the “idea of the attributes common to a
class of thing” (OED, 1942). Similarly, a general-
ized, broadbrush definition (Margolis & Laurence,
2012) is that “Concepts are the constituents of
thought” which may be identified with (a) mental
representations (dating back to Locke, 1690 and
Hume, 1739), (b) abilities (Wittgenstein, 1953) or
(c) Fregean senses (e.g. Peacocke, 1992). Of these,
it would appear that the first has had the greatest
influence on the field of conceptual modelling
and on ontology engineering. Indeed, in ontology
engineering, Ogden’s triangle (Ogden & Richards,
1923; Ullmann, 1972) is often utilized – although
this is not without its critics in some philosophy
researchers. Indeed, this confusion leads Searle
(1969) to recommend that we abandon the whole
idea of ‘concept’. In a similar vein, Smith (2004)
notes the ambiguities in the literature regarding
the term ‘concept’, in particular describing its
interpretation and use in linguistics, engineering
and ontology. His most important conclusion is
that universals and particulars that exist in reality
should be our focus, particularly in developing
domain ontologies, not the mental constructs that
are typically used in such situations.
This suggests that particulars and universals
(both substantial and non-substantial universals),
derived from language use analysis, therefore
relate to reality whilst objects and classes to
software models (Figure 49). As shown in this
figure, may then choose to formalize these in set
theory terms using members (to depict objects that
represent particulars in reality) and sets (to depict
universals). Furthermore, it is generally accepted
that there are three kinds of universals: type (a.k.a.
kind), property, and relationship.
Notwithstanding Searle’s recommendation
above, it is also worth noting that Frege went on
to suggest that the meaning of a concept (or of a
sign) has two components: sense and reference,
where reference links the concept to reality and
Figure 49. A depiction of elements in the software
domain and how they represent elements of reality
and how we might represent them mathematically
122
Ptolemaic Metamodelling?
sense provides cognitive significance or meaning
to this reference by relating it to other concepts in
that specific context (Figure 50). Husserl (1900,
1901, 1939), working independently of Frege
but his contemporary, concerned himself with
the differences between meaning and object,
identifying those names that express a meaning
and refer to the same object (as with the Venus
example), proper names with no meaning but
designate an individual (e.g. ‘Brian’) and those
‘universal’ names that refer to a variety of objects
these denote a ‘concept’ and, since they are said
to refer to a number of similar objects that form
the extension (Wikipedia, 2012), this suggests to
software modellers the use of set theory in which
universals become classes (or sometimes types)
and particulars are objects in the object-oriented
design and implementation (see e.g. Martin &
Odell, 1995). The blurring of mental representa-
tions, software representations (classes/types and
objects) and the real-life referents (that are often
ignored in software models makes undertaking a
detailed and formal description of modelling and
metamodelling in software engineering a serious
challenge.
Much later, a classic discussion of the use
of language, said to replace the term ‘meaning’,
is found in Austin (1962) in which an utterance
(verbal for the moment) plus its immediate con-
text formulate this speech act. Typically, this is a
rhetic act (Austin, 1962, p. 93). Indeed, speaking
a language is performing an act (viz. a speech act)
according to a set of rules (Searle, 1969, p. 37,38).
Speech acts become the central tenet in Searle
(1969) who combined three accepted elements
(which are that the utterance of sentence (a) indi-
cates that an act is performed, (b) is an indication
of what the speaker means, and (c) addresses an
audience who are within communication range) to
consolidate the illocutionary acts of Austin. Figure
51 is an initial attempt to model these ideas using
a UML-like modelling language. A speech-act
(an utterance) is composed by a propositional act
and an illocutionary act (Searle, 1969, p. 24). As
noted above, the propositional act can be further
divided into a reference and a predicate act. A
speech act is governed by a number of pragmatic
use rules (page 40) that the speaker must comply
to in order to succeed with his speech act. These
are rules (general functions) for (1) referencing, (2)
predication, and (3) the illocutionary component
of the speech act. The illocutionary function (3) is
further divided into five different subtypes (p. 31).
Figure 50. Venus’s meaning map (after Partridge,
1996). Searle (1969, p. 171) comments that since
morning star and evening star are not strictly
proper names, Frege was possibly marginally
misled by this example
Figure 51. Partial OO model of the main elements
proposed by Austin and Searle that constitute
speech acts
123
Ptolemaic Metamodelling?
In Searle (1969) he makes an analysis that shows
the important difference between the reference
and predication functions of language. He quotes
Frege (1884, p. 73) as stating that “only in the
context of a sentences do words have reference”
and discusses at length the many roles of predica-
tion in language. He also concludes (Searle, 1969,
p. 122) that “the tendency to construe predication
as a kind of, or analogous to, reference is one
of the most persistent mistakes in the history of
Western philosophy.”
However, speech act theory is not without
its critics: in addition to critics cited by Searle
himself – and refuted – Dörge (2004) argues that
the term is poorly defined and ambiguous such
that authors often use their own idiosyncratic
meaning of the term.
Austin’s (1962) study of the way words are used
is enhanced by Pennebaker, Mehl, and Niederhof-
fer (2003) study of how this usage is individualistic
to the speaker. That suggests that, in our modelling
language context where words (especially nouns)
are replaced by visualized concepts, class names
and hence structural aspects of class diagrams,
for instance, may also be highly idiosyncratic.
It therefore seems vital to ensure that, in any
standardized modelling language, each symbol
is clearly and tightly defined in terms of either
a social/institutional entity or a physical thing.
Guizzardi (2005) stresses the need for an
‘ontological commitment’, citing Quine (1969)
and Guarino (1998); although Searle (1969,
chapter 5.3) has demonstrated that the notion
of an ontological commitment as proposed and
discussed by Quine (1953, 1960), for example,
is untenable. His notion of ‘commitment’, with
which he concludes his book, is either to a set of
brute facts (i.e. scientific and real-world concrete
entities) or to a social construct (see also Searle,
1995) such that this commitment is bound tightly
into the meaning of the speech acts themselves.
Eriksson, Henderson-Sellers, and Ågerfalk
(2013) undertake an extensive analysis of con-
ceptual modelling based on language use and
speech act theory and conclude that these two
approaches can be reconciled by realizing that
one definition describes ‘language definition’ (fol-
lowing authors such as Kühne, 2006) whereas the
alternative definition is based on a Chomsky view
of language (Chomsky, 1956, 1959) focussing
instead on language use – as utilized in software
engineering by Favre (2004). As indicated above,
a more elaborate view of language use is that
represented by speech act theory (Austin, 1962;
Searle, 1969; Habermas, 1979) where language
use is conceived of as the performance of speech
acts, thus emphasising the pragmatic meaning of
sentences in use. This is depicted graphically in
Figure 52 focussing on language use in terms of ‘a
set of speech acts’ and in more detail in Figure 53
in which we also see in the language use section the
‘ontology rectangleas introduced above in Figure
30, suggesting that when we use language we use
both types and instances (in the modelling sense
discussed in Section 2). Indeed, when we expand
the natural language use concepts and link them to
definitions versus examples, as shown in Figure
54, we can superpose on this natural language
metamodel/model framework the observation
Figure 52. Reconciliation of the two apparently
disparate definitions of a modelling language
124
Ptolemaic Metamodelling?
that language use suggests that at the ‘M1’ level
of example nouns (for instance), common nouns
(person, city, animal, etc.) denote classes whilst
proper nouns (Brian, Cesar, London, Sydney,
Rover, etc.) denote instances (see also Searle,
1969, p. 171; Lakoff, 1987, p. xiii). In natural
language use, we often use both type names and
instance names in the same sentence, primarily
the former (Lakoff, 1987, p xiii). Similarly, Smith
(2004) describes, from a philosophical standpoint,
the differences between ‘particulars’ (individuals,
tokens – here proper nouns) and ‘non-particulars’
(kinds, types – here common nouns) a.k.a. univer-
sals, where a universal is defined (Smith, 2004)
as ‘anything that is instantiated’ i.e. something
that has instances that fall under it. Brute facts
relate to things that exist in the real world (facts
in the world) whereas the existence of universals
depends upon the meaning of words (Searle, 1969,
p. 105, 116, 184). Thus, finally, we can translate
Figure 54 into terminology useful for modelling
languages as opposed to natural languages, with
Class replacing Noun and Relationship replacing
Verb (Figure 55).
If we now focus on natural language syntax
as being a set of rules plus a set of symbols used
to reify them, then valid utterances conform to
these rules and are depicted using a set of sym-
Figure 53. Complete multilevel framework based
on language use to replace the strict metamodel-
ling architecture of Figure 3 when modelling in
information systems development and software
engineering (after Henderson-Sellers, 2012) (with
kind permission of Springer Science+Business
Media)
Figure 54. Depicting natural language con-
stituents as a ‘M2’ level metamodel together with
natural language as used by individual persons
(‘M1’ level example nouns and verbs forming
valid sentences). Further details of the complete
performed speech acts are in Figure 51.
Figure 55. Translation of Figure 54 into the mod-
elling language domain
125
Ptolemaic Metamodelling?
bols. The rules, in turn, are defined in terms of
a context-free grammar (Figure 56). We now
translate this from a natural language context into
a (software) modelling language context (Figure
57) – where these two diagrams could be called
‘megamodels’ as proposed25 by Bézivin, Joualt,
and Valduriez (2004).
If we now incorporate Figure 57 as the model-
ling language definition in Figure 53 and combine
it with a ‘use’ of language, then we have a defini-
tion of Modelling Language as shown in Figure
58. Acknowledging language use implies that we
have to consider also the pragmatic functions of
language when defining a modelling grammar.
Restricting the analysis of language to syntax
and semantics alone without considering prag-
matic language use functions leaves unresolved
the question as to whether a dictionary defini-
tion of a concept is a definition of the class or of
objects belonging to that class or indeed perhaps
merely a description of same. It is reasonable
to argue, based on the analysis presented here,
that the answer may be ‘both, but don’t bother
about the bread’ (Milne, 1926). If that assump-
tion is valid, then one should deduce that such a
dictionary definition could be interpreted as that
of a clabject. Language use theory, on the other
hand, vehemently denies the existence of clabjects.
For example, Searle (1969) views speech acts in
terms of reference and predication such that ref-
erence maps to individuals26 (in his principle of
identification, page 85) and predication typically
involves categorization i.e. the use of universals,
which are used to assign properties (Figure 49) to
the individual concerned (assuming that properties
are part of the prevalent philosophy, e.g. Partridge,
1996). As can be seen in Figures 30 and 49, uni-
versals in speech act/language theory as well as in
ontology can be represented by types and classes
(‘concepts’) in UML-style modelling (see also
Figure 56. Natural language definition
Figure 57. Translation of the concepts in Figure
56 from their natural language domain into the
domain of modelling languages
Figure 58. A megamodel of modelling language
showing not only that it is a combination of defi-
nitional elements (syntax and semantics) but also
of its use. In addition a proposed linkage between
the rules component of the ML to a metamodel or
grammar is made explicit
126
Ptolemaic Metamodelling?
Selic, 2011). Since reference and predication are
orthogonal, such that a predicate cannot refer to an
identifiable individual as does the subject of the
speech act (although it may denote a relationship
(Figure 49) that involves an identifiable particu-
lar), we can conclude that language use is either
to an individual or a category/class/concept but
not both simultaneously (see also Searle, 1969,
p. 100). The functions of reference and predica-
tion convey completely different meanings when
they are used together in a speech act. Thus, the
modelling notion of a clabject (Atkinson, 1999)
is contrary to current understanding of language
use and hence is evidently a Ptolemaic fix, see
further discussion below.
Finally, it is important to note that one of the
missing elements in almost all OMG/UML style
modelling is the omission of the real world i.e.
the referent to which our software objects refer. In
Figure 53 the object Rover (either as a software
representation or a language symbol) has a cor-
respondence relationship to the referent of Rover,
the flesh and blood dog. We should also note that
there is philosophical debate regarding whether
types (universals) such as Dog and Breed also have
referents in the real world. Despite these being
conceptual and not substantial, we will take the
view, implicit in software modelling, that both
instances and types in software have (real-world)
referents – while noting that other philosophies
and ontological commitments are possible and
used in other circles.
3.5. Utilizing Both Language Use
and Foundational Ontologies
for Multilevel Modelling
Following the introduction of foundational on-
tologies (Sections 3.2 and 3.3) and language use
and speech acts (Section 3.4), we can now turn
once again to the so-called ‘linguistic/ontological
metamodelling paradox’. From Figure 14, we can
extract the ontological layers (Figure 59). Note
that, although this diagram is visually identical
in form to that of Figure 18, the semantics of
the concepts depicted in the three class ‘boxes’
is very different. In the earlier diagram, the left
hand instance of purported to link an M1 level
class with an M2 level class. Thus, arguably,
the former instanceOf is a linguistic instanceOf
whereas in Figure 32 the Collie-Breed relation-
ship is an ontological instanceOf since both Rover
and Collie belong to the M1 layer (see Figure 14
and associated discussion). Furthermore, in this
example, all three classes belong to the M1 level.
Secondly, in Figure 18 Rover was (correctly) in-
stantiated from a base type whereas here in Figure
32 it is incorrectly instantiated from a moment
universal (see also Eriksson, Henderson-Sellers,
& Ågerfalk, 2013).
We have noted earlier (Figure 10) that an initial
fix was to ‘invent’ a mapping between Collie as an
object and Collie as a class (Figure 60). However,
there is in fact a more important observation:
there is no base class in this diagram. We have
discovered that Collie relates to an instance of
Figure 60. Recognition of collie as a clabject that
needs replacing by an object to class mapping
Figure 59. A typical example found in the litera-
ture to explain ontological metamodelling (cf.
Figure 14)
127
Ptolemaic Metamodelling?
a Moment Universal named Breed. If Rover is
to be an instance of Collie it would appear to be
able to access collieness characteristics27 but not
those defining characteristics of what it means to
be a dog. For example, a dictionary definition of
the concept “Collie” is “any of a breed of large,
long-haired dog with a long, narrow head: first
bred in Scotland for herding sheep” (Webster’s,
2010). However, we must also know implicitly or
explicitly the meaning of “dog”, for example by
agreeing on a definition such as “any of a large
and varied group of domesticated canines (Ca-
nis familiaris) often kept as a house pet or used
for hunting, guarding people or property, etc.”
(Webster’s, 2010) With this recognition of the
missing Dog class, we can improve on Figure 60
as shown in Figure 61. In other words, with this
restricted approach, we view Rover as an instance
of Collie, itself a subtype of Dog. Although this
redrawn diagram (Figure 61) introduces the base
class Dog it violates the restrictions derived from
speech-act theory that Collie must be an instance
of Breed, and that Rover must be an instance of
Dog . In Section 3.4, we showed, in Figure 53,
how Breed and Dog together with instances of
Collie and Rover form an ontologically sound
model, also acceptable within the constraints of
language use.
We can now compare this solution (Figure 53)
that utilizes ideas from foundational ontologies and
speech act theory with one based on powertypes,
as advocated by, for instance, Gonzalez-Perez and
Henderson-Sellers (2006, 2008). In Figure 62 we
see the base type of Dog associated to the Breed
class, which essentially provides the partitioning
rule for the Dog class. In this example, we just
show three subclasses of the Dog class in both set
and OO notations. This suggests that any subtype
of Dog, e.g. Collie, is not only a class/type but
also an instance (of Breed); in other words, it is
a clabject with a class facet and an object facet
(right hand side of Figure 63).
Figure 61. Further recognition of the lack of a
base class. Here the class dog is inserted into
Figure 60 to rectify this omission.
Figure 62. Traditional powertype representation of
the same problem domain as in Figures 61 and 51
Figure 63. Collie as a clabject representation
compared to the ontological “square” of Figures
31 and 51
128
Ptolemaic Metamodelling?
Although at first sight the language use pattern
to the left and the powertype pattern (software
pattern) to the right in Figure 63 may appear to
convey the same meaning, closer inspection reveals
that they are indeed fundamentally different. This
is illustrated in Figures 64 and 65.
Figure 64 depicts the powertype pattern in
which Collie appears to be a subclass of the su-
perclass Dog, and the object Rover is an instance
of the subclass Collie with three own attributes:
dog name = Rover, dog height = 50, dog colour
= black, which can access three breed level attri-
butes: breed name = collie, breed height=45–55,
breed colour=(black, tri-coloured, sable) via the
association to Collie (thus equating attributes and
associations as is commonly done in OO model-
ling). All these attributes are used to represent
the physical dog and the properties it inheres (cf.
Figure 49).
The meaning of Figure 65 that depicts a
language-use pattern is described below, focusing
on the relationships a, b, c and d:
a. Depicts a type-instance relationship between
Rover as an object (instance) and its type
Dog. Rover, the dog name, is an identifier
and Dog is the class type name. We use the
notion of class to represent the sortal i.e. both
the intension and extension of the class. From
a language-use perspective, the Dog class
can be used to communicate about dogs (at
both type and instance level, i.e. the intension
and extension of the class Dog) using speech
acts. For example, the speech act “Rover is a
dog” is used to instantiate the Rover object
in the Dog class if no such object exists, and
to refer to a dog named Rover if such a dog
has already been instantiated by a previous
speech act.
b. Depicts the predicate relationship between
the identifier and the attributes. The identi-
fier (dog name) is used to uniquely refer to
the object, and the attributes: dog height,
dog colour and breed are used to ascribe
attribute values to dog objects. In the speech
act “Rover is a Collie,” Collie is used as an
attribute value that is assigned to Rover, not
as a class name (Dog is the class type name)
that instantiates Rover. This is in line with
how the notion of predication is described in
speech act theory. There is no type-instance
relationship between the language constructs
Figure 64. The meaning of the powertype pattern
in Figure 63
Figure 65. The meaning of the language use pat-
tern in Figure 63
129
Ptolemaic Metamodelling?
Collie and Rover because Collie is simply
used as an attribute value in this speech act, in
the same way that 50 is used as a dog height
attribute value, and “black” is used as a dog
colour attribute value. Rover cannot access (it
is not the possible software implementation
of Rover that is of interest at this stage) and
does not inherit the three Collie attributes:
breed name = collie, breed height=45-55,
breed colour=(black, tri-coloured, sable).
c. Depicts the type-instance relationship be-
tween Collie as an object and its type Dog
Breed. The speech act “Collie is a dog breed”
is used to instantiate Collie in the Dog Breed
class if no such object exists, and to refer to
a dog breed named Collie if such a breed
has already been instantiated by a previous
speech act. Here Collie is used to represent
the meaning of Collie(ness) and need not
have anything to do with the object Rover,
or any other particular dog object. Thus we
can talk about the collieness of dogs without
ascribing it as an attribute to any particular
dog object. The word Collie is hence used
with a completely different meaning com-
pared to (b).
d. Depicts a partition relationship between
Collie and Dog. Collie is used to partition
Dog objects which are identified and instan-
tiated with the Dog class. Collie provides a
rule for the partitioning of dog objects, which
means that Collie essentially is a partition
of Dog objects. and the definition of Collie
see below provides a partitioning rule for a
number of dog objects (c.f. Figure 21).
The analysis above shows that the powertype
software pattern is a Ptolemaic fix, because it is
based on the idea of clabject (which we already
have showed in Section 3.4 to be a Ptolemaic fix).
For example, the definition of the concept “Col-
lie” as “any of a breed of large, long-haired dog
with a long, narrow head: first bred in Scotland
for herding sheep” leaves unresolved the question
as to whether Collie is used as a type, an object, a
predicate, or a partition. This is homonymous until
we specify the rules for how it could be used in
the particular language system under scrutiny. To
maintain that Collie is a clabject, which suggests
that it could be used both as an object and a type
in the same language system does not explain the
meaning of “Collie”. On the contrary, it further
obscures the meaning of “Collie” because, ac-
cording to speech act theory, Collie is used as a
predicate in relationship to already instantiated
dog objects (relationship b), and as a predicate it
cannot be used to instantiate dog objects (relation-
ship a). Predication (relationship b) is orthogonal
to instantiation (relationship a). Neither does
predication (relationship b) mean referring to a
collie object via an association to Collie, which
would equate attributes and associations as is com-
monly undertaken in OO modelling. If this were
the case, then Rover must also be considered an
instance of the attribute values “dog height 50” and
“dog colour black”. Searle (1969, pp. 113–118)
argues strongly and convincingly against such
an understanding of predication – we cannot, for
example, use the attribute red to refer to redness,
in the speech act “the rose is red”; red is merely an
attribute predicated to a rose, and not a reference
to the universal redness, considering the universal
an object. We believe that much of the confusion
surrounding these issues is due to a mix-up in the
understanding of “is a” as signifying inheritance/
subclassification (e.g. Dog is a Mammal), instan-
tiation (Rover is a Dog) and predication (Rover
is a Collie) – essentially confusing the latter with
one or both of the former.
The language use analysis also shows that re-
stricting modelling to syntax and semantics alone
without considering the pragmatic language use
functions of reference and predication leaves the
meaning of concept definitions unresolved. In a
modelling situation, it is important to clarify the
meaning of basic concepts such as “Collie” and,
if we do not clarify how the word Collie can be
used - as a type, an object, a predicate or a partition
130
Ptolemaic Metamodelling?
- “Collie” becomes a misused homonym as in the
models shown in Figures 59, 60, 61, 63, and 64.
Thus, we suggest that powertypes is a ‘Ptol-
emaic fix’ according to speech act theory and
that the incorporation of ontological thinking
together with language use insights should give
an improved quality solution. However, whilst
being theoretically invalid, the powertype fix does
provide a solution within the constraints imposed
by the multilevel architectures currently in use (e.g.
Figures 3 and 24). Consequently, powertypes can
be regarded as a temporary solution until all the
ramifications of our proposals of Section 4 for a
paradigm shift are universally adopted. If the revo-
lution proves to be successful, and we do not see
any logical-theoretical reasons that it should not
(albeit perhaps political ones), then this would no
longer have to be the case. Modellers would then
be trained to see that the Earth is indeed circling
the Sun, and the “geocentric view of metamod-
elling” (Ptolemaic metamodelling, as we call it)
will eventually only be mentioned in passing as
a historical anecdote. It is always easier to learn
the right thing from the beginning than having to
unlearn. As John Maynard Keynes is known to
have said, “The difficulty lies, not in new ideas,
but in escaping from the old ones, which ramify,
for those brought up as most of have been, into
the corners of our minds.”
3.6. Other Related Research
Although we have endeavoured to include all
relevant research work so far in this section (3.1-
3.5), there are other contributions that might be
considered to be in the same sphere of interest.
A large number of authors criticize UML or
MOF. We do not aim to collect them all here
as they span a large compass in both scale and
temporality. One with an obvious title is “Errors
in the UML Metamodel?” by Fuentes, Quintana,
Llorens, Génova, and Prieto-Diaz (2003). These
authors identified 450 errors in the UML V1.5
metamodel (OMG, 2003); although they do not
challenge the basic structure or architecture of
a metamodel-based language like UML, rather
likening the UML standard to a ‘bible’.
Song and Baik (2003) recognize that nowhere
in the OMG’s documents nor spin-off books is
the question addressed “Which UML diagrams
should be used in each of the SDLC phases?”
These authors propose three phases, which they
call conceptual, specific, and concrete. For each
phases they consider use cases, class models, state
charts and activity models and argue that each
combination requires an individual metamodel
that are later integrated.
The topic of the paucity of behavioural support
in UML is widely discussed. One such example
is the discussion by Gargantini, Riccobene, and
Scandurra (2009) who propose a semantic frame-
work, in an MDE context, that uses translational
mappings together with weaving and a technique
called semantic hooking. This approach is com-
patible with a basic assumption that the abstract
syntax of a modelling language is defined in terms
of a metamodel (see also discussion in Henderson-
Sellers, 2012). Modelling and metamodelling in an
MDE environment is a topical and an interesting
research area exemplified by papers such as those
of Kühne (2007) and Kleppe (2007). Another
emerging area, often linked to MDE, is that of
domain-specific languages and, especially in
our context here, of Domain Specific Modelling
Languages (DSMLs) (e.g. Selic, 2011). These al-
low users to work directly with a set of concepts
closely related to their domain-specific knowledge
(e.g. Kühne, 2007; Gargantini, Riccobene, &
Scandurra, 2009), often expressed as a domain
ontology (Falbo, Guizzardi, & Duarte, 2002;
Kurtev, Bézivin, Joualt, & Valduriez, 2006).
Most recently, Shan and Zhu (2012) ask ‘What
is the exact meaning of the instanceOf relationship
between an Mx model and an M(x+1) model (in
the context of Figure 3). They propose four equally
acceptable alternative understandings from the
UML specification documents for the case of a
simple class diagram with a single class labelled A:
131
Ptolemaic Metamodelling?
There is only one class in the system and it
is named A.
There is at least one class named A in the
system (which may have other classes).
There is only one class in the system and
its name does not matter.
There is at least one class in the system and
its name does not matter.
These authors seek a uniform semantics for
models in all pairs of metalevels. They under-
take this research by mapping UML models to
predicate calculus.
4. REVOLUTION: MAKE LANGUAGE
USE NOT MODELS THE FOCUS
The history of the evolution of modelling lan-
guages and conceptual modelling more generally
has, over the last decades, depended significantly
on the multilevel architecture of Figure 3. This mul-
tilevel stack is of ‘models’ viz. model, metamodel,
metametamodel etc. ad infinitum (but closed
off in the OMG version with a topmost level of
metametamodel). This architecture, as we (and
others) have shown, leads to many significant
problems. Since many authors recognize the prob-
lems inherent in the four-level architecture of the
OMG (Figure 3), there have been attempts made
to circumvent these by investigating alternative
m-level architecture (m>=1). As a smooth evo-
lution from earlier ideas by Colin Atkinson and
Thomas Kühne (e.g. Atkinson & Kühne, 2000a,
and see earlier discussion), the Pan Level Model
(PLM) and Level-agnostic Modelling Language
(LML) have emerged (Atkinson, Kennel, & Goß,
2011). We propose here that it is time for a revolu-
tion to replace the evolution with a new Kuhnian
paradigm. Our discussion is intended to provide a
stimulus for the modelling community to develop
a new mindset – whether or not our proposals here
become the core of such a revolution remains to
be seen. We encourage community debate once
the realization of the need for a paradigm shift
has been accepted (as we hope it has after reading
our treatise here).
In practical terms, adoption of a language-
focussed paradigm for modelling means that
individual developers no longer need understand
non-standard ‘Ptolemaic fixes’ such as potency
or powertypes, which not only add complexity to
the modelling environment but also run the risk of
being interpreted differently by different people.
With this newly proposed emphasis on model-
ling languages rather than multi-level modelling
hierarchies, the tacit knowledge of each developer,
as a natural language speaker, matches smoothly
with the underlying theories of language use and
speech acts, thus turning the conceptual model-
ling environment from an artificial one to a more
natural one. In addition, correct utilization of the
various ontological types (for instance, whether
role types can or cannot be linked directly to base
types) will not only avoid incorrect models but
will also permit tool vendors to enforce these
additional foundational ontological classes in a
seamless manner thus supporting the developer
in creating useful and high quality models– much
as object technology itself removed from the
software developer the need to concentrate hard
on how to insist on information hiding and cor-
rectly bundle together state and behaviour: the
new default (in OO).
We saw in Figure 53 a first indication of how
a restructured multi-level architecture might be
envisaged. Rather than have the ‘M2’ level being
the metamodel, instead it is the ‘Language Defini-
tion’ with ‘M1’ being the type part of language
use and ‘M0’ being the instance part of language
use. A straight incorporation of these observa-
tions into Figure 3 suggests that the replacement
architecture looks like that in Figure 66. However,
Figure 66 cannot be the whole story since, as we
see in Figure 53, we also need to incorporate real
world entities. These are not M0 since M0 are the
modelled instances that correspond to things in
the real world. Indeed, the correspondences seen
132
Ptolemaic Metamodelling?
in this diagram are what Searle (1969, p. 82) calls
‘fully consummated references’. Secondly, as seen
in Figure 53, both types and instances are part of
our everyday use of language i.e. any modelling
distinction between types and instances could be
regarded as both artificial and unnecessary in
the sense that as we speak and write (language
use) we do NOT continually assess whether the
morphemes denote instances or types (i.e. refer-
ences or predication). We do not differentiate
between types and instances in natural language
usage suggesting that this combination could
constitute what we have previously called the’M1’
level (Figure 67). In this diagram is also shown the
representation of Dog and Breed as tables suitable
for a database (for full discussion see Eriksson,
Henderson-Sellers, & Ågerfalk, 2013).
With these changes, Figure 66 is revised as
shown in Figure 68, noting in addition that the
“M2 metamodel” of Figure 66 is equivalent to an
“ontological commitment” that is formalized in
terms of a foundational ontology. However, even
Figure 68 still has a basic influence (and indeed
aim) of creating an OMG-like architecture. We
have seen that an alternative architecture is the
multi-level model of Figure 24. In this alternative
structure, the real world was called the Endeavour
Domain, theM1/M0 model level of Figure 68
becomes the Method Domain but the Metamodel
Domain of Figure 24 needs to be replaced by the
Definitional Domain (which includes the model-
ling language definition and also the metamodel
of the ‘M2’ level and the metametamodel ‘M3’
level of Figure 68). Remodelling Figure 68 along
these lines leads to our final suggestion of Figure
69. In this diagram, we suggest including both
design models (including process models or meth-
odologies) and enactment models (previously M0
models) in a single “Model” domain (or layer).
The lowest layer is then distinct from models and
Figure 66. First revision of the OMG multi-level
architecture of Figure 3 to place the modelling
language and not the metamodel at the ‘M2’ level
in the multilevel stack (now restricted to three levels
with a linkage to a second multilevel stack – here
shown as having only two levels)
Figure 67. Type and instance level as the new ‘M1’ level. The key at the base is not only a key but an
implicit metamodel to which all elements in the new ‘M1’ level must conform.
133
Ptolemaic Metamodelling?
only refers to real world entities, method following
actions etc,. This approach aligns with Ågerfalk
and Fitzgerald’s (2006) notion of methods as ac-
tion knowledge and also provides an architecture
compatible with reduced-level approaches. Note
that “real world entities” include systems specifica-
tions (models) that are produced and used during
systems development as part of communication/
design activities concerned with the system to be
constructed. They are what Eriksson and Ågerfalk
(2010) refer to as institutional objects. It is not
their status of their being models that is in focus
at this level. Instead, they are included by virtue
of being used in method-following speech acts
– such as in coming to an agreement on system
requirements. For example, if the subject of study
(SUS) in the systems developing project is a Ken-
nel club, the model depicted in Figure 67 could
be a part of such an agreement. The enactment
model describes the design activities. Hence, a
specific design activity such as “Brian’s design
activity” (cf. Section 3.1 above) is part of the
model layer in Figure 69. It is also important to
recognize that the enactment model can be both
prescriptive and descriptive in relation to real world
modelling activities gerfalk & Fitzgerald, 2006).
For example, if Brian gets a managerial signoff
for a 2 day duration on his design activity, it is a
commitment (institutional object) that should be
complied with. Similarly, the method prescription
that such a signoff should be agreed is a directive
represented in the Enactment model that may or
may not result in the institutional object. Post
facto analysis of the situation may result in de-
Figure 68. Revision of Figure 66 to incorporate the ideas depicted in Figure 53
Figure 69. Revision of Figure 68 to incorporate the ideas of Figure 24
134
Ptolemaic Metamodelling?
scriptive models that can be compared with such
prescriptions to assess conformance. This means
that the deep instantiation plus potency approach,
which was suggested in order to permit multilevel
modelling of processes and methodologies, can
be avoided.
As an example to aid understanding, we com-
pare this new language-use-based architecture as
applied to the standardization for methodologies
with the current status as exemplified in Figure 22
earlier. Figure 70 compares the essence of Figure
22 with its equivalent in the new architecture (of
Figure 69). In Figure 22, the multilevel constraints
of Figure 3 or Figure 24 dictate that Activity and
ActivityKind MUST belong to the metamodel
level (OMG’s M2 level). With the new architecture,
the metamodel layer is replaced by a definitional
layer in which a metamodel does play a part but
more along the lines of the ontologically enhanced
structure of Figure 27, e.g. it contains, Sortals and
Moment Universals inter alia (cf. also Figure 30).
As shown in Figure 67, both types and instances
can co-exist in the M1 layer and, importantly, the
M0 layer now relates only to reality (as shown in
Figures 53 and 69). This means that (1) standard-
izing a general purpose modelling language, such
as the UML, still occurs at the definitional layer
but that (2) a DSML (Domain Specific Modelling
Language), much as the name suggests, as well as
a methodology (meta)model like ISO/IEC 24744
(ISO/IEC 2007) are now defined at the type level
within the model layer. Finally, a standard like
ISO/IEC 12207 (ISO/IEC, 1995) is identified with
the instance level of M1 as shown in Figure 67.
Figure 71 stresses that, in fact, models occur in
all three ‘domains’ of Figure 24 and of Figure 69.
All three kinds of model use a modelling language
(often the same language, e.g. Shan & Zhu, 2012),
which, in turn, has a specification or definition
(also a model). That definition is frequently made
by means of a metamodel (depicted as a class
diagram) but could be by a textual grammar or
some other formal means. Figure 71 also stresses
the need to replace the ‘metamodel’ as a key focus
in modelling language design (as currently in the
UML documents) by ‘modelling language’ (as
shown in Figure 69 for instance in terms of its
definition, which is the main connection between
the definitional domain and the model domain).
Figure 70. An architectural multi-level view of Figure 67 compared to the current multi-level architecture
exemplified by Figure 22
135
Ptolemaic Metamodelling?
5. CONCLUSION: FUTURE NEEDS
Science progresses partly by small additions to
knowledge and partly due to paradigm shifts
(Kuhn, 1962). Often the seeds for the revolution
are sown earlier, scattered throughout the literature
and may, or may not, be recognized as harbingers
of an impending paradigm shift. We saw how the
early ideas leading to both the Copernican revolu-
tion in astronomy and the Darwinian exposition of
natural selection were present in earlier writings
of other researchers prior to the paradigm shift
occurring and the establishment, sometimes after
many decades, of the new orthodoxy.
In this chapter, we have considered parallels
from scientific revolutions as a basis for evaluat-
ing whether or not the time is ripe for a similar
change of direction in metamodelling for software
engineering, especially in the context of MDE (or
in its new guise of MBE: model-based engineering
(Selic 2012b)). We have introduced a number of
ideas that seem to solve many of the inconsistencies
and paradoxes of the current orthodoxy. Although
what we have presented in this chapter may at first
sight appear to be complex, it is in fact far less
complex than suggested alternatives, such as the
OMG multi-level architecture. Metamodelling
is indeed a complex task that requires somewhat
intricate tools, although we also recall and super-
pose the so-called Einstein’s Razor (Borkar, 1998,
p. 42): “Everything should be made as simple as
possible, but not simpler.
Essentially what we suggest is a change in
mindset similar to the “pragmatic turn” in phi-
losophy (Egginton & Sandbothe, 2004; Bernstein,
2010). Our focus as modellers needs to shift from
models to language, and by extension to how
language is used to achieve pragmatic outcomes
(Ågerfalk, 2010). Eriksson & Ågerfalk (2010)
showed the implications of such a turn for informa-
tion infrastructures and for conceptual modelling
of information systems. In this chapter we have
laid the groundwork for a similar revolution to
the practices of metamodelling.
And being even more pragmatic, we argue that
practitioners and software developers in industry
will find metamodelling, and modelling in general,
a much more affordable domain. In the age of
agile development, where focus is often on code,
a pragmatic and simpler approach like the one
proposed here is most likely to be well received
and adopted by the community.
Whether what we have presented, together, are
sufficient to create a shift in mindset or whether
they are simply the stimulus for others to create new
and orthogonal ideas remains to be seen. We urge
Figure 71. There are three main kinds of model used in software engineering, all of which are depicted
using a modelling language. That language needs to be specified (defined), which can be accomplished
by one of several means e.g. metamodel, grammar.
136
Ptolemaic Metamodelling?
the modelling and metamodelling communities to
search out that new orthodoxy that will, necessar-
ily, ensure that our science will offer simpler and
more satisfying solutions in the years to come.
Our future work is aimed at analysing various
possible philosophical and ontological underpin-
nings for modelling and metamodelling. There are
a number of accepted but contrasting paradigms
discussed in the contemporary philosophical lit-
erature including those dating back to the late 19th
century (e.g. Frege, 1892a,b), those focussed on
speech acts (e.g. Austin, 1962 and Searle, 1969)
and some specifically aimed at supporting object-
oriented analysis and design (Partridge, 1996).
These need to be evaluated for our metamodel-
ling context but also augmented by a revised and
improved version of a foundational ontology like
the UFO that was used earlier in this chapter.
ACKNOWLEDGMENT
B. Henderson-Sellers wishes to acknowledge
the support of the Australian Research Council
through grant DP0878172. This is contribution
12/07 of the Centre for Object Technology Ap-
plications and Research within the Human-Centred
Technology Design Centre at the University of
Technology, Sydney.
We wish to thank Chris Partridge for his
insightful comments on an earlier draft of this
manuscript. We also wish to acknowledge, with
thanks, discussions over the years with, in alpha-
betical order, Colin Atkinson, Tony Clark, Sergio
DeCesare, Giancarlo Guizzardi, Thomas Kühne,
and Graham Low.
REFERENCES
Ågerfalk, P. J. (2010). Getting pragmatic. Eu-
ropean Journal of Information Systems, 19(3),
251–256. doi:10.1057/ejis.2010.22.
Ågerfalk, P. J., & Fitzgerald, B. (2006). Exploring
the concept of method rationale: A conceptual tool
for method tailoring. In Siau, K. (Ed.), Advanced
Topics in Database Research (Vol. 5). Hershey,
PA: Idea Group. doi:10.4018/978-1-59140-935-
9.ch004.
Álvarez, J., Evans, A., & Sammut, P. (2001). Map-
ping between levels in the metamodel architecture.
In M. Gogolla, & C. Kobryn (Eds.), Proc. UML
2001 – The Unified Modeling Language: Model-
ing Languages, Concepts and Tools (LNCS), (vol.
2185, pp. 34-46). Berlin: Springer-Verlag.
Aristotle. in Translation. (1984). Complete works.
(J. Barnes, Ed.). Princeton, NJ: Princeton Uni-
versity Press.
Armstrong, D. M. (1989). Universals: An opinion-
ated introduction. Westview Press.
Asimov, I. (1988). Prelude to foundation. London:
Grafton Books.
Aßmann, U., Zschaler, S., & Wagner, G. (2006).
Ontologies, meta-models, and the model-driven
paradigm. In Calero, C., Ruiz, F., & Piattini,
M. (Eds.), Ontologies for Software Engineer-
ing and Software Technology. Berlin: Springer.
doi:10.1007/3-540-34518-3_9.
Atkinson, C. (1997). Metamodelling for distrib-
uted object environments. In Proceedings of the
First International Enterprise Distributed Object
Computing Workshop (EDOC’97). Brisbane,
Australia: IEEE Computer Society.
Atkinson, C. (1999). Supporting and applying the
UML conceptual framework. In Bézivin, J., &
Muller, P.-A. (Eds.), The Unified Modeling Lan-
guage «UML» 1998: Beyond the Notation (LNCS)
(Vol. 1618, pp. 21–36). Berlin: Springer-Verlag.
doi:10.1007/978-3-540-48480-6_3.
137
Ptolemaic Metamodelling?
Atkinson, C., Gutheil, M., & Kennel, B. (2009).
A flexible infrastructure for multilevel language
engineering. IEEE Transactions on Software
Engineering, 35(6), 742–755. doi:10.1109/
TSE.2009.31.
Atkinson, C., Kennel, B., & Goß, B. (2011). The
level-agnostic modeling language. In Malloy,
B., Staab, S., & van den Brand, M. (Eds.), SLE
2010 (LNCS) (Vol. 6563, pp. 269–275). Berlin:
Springer-Verlag.
Atkinson, C., & Kühne, T. (2000a). Strict profiles:
why and how. In Proceedings Third International
Conference on the Unified Modeling Language,
(LNCS), (vol. 1939, pp. 309-322). Berlin:
Springer-Verlag.
Atkinson, C., & Kühne, T. (2001a). The essence
of multilevel metamodelling. In Gogolla, M., &
Kobryn, C. (Eds.), UML»2001 The Unified Mod-
eling Language. Modeling Languages, Concepts
and Tools, (LNCS) (Vol. 2185, pp. 19–33). Berlin:
Springer-Verlag. doi:10.1007/3-540-45441-1_3.
Atkinson, C., & Kühne, T. (2001b). Processes
and products in a multi-level metamodelling
architecture. International Journal of Software
Engineering and Knowledge Engineering, 11(6),
761–783. doi:10.1142/S0218194001000724.
Atkinson, C., & Kühne, T. (2003). Model-
driven development: a metamodelling founda-
tion. IEEE Software, 20, 36–41. doi:10.1109/
MS.2003.1231149.
Atkinson, C., & Kühne, T. (2005). Concepts for
comparing modeling tool architectures. In Model
Driven Engineering Languages and Systems,
(LNCS) (Vol. 3713, pp. 398–413). Berlin: Springer-
Verlag. doi:10.1007/11557432_30.
Atkinson, C., & Kühne, T. (2008). Reducing ac-
cidental complexity in domain models. Software
& Systems Modeling, 7(3), 345–359. doi:10.1007/
s10270-007-0061-0.
Austin, J. L. (1962). How to do things with words.
Oxford, UK: Oxford University Press.
Baader, F., & Nutt, W. (2002). Basic description
logics. In Baader, F., Calvanese, D., McGuinness,
D. L., Nardi, D., & Patel-Schneider, P. F. (Eds.),
Description Logic Handbook. Cambridge, UK:
Cambridge University Press.
Beddall, B. G. (1968). Wallace, Darwin, and
the theory of natural selection. Journal of the
History of Biology, 1(2), 261–323. doi:10.1007/
BF00351923.
Bernstein, R. J. (2010). The pragmatic turn.
Cambridge, UK: Polity Press.
Bézivin, J. (2004). In search of a basic principle for
model-driven engineering. Upgrade, 5(2), 21–24.
Bézivin, J., Joualt, F., & Valduriez, P. (2004).
On the need for megamodels. In Proceedings of
Workshop on Best Practices for Model-Driven
Software Development at the 19th Annual ACM
Conference on Object-Oriented Programming,
Systems, Languages, and Applications. ACM
Press.
Bhathal, R. (2012). Australia and the transit of
Venus. Astronomy & Geophysics, 53(3), 3.22-3.24.
Bock, C., & Odell, J. J. (1994). A foundation for
composition. Journal of Object-Oriented Pro-
gramming, 7(6), 10–14.
Borkar, V. S. (1998). There’s no such thing as a
free lunch: The bias-variance dilemma. Resonance
-. Journal of Science Education, 3(6), 40–51.
Brachman, R. J. (1985). I lied about the trees’ or,
defaults and definitions in knowledge representa-
tion. AI Magazine, 6(3), 80–93.
Brentano, F. (1874). Psychologie vom empirischen
standpunkt. Leipzig, Germany: Verlag von
Duncker & Humblot.
138
Ptolemaic Metamodelling?
Broy, M. (2011, October). Can practitioners ne-
glect theory and theoreticians neglect practice?
IEEE Software, 19–24.
Bunge, M. (1977). Treatise on basic philosophy:
Vol. 3. Ontology I: The furniture of the world.
Boston: Reidel.
Bunge, M. (1979). Treatise on basic philosophy:
Vol. 4. Ontology II: A world of systems. Boston:
Reidel.
Butterfield, H. (1957). The origins of modern
science, 1300-1800. London: G. Bell.
Cardelli, L. (1988). Structural subtyping and the
notion of power type. In J. Ferrante, & P Mager
(Eds.), Proceedings Fifteenth Annual ACM Sym-
posium on Principles of Programming Languages.
ACM Press.
Carmichael, A. (1994). Towards a common object-
oriented meta-model for object development.
In Carmichael, A. (Ed.), Object Development
Methods (pp. 321–333). New York: SIGS Books.
Carnap, R. (1947). Meaning and necessity: A
study in semantics and modal logic. Chicago, IL:
University of Chicago Press.
Chambers, R. (1844). Vestiges of the natural his-
tory of creation. London, W: R Chambers.
Chomsky, N. (1956). Three models for the de-
scription of language. I.R.E. Transactions on
Information Theory, 2(3), 113–124. doi:10.1109/
TIT.1956.1056813.
Chomsky, N. (1959). On certain formal proper-
ties of grammars. Information and Control, 2(2),
137–171. doi:10.1016/S0019-9958(59)90362-6.
Copernicus, N. (1543). De revolutionibus orbium
coelestium. Nuremburg.
Dahchour, M., & Pirotte, A. (2002). Materialization
and its metaclass implementation. IEEE Transac-
tions on Knowledge and Data Engineering, 14(5),
1078–1094. doi:10.1109/TKDE.2002.1033775.
Darwin, C. (1859). On the origin of species.
London: John Murray.
Darwin, C., & Wallace, A. R. (1858). On the
tendency of species to form varieties, and on the
perpetuation of varieties and species by natural
means of selection. Journal of the Proceedings of
the Linnean Society of London Zoology, 3, 46–50.
doi:10.1111/j.1096-3642.1858.tb02500.x.
Denning, P. J., Dennis, J. B., & Qualitz, J. E.
(1978). Machines, languages, and computation.
Englewood Cliffs, NJ: Prentice-Hall.
Descartes, R. (1637). Discours de la méthode.
Descartes, R. (1644). Principia philosophiae.
Dörge, F. C. (2004). Illocutionary acts: Austin’s
account and what Searle made of it. Inaugural-
Dissertation zur Erlangung des Grades eines Dok-
tors der Philosophie. Eberhard-Karls-Universität
Tübingen.
Egginton, W., & Sandbothe, M. (2004). The prag-
matic turn in philosophy: Contemporary engage-
ments between analytic and continental thought.
State Albany, NY: University of New York Press.
Eriksson, O., & Ågerfalk, P. J. (2010). Rethink-
ing the meaning of identifiers in information
infrastructures. Journal of the Association for
Information Systems, 11(8), 433–454.
Eriksson, O., Henderson-Sellers, B., & Ågerfalk,
P. J. (2013). Ontological and linguistic metamod-
elling revisited – A language use approach.
Unpublished.
Falbo, R., Guizzardi, G., & Duarte, K. C. (2002).
An ontological approach to domain engineering.
In Proceedings of the International Conference on
Software Engineering and Knowledge Engineer-
ing SEKE’02. Ischia, Italy: ACM Press.
139
Ptolemaic Metamodelling?
Favre, J.-M. (2004). Foundations of meta-pyr-
amids: Languages vs. metamodels: Episode II:
Story of Thotus the baboon. In Proceedings of
Dagstuhl Seminar 04101 ‘‘Language Engineer-
ing for Model-Driven Software Development’’.
Dagstuhl.
Favre, J.-M., & NGuyen, T. (2005). Towards a
megamodel to model software evolution through
transformations. Electronic Notes in Theoretical
Computer Science, 127(3), 59–74. doi:10.1016/j.
entcs.2004.08.034.
Firesmith, D., Henderson-Sellers, B., & Graham,
I. (1997). OPEN modeling language (OML) refer-
ence manual. New York: SIGS Books.
Flatscher, R. G. (2002). Metamodeling in EIA/
CDIF – Meta-metamodel and metamodels. ACM
Transactions on Modeling and Computer Simula-
tion, 12(4), 322–342. doi:10.1145/643120.643124.
Frege, G. (1884). Die grundlagen der arithmetik.
Breslau.
Frege, G. (1892a). Über sinn und bedeutung. In
Zeitschrift für Philosophie und philosophische
Kritik, 100, 25-50.
Frege, G. (1892b). Über begriff und gegenstand.
In Vierteljahrsschrift für Wissenschaftliche Phi-
losophie, 16, 192-205.
Frege, G. (1950). The foundations of arithmetic
(Austin, J. L., Trans.). Oxford, UK: Basil Black-
well.
Fuentes, J. M., Quintana, V., Llorens, J., Génova,
G., & Prieto-Diaz, R. (2003). Errors in the UML
metamodel? ACM SIGSOFT Software Engineer-
ing Notes, 28(6), 3. doi:10.1145/966221.966236.
Galilei, G. (1610). Sidereus nuncius.
Galilei, G. (1632). Dialogue concerning the two
chief world systems.
Gargantini, A., Riccobene, E., & Scandurra, P.
(2009). A semantic framework for metamodel-
based languages. Journal of Automated Software,
16(3-4), 415–454. doi:10.1007/s10515-009-
0053-0.
Genova, G. (2010). Is computer science truly
scientific? Communications of the ACM, 53(7),
37–39. doi:10.1145/1785414.1785431.
Gonzalez-Perez, C., & Henderson-Sellers, B.
(2006). A powertype-based metamodelling frame-
work. Software & Systems Modeling, 5(1), 72–90.
doi:10.1007/s10270-005-0099-9.
Gonzalez-Perez, C., & Henderson-Sellers, B.
(2007). Modelling software development meth-
odologies: A conceptual foundation. Journal
of Systems and Software, 80(11), 1778–1796.
doi:10.1016/j.jss.2007.02.048.
Gonzalez-Perez, C., & Henderson-Sellers, B.
(2008). Metamodelling for software engineering.
Chichester, UK: John Wiley & Sons.
Graham, I. M., Bischof, J., & Henderson-Sellers,
B. (1997). Associations considered a bad thing.
Journal of Object-Oriented Programming, 9(9),
41–48.
Guarino, N. (1998). Formal ontology and infor-
mation systems. In N. Guarino (Ed.), Formal
Ontology in Information Systems: Proceedings of
the International Conference on Formal Ontol-
ogy and Information Systems (FOIS). IOS Press.
Guarino, N., & Welty, C. (2000). A formal ontol-
ogy of properties. In R. Dieng & O. Corby (Eds.),
Proceedings 12th International Conference on
Knowledge Engineering and Knowledge Manage-
ment, (LNCS), (vol. 1937, pp. 97-112). Berlin:
Springer-Verlag.
140
Ptolemaic Metamodelling?
Guarino, N., & Welty, C. (2001). Identity and
subsumption: LADSEB-CNR internal report
01/2001. In Green, R., Bean, C. A., & Myaeng,
S. H. (Eds.), The Semantics of Relationships: An
Interdisciplinary Perspective. Dordrecht, The
Netherlands: Kluwer.
Guizzardi, G. (2005). Ontological foundations for
structural conceptual models. CTIT PhD Thesis
Series, No. 05-74, Enschede, The Netherlands.
Guizzardi, G. (2006). Agent roles, qua indi-
viduals and the counting problem. In Garcia,
Choren, Pereira de Lucena, Giorgini, Holvoet,
& Romanovky (Eds.), Software Engineering for
Multi-Agent Systems IV, Research Issues and
Practical Applications (LNCS), (vol. 3914, pp.
143-160). Berlin: Springer-Verlag.
Guizzardi, G., & Wagner, G. (2005). Towards
ontological foundations for agent modelling
concepts using the unified foundational ontology
(UFO). In Bresciani, P., Giorgini, P., Henderson-
Sellers, B., Low, G., & Winikoff, M. (Eds.),
Agent-Oriented Information Systems II (LNAI)
(Vol. 3508, pp. 110–124). Berlin: Springer-Verlag.
doi:10.1007/11426714_8.
Guizzardi, G., Wagner, G., Guarino, N., & van
Sinderen, M. (2004). An ontologically well-
founded profile for UML conceptual models. In
A. Persson & J. Stirna (Eds.), 16th International
Conference on Advances in Information Systems
Engineering (CAiSE’04), (LNCS), (vol. 3084, pp.
122-126). Berlin: Springer-Verlag.
Habermas, J. (1979). What is universal pragmat-
ics? In Habermas, J. (Ed.), Communication and
the Evolution of Society (McCarthy, T., Trans.).
London: Heinemann.
Halpin, T. (2005). Higher order types and informa-
tion modeling. In Siau, K. (Ed.), Advanced Topics
in Database Research. Hershey, PA: Idea Group.
doi:10.4018/978-1-59140-471-2.ch010.
Halpin, T., & Bloesch, A. (1999). Data modeling
in UML and ORM: A comparison. Journal of
Database Management, 10(4), 4–13. doi:10.4018/
jdm.1999100101.
Henderson-Sellers, B. (1994). Methodologies -
Frameworks for OO success. American Program-
mer, 7(10), 2–11.
Henderson-Sellers, B. (2006). Method engineer-
ing: theory and practice. In Karagiannis, D., &
Mayr, H. C. (Eds.), Information Systems Technol-
ogy and its Applications (LNI). Bonn: Gesellschaft
für Informatik.
Henderson-Sellers, B. (2011a). Bridging
metamodels and ontologies in software engineer-
ing. Journal of Systems and Software, 84, 301–313.
doi:10.1016/j.jss.2010.10.025.
Henderson-Sellers, B. (2011b). Random thoughts
on multi-level conceptual modelling. In Delcam-
bre, L., & Kaschek, R. (Eds.), The Evolution of
Conceptual Modeling (LNCS) (Vol. 6520, pp. 93–
116). Berlin: Springer-Verlag. doi:10.1007/978-
3-642-17505-3_5.
Henderson-Sellers, B. (2012). On the mathemat-
ics of modelling, metamodelling, ontologies
and modelling languages. Berlin: Springer.
doi:10.1007/978-3-642-29825-7.
Henderson-Sellers, B., & Bulthuis, A. (1998). Ob-
ject-oriented metamethods. New York: Springer.
doi:10.1007/978-1-4612-1748-0.
Henderson-Sellers, B., & Edwards, J. M. (1994).
booktwo of object-oriented knowledge: The work-
ing object. New York: Prentice-Hall.
Henderson-Sellers, B., & Gonzalez-Perez,
C. (2005). The rationale of powertype-based
metamodelling to underpin software develop-
ment methodologies. Australian Conferences in
Research and Practice in Information Technology,
43, 7-16.
141
Ptolemaic Metamodelling?
Henderson-Sellers, B., & Gonzalez-Perez, C.
(2006). On the ease of extending a powertype-
based methodology metamodel. In Proceedings
of Meta-Modelling and Ontologies WoMM 2006.
WoMM.
Henderson-Sellers, B., & Unhelkar, B. (2000).
OPEN modeling with UML. Reading, MA:
Addison-Wesley.
Hume, D. (1739). A treatise of human nature.
Oxford, UK: Oxford University Press.
Husserl, E. (1900). Logische untersuchungen:
Erster teil: Prolegomena zur reinen logik.
Husserl, E. (1901). Logische untersuchungen:
Zweiter teil: Untersuchungen zur phänomenologie
und theorie der erkenntnis.
Husserl, E. (1939). Erfahrung und urteil: Unter-
suchungen zur genealogie der logik (experience
and judgment). (J.S. Churchill & K. Amerika,
Trans.). Lodnon: Routledge.
ISO/IEC. (1995). Software life cycle processes
ISO/IEC 12207. Geneva: International Standards
Organization/ International Electrotechnical
Commission.
ISO/IEC. (2007). Software engineering -
Metamodel for development methodologies, ISO/
IEC 24744. Geneva: International Organization
for Standardization/International Electrotechnical
Commission.
Johansson, I. (2005). Qualities, quantities, and
the endurant-perdurant distinction in top-level
ontologies. In Althoff, K.-D., Dengel, A., Berg-
mann, R., Nick, M., & Roth-Berghofer, T. (Eds.),
WM 2005: Professional Knowledge Management
Experiences and Vision. DFKI.
Kaschek, R. (2011). Introduction: Issues of a
conceptual modeling agenda. In Kaschek, R., &
Delcambre, L. (Eds.), The Evolution of Conceptual
Modeling (LNCS) (Vol. 6520, pp. ix–xv). Berlin:
Springer. doi:10.1007/978-3-642-17505-3.
Kent, S., Evans, A., & Rumpe, B. (1999). UML
semantics FAQ. In Moreira, A., & Demeyer, S.
(Eds.), ECOOP’99 Workshops (LNCS) (Vol. 1743,
pp. 33–56). Berlin: Springer-Verlag.
Kepler, J. (1596). Mysterium cosmographicum.
Kepler, J. (1609). Astronomia nova.
Kepler, J. (1617-1621). Epitome of Copernican
astronomy.
Kepler, (1627). Rudolphine tables.
Kleppe, A. (2007). A language description is more
than a metamodel. Paper presented at ATEM2007
(part of MoDELS2007). IEEE.
Kuhn, T. (1962). The structure of scientific revolu-
tions. Chicago, IL: University of Chicago Press.
Kühne, T. (2006). Matters of (meta-)modeling.
Software & Systems Modeling, 5, 369–385.
doi:10.1007/s10270-006-0017-9.
Kühne, T. (2007). Making modeling languages fit
for model-driven development. Paper presented
at ATEM2007 (part of MoDELS2007). IEEE.
Kühne, T. (2009). Contrasting classification with
generalization. In M. Kirchberg & S. Link (Eds.),
Proceedings of the Sixth Asia-Pacific Conference
on Conceptual Modelling, (pp. 71-78). IEEE.
Kurtev, I., Bézivin, J., Joualt, F., & Valduriez, P.
(2006). Model-based DSL frameworks. In Pro-
ceedings of OOPSLA’06: Companion to the 21st
ACM SIGPLAN Conference on Object-Oriented
Programming Systems, Languages, and Applica-
tions. ACM.
Laarman, A., & Kurtev, I. (2010). Ontological
metamodelling with explicit instantiation. In van
den Brand, M., Gašević, D., & Gray, J. (Eds.),
SLE2009 (LNCS) (Vol. 5969, pp. 174–183). Berlin:
Springer-Verlag.
142
Ptolemaic Metamodelling?
Lakoff, G. (1987). Women, fire, and danger-
ous things: What categories reveal about the
mind. Chicago, IL: University of Chicago Press.
doi:10.7208/chicago/9780226471013.001.0001.
Lamarck, J.-B. (1809). Philosophie zoologique, ou
exposition des considérations relatives à l’histoire
naturelle des animaux. Paris.
Lewis, D. (1971). Counterparts of persons and their
bodies. The Journal of Philosophy, 68, 203–211.
doi:10.2307/2024902.
Liskov, B. (1987). Data abstraction and hierarchy.
In Addendum to the Proceedings OOPSLA (Ad-
dendum). ACM.
Locke, J. (1975). An essay concerning human
understanding. Oxford, UK: Oxford University
Press.
Lowe, E. J. (2001). The possibility of metaphys-
ics: Substance, identity and time. Oxford, UK:
Oxford University Press. doi:10.1093/0199244
995.001.0001.
MacBride, F. (2011). Impure reference: A way
around the concept horse paradox. Philosophical
Perspectives, 25(1), 297–312. doi:10.1111/j.1520-
8583.2011.00217.x.
Margolis, E., & Laurence, S. (2012). Concepts. In
E. N. Zaltz (Ed.), The Stanford Encyclopedia of
Philosophy. Retrieved from http://plato.stanford.
edu/archives/fall2012/entries/concepts/
Martin, J., & Odell, J. J. (1992). Object-oriented
analysis and design. Englewood Cliffs, NJ:
Prentice-Hall.
Martin, J., & Odell, J. J. (1995). Object-oriented
methods: A foundation. Upper Saddle River, NJ:
Prentice Hall.
Martin, J., & Odell, J. J. (1998). Object-oriented
methods: A foundation. Upper Saddle River, NJ:
Prentice Hall.
Masolo, C., Guizzardi, G., Vieu, L., Bottazzi, E.,
& Ferrario, R. (2005). Relational roles and qua-
individuals. In Proceedings AAAI Fall Symposium
on Roles, an Interdisciplinary Perspective, (pp.
103-112). AAAI.
McBride, T., & Henderson-Sellers, B. (2011).
A method assessment framework. In Ralyté, J.,
Mirbel, I., & Deneckère, R. (Eds.), Engineering
Methods in the Service-Oriented Context. Berlin:
Springer. doi:10.1007/978-3-642-19997-4_7.
McGregor, J. D., & Korson, T. (1993). Supporting
dimensions of classification in object-oriented
design. Journal of Object-Oriented Programming,
5(9), 25–30.
Meyer, B. (1988). Object-oriented software con-
struction. Hemel Hempstead, UK: Prentice-Hall.
Milne, A. A. (1926). In which pooh goes visiting
and gets into a tight place. In Winnie-the-Pooh.
London: Methuen & Co. Ltd., London.
Monarchi, D., Booch, G., Henderson-Sellers, B.,
Jacobson, I., Mellor, S., Rumbaugh, J., & Wirfs-
Brock, R. (1994). Methodology standards: help
or hindrance? ACM SIGPLAN, 29(10), 223–228.
doi:10.1145/191081.191115.
Neumayr, B., Schrefl, M., & Thalheim, B. (2011).
Modeling techniques for multi-level abstraction. In
Kaschek, R., & Delcambre, L. (Eds.), The Evolu-
tion of Conceptual Modeling, (LNCS) (Vol. 6520,
pp. 68–92). Berlin: Springer. doi:10.1007/978-3-
642-17505-3_4.
Newton, I. (1687). Philosophnaturalis principia
mathematica.
Noonan, H. (2011). Identity. In E. N. Zaltz (Ed.),
The Stanford Encyclopedia of Philosophy. Re-
trieved from http://plato.stanford.edu/archives/
win2011/entries/identity/
Odell, J. (1994). Power types. Journal of Object-
Oriented Programming, 7(2), 8–12.
143
Ptolemaic Metamodelling?
OED. (1942). The pocket oxford dictionary of
current English (Fowler, F. G., & Fowler, H. W.,
Eds.). 4th ed.). Oxford, UK: Clarendon Press.
Ogden, C. K., & Richards, I. A. (1923). The
meaning of meaning. New York: Harcourt, Brace
and World.
OMG. (1997). UML notation: Version 1.1. OMG
document ad/97-08-05.
OMG. (2000). Request for proposal: UML 2.0
infrastructure RFP. OMG Document Number
ad/2000-08-08.
OMG. (2002). Unambiguous UML (2U) submis-
sion to UML 2 infrastructure RFP. OMG Docu-
ment number ad/2002-06-07.
OMG. (2003). Unified modeling language speci-
fication. OMG document formal/03-03-01.
OMG. (2006). Unified modeling language: Infra-
structure: Version 2.0. OMG Document Number
formal/05-07-05.
OMG. (2010). OMG unified modeling languageTM
(OMG UML): Infrastructure version 2.3. OMG
Document Number formal/2010-05-03.
OMG. (2011a). OMG unified modeling languag-
eTM (OMG UML): Infrastructure version 2.4.1.
OMG Document Number: formal/2011-08-05.
OMG. (2011b). OMG unified modeling languag-
eTM (OMG UML): Superstructure version 2.4.1.
OMG Document Number: formal/2011-08-06.
Opdahl, A., & Henderson-Sellers, B. (2004). A
template for defining enterprise modelling con-
structs. Journal of Database Management, 15(2),
39–73. doi:10.4018/jdm.2004040103.
Paley, W. (1809). Natural theology: Or, evidences
of the existence and attributes of the deity (12th
ed.). London: Printed for J. Faulder.
Parnas, D. L. (1972). A technique for software
module specification with examples. Com-
munications of the ACM, 15(5), 330–336.
doi:10.1145/355602.361309.
Partridge, C. (1996). Business objects: Re-en-
gineering for re-use. Oxford, UK: Butterworth
Heineman.
Partridge, C. (2002). Note: A couple of meta-
ontological choices for ontological architectures.
Technical Report 06/02, LADSEB-CNR, Padova,
Italy.
Pastor, O., Levin, A. M., Celma, M., Casamayor,
J. C., Virrueta, A., & Eraso, L. E. (2011). Model-
based engineering applied to the interpretation of
the human genome. In Kaschek, R., & Delcambre,
L. (Eds.), The Evolution of Conceptual Modeling,
(LNCS) (Vol. 6520, pp. 306–330). Berlin: Springer.
doi:10.1007/978-3-642-17505-3_14.
Peacocke, C. (1992). A study of concepts. Cam-
bridge, MA: MIT Press.
Peirce, C. (1898). Reasoning and the logic of
things: The Cambridge conference lectures of
1898. Harvard.
Pennebaker, J. W., Mehl, M. R., & Niederhoffer,
K. G. (2003). Psychological aspects of natural lan-
guage use: Our words, our selves. Annual Review
of Psychology, 54, 547–577. doi:10.1146/annurev.
psych.54.101601.145041 PMID:12185209.
Peurbach, G., & Regiomontanus, J. (1496).
Epitome of Ptolemy’s almagest.
Pirotte, A., Zimányi, E., Massart, D., & Yaku-
sheva, T. (1994). Materialization: A powerful
and ubiquitous abstraction pattern. In J. Bocca,
M. Jarke, & C. Zaniolo (Eds.), 20th International
Conference on Very Large Data Bases (pp. 630-
641). Academic Press.
Ptolemy, C. (150). Almagest, originally entitled
mathematike syntaxis.
144
Ptolemaic Metamodelling?
Quine, W. V. O. (1953). From a logical point of
view. Boston: Harvard University Press.
Quine, W. V. O. (1960). Word and object. Cam-
bridge, MA: MIT Press.
Quine,