Fig 4 - uploaded by Giancarlo Guizzardi
Content may be subject to copyright.
Source publication
In recent years, there has been a growth in the use of reference conceptual models to capture information about complex and critical domains. However, as the complexity of domain increases, so does the size and complexity of the models that represent them. Over the years, different techniques for complexity management in large conceptual models hav...
Contexts in source publication
Context 1
... example, in the model of fig. 3, we have initially three occurrences of this pattern. By applying R3 to that model, we obtain the model of fig. 4. So, for example, in fig. 3, the relation 'rents' (R' above) connects the sortal 'Personal Customer' -a role played by an 'Adult Living Person' when renting a car (ST 1 ) -to another sortal 'Rental Car' -a role played by an 'Available Car' when being rented by a customer (ST 2 ). Due to the application of R3, this relation is then now ...
Context 2
... ) -to another sortal 'Rental Car' -a role played by an 'Available Car' when being rented by a customer (ST 2 ). Due to the application of R3, this relation is then now moved to connect a more abstract supertype of 'Personal Customer' ('Adult' -ST 1 ) and a more abstract supertype of 'Rental Car' ('Available Car'-ST 2 ) (see oval marked as R3* in fig. 4). Moreover, the rolenames 'Personal Customer' and 'Rental Car' are attached to the association ends connected to 'Adult' and 'Available Car', respectively. 5 Finally, the minimum cardinality constraint for each of these association ends are relaxed to zero. After all, it is neither the case that every 'Adult' rents at least one car nor ...
Context 3
... the association ends connected to 'Adult' and 'Available Car', respectively. 5 Finally, the minimum cardinality constraint for each of these association ends are relaxed to zero. After all, it is neither the case that every 'Adult' rents at least one car nor the case that every 'Available Car' must be rented. Of course, as illustrated in R3* in fig. 4, an analogous case can be made for the abstraction of 'Corporate Customer' into the supertyping sortal ...
Context 4
... example, in the model of fig. 4, we have three occurrences of this pattern. By applying R4 to that model, we obtain the model of fig. 5. So, for example, in fig. 4, we have the phase partition 'developmental phase' connecting the phases 'Child' (SortalT ype j 1),'Teenager' (SortalT ype j 2) and 'Adult' (SortalT ype i ) to the sortal (another phase) 'Living Person' ...
Context 5
... example, in the model of fig. 4, we have three occurrences of this pattern. By applying R4 to that model, we obtain the model of fig. 5. So, for example, in fig. 4, we have the phase partition 'developmental phase' connecting the phases 'Child' (SortalT ype j 1),'Teenager' (SortalT ype j 2) and 'Adult' (SortalT ype i ) to the sortal (another phase) 'Living Person' (SortalType). As one can observe, in the model of fig. 5 (see R4* in the lower part of the figure), this configuration is replaced by ...
Similar publications
Reusing previously completed software repository to enhance the development process is a common phenomenon. If developers get suggestions from the existing projects they might be benefited a lot what they eventually expect while coding. The strategies available in this field have been rapidly changing day by day. There are a number of efforts that...
Citations
... General strategies for the (un)folding mechanisms needed for model summarization have been the subject of study in the past in the context of dealing with large conceptual models [11,12,34], as well as more recently utilizing foundational ontologies to generate ontologically founded (un) foldings [27,64] of large conceptual models. The general idea of the latter approaches is to let the models undergo an (automatic) lossy transformation based on the underlying foundational ontology, to yield another model (a summarizing view) that captures the gist of what the original model was about. ...
Humanity has long since used models, in different shapes and forms, to understand, redesign, communicate about, and shape, the world around us; including many different social, economic, biological, chemical, physical, and digital aspects. This has resulted in a wide range of modeling practices. When the models as used in such modeling practices have a key role to play in the activities in which these practices are ‘embedded’, the need emerges to consider the effectiveness and efficiency of such processes, and speak about modeling capabilities. In the latter situation, it also becomes relevant to develop a thorough understanding of the artifacts involved in modeling practices/capabilities. One context in which models play (an increasingly) important role is model-driven systems development, including software engineering, information systems engineering, business process engineering, enterprise engineering, and enterprise architecture management. In such a context, we come across a rich variety of modeling related artifacts, such as views, diagrams, programs, animations, specifications, etc. In this paper, which is actually part of an ongoing ‘journey’ in which we aim to gain deeper insights into the foundations of modeling, we take a fundamental look at the variety of modeling related artifacts as used in the context of model-driven (systems) development, while also presenting an associated framework for understanding, synthesizing the insights we obtained during the ‘journey’ so-far. In doing so, we will also argue that the aforementioned artifacts are actually specific kinds of models, albeit for fundamentally different purposes. The provided framework for understanding involves definitions of domain model, the Return on Modeling Effort (RoME), the conceptual fidelity of domain models, as well as views as a mechanism to manage the complexity of domain models.
... This aspect of explanation goes exactly in the inverse direction of ontological unpacking, which is a process that reveals the implicit distinctions underlying domain models, thus, typically yielding larger and more complex models. For this reason, as discussed by Romanenko et al. [65], ontological unpacking must be complemented by complexity management tools for, e.g., model abstraction/summarization, modularization, and viewpoint extraction [66][67][68][69], which could be adapted to reduce the complexity of the model for an explanation-seeker and with a set of requests for explanation in mind. ...
... The intuition about CM abstractions is to provide the user with a bird's-eye view of the model by filtering out some details. Some of the existing algorithms for abstraction are based on classic modeling notations (UML, ER) and use topological properties of the graphs (see [5,6]), while others leverage the ontological semantics offered by ontology-driven conceptual modeling languages (see [7,8]). ...
... An example is 'Artifact', which applies to different types of documents, music, and video recordings. As we will see later in the paper, a special type of rigid sortal type called a kind plays a fundamental role in existing OntoUML abstraction algorithms [7,8]. For more examples and formalization of these and other notions, one can refer to [31]. ...
... In contrast, the graph-rewriting rules in the existing OntoUML abstraction algorithms [7,8] leverage the ontological semantics of the language based on the UFO ontology. The first version of an abstraction algorithm was introduced in [7], followed by an enhanced version in [8], which was able to abstract more sophisticated models, i.e., models employing a larger number of formal ontological primitives. ...
... ExpO consists of (1) an API that implements model transformations that are supposed to help in ODCM understanding, (2) an extension of the existing OntoUML Plugin with the API functionality, and (3) a web application for model exploration mostly designed for domain experts with a non-technical background. This work is based on several previous papers [5,7,10,11]. However, our main purpose here is not to formulate a final set of explanation operations needed to reach a better understanding of a given model, but to present the system itself. ...
... In this context, the term 'explanation' refers to pragmatic explanation, where 'pragmatic' signifies an 'instrumentalist' approach to constructing explanations (see [16]), emphasizing the creation of a 'toolbox' designed to assist users in reaching their goals. In [11], we show that complexity management approaches, such as clustering [7] and abstraction [5,10], can be viewed as pragmatic explanation techniques when talking about domain ontologies. Recent experiments revealed that this is also true for ODCMs [12]. ...
... ExpO consists of (1) an API that implements model transformations that are supposed to help in ODCM understanding, (2) an extension of the existing OntoUML Plugin with the API functionality, and (3) a web application for model exploration mostly designed for domain experts with a non-technical background. This work is based on several previous papers [5,7,10,11]. However, our main purpose here is not to formulate a final set of explanation operations needed to reach a better understanding of a given model, but to present the system itself. ...
... In this context, the term 'explanation' refers to pragmatic explanation, where 'pragmatic' signifies an 'instrumentalist' approach to constructing explanations (see [16]), emphasizing the creation of a 'toolbox' designed to assist users in reaching their goals. In [11], we show that complexity management approaches, such as clustering [7] and abstraction [5,10], can be viewed as pragmatic explanation techniques when talking about domain ontologies. Recent experiments revealed that this is also true for ODCMs [12]. ...
0000−0002−8139−5977] , Diego Calvanese 1,2[0000−0001−5174−9693] , and Giancarlo Guizzardi 3,4[0000−0002−3452−553X] Abstract. Ontology-driven conceptual models play an explanatory role in complex and critical domains. However, since those models may consist of a large number of elements, including concepts, relations and sub-diagrams, their reuse or adaptation requires significant efforts. While conceptual model engineers tend to be biased against the removal of information from the models, general users struggle to fully understand them. The paper describes ExpO-a prototype that addresses this trade-off by providing three components: (1) an API that implements model transformations , (2) a software plugin aimed at modelers working with the language OntoUML, and (3) a web application for model exploration mostly designed for domain experts. We describe characteristics of every component and specify scenarios of possible usages.
... General strategies for the (un)folding mechanisms needed for model summarization have been the subject of study in the past in the context of dealing with large conceptual models (Hofstede et al. 1992;Campbell et al. 1996;Creasy and Proper 1996), as well as more recently utilizing foundational ontologies to generate ontologically founded (un)foldings (Guizzardi et al. 2019;Romanenko et al. 2022a) of large conceptual models. The general idea of the latter approaches is to let the models undergo an (automatic) lossy transformation based on the underlying foundational ontology, to yield another model but capturing the gist of what the original model was about. ...
Humanity has long since used models in different shapes and forms to understand , redesign, communicate about, and shape, the world around us; including many different social, economic, biological, chemical, physical, and digital aspects. This has resulted in a wide range of modeling practices. When the models as used in such modeling practices have a key role to play in the activities in which these modeling practices are 'embedded', the need emerges to consider the effectiveness and efficiency of such processes, and speak about modeling capabilities. In the latter situation, it becomes relevant to develop a thorough understanding of the artifacts involved in the modeling practices/capabilities. One field in which models play (an increasingly) important role is the field of system development (including software engineering, information systems engineering, and enterprise design management). In this context, we come across notions, such as views, diagrams, programs, animations, specifications, etc. The aim of this paper is to take a fundamental look at these notions. In doing so, we will argue that these notions should actually be seen as specific kinds of models, albeit for fundamentally different purposes. 5.1 Introduction Whenever we are confronted with complex phenomena, such as the processes we observe in nature, the construction of buildings, the design of information systems, etc, we tend to 'work with' an abstraction (in our mind) of the actual phenomenon; zooming in on those 'properties' of the phenomenon that matter to us, and filtering out all the properties that are not germane to the goals at hand. When we externalize this abstraction in terms of some artifact, then this artifact is a model (to us, as an individual) of the observed phenomenon. More generally, one can observe how humanity has long since used models to understand, redesign, communicate about, and shape, the world around us, including many different social, economic, biological, chemical, physical, and digital aspects. These models may take different shapes and forms, such as sketches, precise drawings, textual specifications, or tangible forms mimicking key physical properties of some original. This wide spread, and natural (Zarwin et al. 2014) use of models has resulted in many different modeling practices. When the models as created and/or used in such modeling practices have a key role to play in the activities in which these modeling practices are 'embedded', a natural need emerges to consider the effectiveness and efficiency of such processes, and speak about 123
... We make the assumption that it should be a 1:1 connection via an object property. Nevertheless, we consider the graph rewriting rules on page 6 of [6] to represent an important contribution in reducing the complexity of ontology models. The approach of Bense and Humm [7] proposes satisfying the instance and type character via two different inheritance mechanisms of properties. ...
Research into knowledge and expert system engineering has seen numerous attempts to streamline conceptual modeling, especially in the field of so-called Multi-Level Modeling (MLM). In this paper, we will refine and augment the approaches made there, so that these can also be used for conceptual modeling in general. To this end, we introduce a formal methodology for the definition of attributes (data properties) and relational relationship types (object properties). Rules are then defined as instantiation regulations in this connection. As a new methodology, we introduce the so-called Value Assignment Propagation (VAP), and then show how this streamlines conceptual modeling, how layer-mistakes can be avoided and how previously unfulfilled requirements for MLM can be satisfied.
... The use of conceptual models has increased due to the need to represent complex problems in various domains [5]. This paper proposes the use of design science methodology for the development of conceptual modeling of the V gene annotation process. ...
... However, in the case of ODCMs, there is the possibility to make good use of the built-in ontological semantics. The first version of an abstraction algorithm leveraging foundational ontological semantics was introduced in [12], followed by an enhanced one [18], which is based on 11 graph-rewriting rules. ...
... Therefore, we can assume that the rules suggested for developing the abstractions for ODCMs [12,18] should generate TI abstractions as defined by Giunchiglia & Walsh [10]. We come back to this discussion in Section 3. ...
... In other words, OntoUML shifts the inherent complexity of reality towards the language's definition in such a way that every syntactically valid model represents a sound ontology in terms of UFO [6]. With this in mind, patterns for ODCM's abstractions were initially developed in terms of OntoUML [12,18]. ...
Ontology-driven conceptual models are precise and semantically transparent domain descriptions that enable the development of information systems. As symbolic artefacts, such models are usually considered to be self-explanatory. However, the complexity of a system significantly correlates with the complexity of the conceptual model that describes it. Abstractions of both conceptual models and ontology-driven conceptual models are thus considered to be a promising way to improve the understandability and comprehensibility of those models. Although algorithms for providing abstractions of such models already exist, they still lack precisely formulated formal semantics. This paper aims to provide an approach towards the formalization of the abstraction process. We specify in first-order modal logic one of the graph-rewriting rules for ontology-driven conceptual model abstractions, in order to verify the correctness of the corresponding abstraction step. We also assess the entire network of abstractions of ontology-driven conceptual models and discuss existing drawbacks.
... Booshehri and Luksch [23] developed an approach that utilized semantic web techniques based on the V-OntModel. Another approach for Ontology-based model abstraction comes from Guizzardi et al. [24]. They implement a collection of abstraction rules, such as, similar to Egyed, abstractions by introducing direct relationships to substitute indirect relators. ...
... This might be explained, by the fact that they studied sketches, which are different in nature from models committed to repositories. Particularly surprising was that summary elements, as they are proposed by approaches to create abstraction automatically [24] [22], were rarely observed in our subject projects, namely only in one out of five cases. ...
Models are a useful tool for software design, analysis, and to support the onboarding of new maintainers. However, these benefits are often lost over time, as the system implementation evolves and the original models are not updated. Reverse engineering methods and tools could help to keep models and implementation code in sync; however, automatically reverse-engineered models are typically not abstract and contain extensive information that prevents understanding. Recent advances in AI-based content generation make it likely that we will soon see reverse engineering tools with support for human-grade abstraction. To inform the design and validation of such tools, we need a principled understanding of what manual abstraction is, a question that has received little attention in the literature~so~far. Towards this goal, in this paper, we present a multiple-case study of model-to-code differences, investigating five substantial open-source software projects retrieved via repository mining. To explore characteristics of model-to-code differences, we, all in all, manually matched 466 classes, 1352 attributes, and 2634 operations from source code to 338 model elements (classes, attributes, operations, and relationships).
These mappings precisely capture the differences between a provided class diagram design and implementation codebase.
Studying all differences in detail allowed us to derive a taxonomy of difference types and to provide a sorted list of cases corresponding to the identified types of differences.
As we discuss, our contributions pave the way for improved reverse engineering methods and tools, new mapping rules for model-to-code consistency checks, and guidelines for avoiding over-abstraction and over-specification during design.
