Conference Paper

On-the-Fly Emendation of Multi-level Models

Authors:
To read the full-text of this research, you can request a copy directly from the authors.

Abstract

One of the main advantages of multi-level modeling environments over traditional modeling environments is that all ontological classification levels are treated in a uniform way and are all equally available for immediate, on-the-fly modification. However, such flexibility is a two-edged sword, since a minor change in a (meta-) ontological level can have a dramatic impact on other parts of the ontology (i.e. collection of ontological levels) - requiring a large number of "knock-on" changes to keep the overall ontology correct. To effectively exploit the modeling flexibility offered by multi-level modeling environments therefore, modelers need semi-automated support for emending ontologies to keep them consistent in the face of changes. In this paper we describe a model emendation architecture and illustrate how it can help modelers maintain the correctness of an ontology.

No full-text available

Request Full-text Paper PDF

To read the full-text of this research,
you can request a copy directly from the authors.

... While refactorings have been extensively studied for programming languages and flat models (Fowler 1999;Opdyke and Johnson 1990), they have not been proposed for multi-level models up to now. The closest work to ours is Atkinson et al. (2012), which explores the use of emendation services to repair a multi-level model upon changing some of its elements (e.g., modifying the potency of a clabject or adding an attribute). Our refactorings go beyond atomic changes as they may involve a sequence of modifications, and have a purpose of use, pre-conditions, and variants. ...
... Our refactorings go beyond atomic changes as they may involve a sequence of modifications, and have a purpose of use, pre-conditions, and variants. Emendation services could be used to implement our refactorings in Melanee, which is the technology used in Atkinson et al. (2012). ...
... Our refactorings are not specific to MetaDepth, but they are applicable to any tool supporting potency-based modelling like Melanee (Atkinson et al. 2012), the extension of Xmodeller described in Frank (2014), or the ConceptBase implementation in Neumayr et al. (2014), among others. ...
Article
Multi-level modelling promotes flexibility in modelling by enabling the use of several meta-levels instead of just two, as is the case in mainstream two-level modelling approaches. While this approach leads to simpler models for some scenarios, it introduces an additional degree of freedom as designers can decide the meta-level where an element should reside, having to ascertain the suitability of such decisions. In this respect, model refactorings have been successfully applied in the context of two-level modelling to rearrange the elements of a model while preserving its meaning. Following this idea, we propose a catalogue of 17 novel refactorings specific to multi-level models. Their objective is to help designers in rearranging elements across and within meta-levels and exploring the consequences. In this article, we detail each refactoring in the catalogue, show a classification across different dimensions, and describe the support we provide in our MetaDepth tool. We present two experiments to assess two aspects of our refactorings. The first one validates the predicted semantic side effects of the refactorings on the basis of more than 210.000 refactoring applications. The second one measures the impact of refactorings on three quality attributes of multi-level models.
... However, there is still a lack of formalisation of the main concepts of deep metamodelling such as deep characterisation through potency, double linguistic/ontological typing and linguistic extension [dG10]. Such formalisation is needed in order to explain the main aspects of the approach, study the different semantic variation points and their consequences, as well as to classify the different semantics found in the tools implementing them [KS07,ADP09,AM09,AGK09,dG10,AGK12]. ...
... The work in [AGK09] presents a prototype implementation of a modelling infrastructure which provides built-in support for multiple ontological as well as linguistic metalevels. This work was continued within the Melanie tool [AGK12], which includes support for suggesting emendations for models at lower metalevels when models at upper metalevels of a metamodelling stack change (e.g., by changing the value of a potency). In Melanie, fields can be decorated with socalled traits, like value mutability, which defines over how many metalevels the value may be changed from the default. ...
Article
Full-text available
Metamodelling is one of the pillars of model-driven engineering, used for language engineering and domain modelling. Even though metamodelling is traditionally based on a two-metalevel approach, several researchers have pointed out limitations of this solution and proposed an alternative deep (also called multi-level) approach to obtain simpler system specifications. However, this approach currently lacks a formalisation that can be used to explain fundamental concepts such as deep characterisation, double linguistic/ontological typing and linguistic extension. This paper provides such a formalisation based on the Diagram Predicate Framework, and discusses its practical realisation in the metaDepth tool.
... However, they cannot configure the conformance relation, and lack support for modelling processes. Among these tools, only Melanee provides quick fixes, though they are hard-coded and cannot be extended [4]. ...
Conference Paper
Modelling is a fundamental activity in Software Engineering, and central to model-based engineering approaches. It is used for different purposes, and so its nature can range from informal (e.g., as a casual mechanism for problem discussion and understanding) to fully formal (e.g., to enable the automated processing of models by model transformations). However, existing modelling tools only serve one of these two extreme purposes: either to create informal drawings or diagrams, or to build models fully conformant to their modelling language. This lack of reconciliation is hampering the adoption of model-based techniques in practice, as they are deemed too imprecise in the former case, and too rigid in the latter. In this new ideas paper, we claim that modelling tools need further flexibility covering different stages, purposes and approaches to modelling. We detail requirements for such a new generation of modelling tools, describe our first steps towards their realization in the Kite metamodelling tool, and showcase application scenarios.
... In addition, a few researchers consider the migration of dependent artifacts as well. These are model transformations [54], OCL constraints [55], and meta-model hierarchies with more than two levels [56]. A taxonomy for the evolution of modeling languages discussing different scenarios including the evolution of meta-models and the migration of models and model transformations, can be found in [40]. ...
Article
Model-driven engineering focuses on models as primary artifacts of the software development process, which means programs are mainly generated by model-to-code transformations. In particular, modeling languages tailored to specific domains promise to increase the productivity of software developers and the quality of generated software. Modeling languages, however, evolve over time and therefore, existing models have to be migrated accordingly. The manual migration of models tends to be tedious and error-prone, therefore tools have been developed to (partly) automate this process. Nevertheless, the migration results may not always be well-defined.
... While modifying clabjects at run-time is possible, being one of the advantages of multi-level modelling, care should be taken to keep consistent the instances of the modified clabjects. Some techniques to solve this issue are proposed in [Atkinson et al. 2012a]. ...
Article
Full-text available
Model-Driven Engineering (MDE) promotes models as the primary artefacts in the software development process, from which code for the final application is derived. Standard approaches to MDE (like those based on MOF or EMF) advocate a two-level metamodelling setting where Domain-Specific Modelling Languages (DSMLs) are defined through a metamodel that is instantiated to build models at the metalevel below. Multilevel modelling (also called deep metamodelling) extends the standard approach to metamodelling by enabling modelling at an arbitrary number of metalevels, not necessarily two. Proposers of multilevel modelling claim this leads to simpler model descriptions in some situations, although its applicability has been scarcely evaluated. Thus, practitioners may find it difficult to discern when to use it and how to implement multilevel solutions in practice. In this article, we discuss those situations where the use of multilevel modelling is beneficial, and identify recurring patterns and idioms. Moreover, in order to assess how often the identified patterns arise in practice, we have analysed a wide range of existing two-level DSMLs from different sources and domains, to detect when their elements could be rearranged in more than two metalevels. The results show this scenario is not uncommon, while in some application domains (like software architecture and enterprise/process modelling) pervasive, with a high average number of pattern occurrences per metamodel.
... There is also no concept available in Melanee for realizing layer spanning references as defined in Sec. 3. However, some framework capabilities like for example emendation support [7] are neither provided by DeepML nor by any other deep modeling framework we are aware of. Another deep modeling language is MetaDepth [5]. ...
Conference Paper
Full-text available
Traditional modeling approaches support a limited set of instantiation levels (typically one for classes and nother adjacent one for objects). Multi-level modeling approaches on the other hand have no such limit to the number of levels. As a consequence, an arbitrary number of levels may be used to define models, and the distinction between class and instance is redefined. The paper summarizes the experience gained from applying multi-levelmodeling techniques to a real application from the domain of development process improvement (DPI). The underlying case study has been conducted in cooperation with a large automotive supplier. We discuss the pros and cons of using multi-level modeling techniques and propose areas that we think would benefit from further research.
... Emendation. Interactive multi-level (meta)modeling [1] is a two-edged sword — it allows changes at any level in an ontology to have an immediate effect, but also allows inconsistencies to arise easily. Without automated emendation support, after each change modelers would have to manually check all model-elements for correctness and apply changes by hand to keep all parts of an ontology consistent. ...
Conference Paper
Full-text available
Multi-level modeling based on deep instantiation has attracted growing interest over the last few years as a better way of creating and organizing models capturing problem domains featuring more than one classification level. However, until recently the approach has lacked practical tool support. This work introduces Melanie, a new MultiLevel Modeling and Ontology Engineering Environment, that has been specifically developed to support multi-level modeling as well as other important new modeling use cases such as unified exploratory / constructive modeling, symbiotic domain-specific / general purpose languages and interactive (meta)modeling. This work briefly explains the motivations and goals behind Melanie and provides a short overview of its features and architecture.
Conference Paper
Full-text available
One of the key enablers of further growth of multi-level modeling will be the development of objective ways to allow multi-level modeling approaches to be compared to one another and to two-level modeling approaches. While significant strides have been made regarding qualitative comparisons, there is currently no adequate way to quantitatively assess to what extent a multi-level model may be preferable over another model with respect to high-level qualities such as understandability, maintainability, and control capacity. In this paper, we propose deep metrics, as an approach to quantitatively measure high-level model concerns of multi-level models that are of interest to certain stakeholders. Beyond the stated goals, we see deep metrics as furthermore supporting the comparison of modeling styles and aiding modelers in making individual design decisions. We discuss what makes a metric "depth-aware" so that it can appropriately capture multi-level model properties, and present two concrete proposals for metrics that measure high-level multi-level model qualities.
Article
In the future, robots will play an increasingly important role in many areas of human society from domestic housekeeping and geriatric care to manufacturing and running businesses. To best exploit these new opportunities, and allow third party developers to create new robot applications in as simple and efficient a manner as possible, new user-friendly approaches for describing desired robot behavior need to be supported. This paper introduces a prototype domain-specific modeling framework designed to support the quick, simple and reliable creation of control software for standard robot platforms. To provide the best mix of general purpose and domain-specific language features the framework leverages the deep modeling paradigm and accommodates the execution phases as well as design phases of a robot application's lifecycle.
Article
Multi-level modeling has become a popular paradigm as it allows for a natural and easy-to-understand representation of various real-word hierarchies. To date, several approaches have been proposed on how multi-level models should be represented and constructed - however, their continuous evolution and consistency has received considerably less attention. Consistency checking is critical to efficient and effective modeling-especially to understand the impact of model changes. Multi-level modeling adds another dimension because it allows for both model and metamodel changes over multiple levels. This paper discusses the key challenges for consistency checking in multi-level modeling environments and outlines an incremental and highly flexible approach for addressing these challenges effectively without being limited to a specific modeling paradigm. A prototype implementation of the approach has been developed; preliminary evaluation results suggest that the approach scales and provides instant consistency information during multilevel modeling.
Article
As the number and diversity of technologies involved in building enterprise systems continues to grow so does the importance of modeling tools that are able to present customized views of enterprise systems to different stakeholders according to their needs and skills. Moreover, since the range of required view types is continuously evolving, it must be possible to extend and enhance the languages and services offered by such tools on an ongoing basis. However, this can be difficult with today׳s modeling tools because the meta-models that define the languages, views and services they support are usually hardwired and thus not amenable to extensions. In practice, therefore, various workarounds have to be used to extend a tool׳s underlying meta-model. Some of these are built into the implemented modeling standards (e.g. UML 2, BPMN 2.0 and ArchiMate 2.0) while others have to be applied by complementary, external tools (e.g. annotation models). These techniques not only increase accidental complexity, they also reduce the ability of the modeling tool to ensure adherence to enterprise rules and constraints. In this paper we discuss the strengths and weaknesses of the various approaches for language extension and propose a modeling framework best able to support the main extension scenarios currently found in practice today.
Conference Paper
Full-text available
Multi-level modeling based on deep instantiation has attracted growing interest over the last few years as a better way of creating and organizing models capturing problem domains featuring more than one classification level. However, until recently the approach has lacked practical tool support. This work introduces Melanie, a new MultiLevel Modeling and Ontology Engineering Environment, that has been specifically developed to support multi-level modeling as well as other important new modeling use cases such as unified exploratory / constructive modeling, symbiotic domain-specific / general purpose languages and interactive (meta)modeling. This work briefly explains the motivations and goals behind Melanie and provides a short overview of its features and architecture.
Conference Paper
Full-text available
Predefined composite operations are handy for efficient software modeling, e.g., for the automatic execution of refactorings, and for the introduction of patterns in existing models. Some modeling environments provide an initial set of basic refactoring operations, but hardly offer any extension points for the user. Even if extension points exist, the introduction of new composite operations requires programming skills and deep knowledge of the respective metamodel. In our demonstration we present the Operation Recorder, a tool for specifying composite operations, like refactorings, within the user's modeling language and environment of choice. The user models the composite operation by-example, which enables the semi-automatic derivation of a generic composite operation specification. This specification may be used in further modeling scenarios, like model refactoring and model versioning. We demonstrate our tool by creating two refactoring specifications for UML class diagrams and UML state machine diagrams.
Conference Paper
Full-text available
Refactorings can be used to improve the structure of software artifacts while preserving the semantics of the encapsulated information. Various types of refactorings have been proposed and implemented for programming languages such as Java or C#. With the advent of Model-Driven Software Development (MDSD), the need for restructuring models similar to programs has emerged. Previous work in this field [1,2] indicates that refactorings can be specified generically to foster their reuse. However, existing approaches can handle only certain types of modelling languages and reuse refactorings only once per language. In this paper a novel approach based on role models to specify generic refactorings is presented. We discuss how this resolves the limitations of previous works, as well as how specific refactorings can be defined as extensions to generic ones. The approach was implemented based on the Eclipse Modeling Framework (EMF) [3] and evaluated using multiple modelling languages and refactorings.
Article
Full-text available
Support for ontology evolution becomes extremely important in distributed development and use of ontologies. Information about change...
Conference Paper
Almost every expert in Object-Oriented Development stresses the importance of iterative development. As you proceed with the iterative development, you need to add function to the existing code base. If you are really lucky that code base is structured just right to support the new function while still preserving its design integrity. Of course most of the time we are not lucky, the code does not quite fit what we want to do. You could just add the function on top of the code base. But soon this leads to applying patch upon patch making your system more complex than it needs to be. This complexity leads to bugs, and cripples your productivity.
Article
Although domain-specific modeling tools have come a long way since the modern era of model-driven development started in the early 1990s and now offer an impressive range of features, there is still significant room for enhancing the flexibility they offer to end users and for combining the advantages of domain-specific and general-purpose languages. To do this, however, it is necessary to enhance the way in which the current generation of tools view metamodeling and support the representation of the multiple, ?ontological? classification levels that often exist in subject domains. State-of-the-art tools essentially allow users to describe the abstract and concrete syntaxes of a language in the form of metamodels and to make statements in that language in the form of models. These statements typically convey information in terms of types and instances in the domain (e.g., the classes and objects of UML), but not in terms of types of types (i.e., domain metaclasses), and types of types of types, and so on, across multiple classification levels. In essence, therefore, while they provide rich support for ?linguistic? metamodeling, the current generation of tools provides little if any built-in support for modeling ?ontological? classification across more than one type/instance level in the subject domain. In this paper, we describe a prototype implementation of a new kind of modeling infrastructure that, by providing built-in support for multiple ontological as well as linguistic classification levels, offers various advantages over existing language engineering approaches and tools. These include the ability to view a single model from the perspective of both a general-purpose and a domain-specific modeling language, the ability to define constraints across multiple ontological classification levels, and the ability to tie the rendering of model elements to ontological as well as linguistic types over multiple classification levels. After first outlining the key conce- - ptual ingredients of this new infrastructure and presenting the main elements of our current realization, we show these benefits through two small examples.
Article
This thesis defines a set of program restructuring operations (refactorings) that support the design, evolution and reuse of object-oriented application frameworks. The focus of the thesis is on automating the refactorings in a way that preserves the behavior of a program. The refactorings are defined to be behavior preserving, provided that their preconditions are met. Most of the refactorings are simple to implement and it is almost trivial to show that they are behavior preserving. However, for a few refactorings, one or more of their preconditions are in general undecidable. Fortunately, for some cases it can be determined whether these refactorings can be applied safely. Three of the most complex refactorings are defined in detail: generalizing the inheritance hierarchy, specializing the inheritance hierarchy and using aggregations to model the relationships among classes. These operations are decomposed into more primitive parts, and the power of these operations is discussed from the perspectives of automatability and usefulness in supporting design. Two design constraints needed in refactoring are class invariants and exclusive components. These constraints are needed to ensure that behavior is preserved across some refactorings. This thesis gives some conservative algorithms for determining whether a program satisfies these constraints, and describes how to use this design information to refactor a program.
Introducing the Java Pet Store 2.0 Application
  • M Basler
  • S Brydon
  • D Nourie
  • I Singh
A Unified Framework for Multi-Level Modeling
  • B Kennel
Change management for metadata evolution
  • D Maynard
  • W Peters
  • M Sabou
  • M Dáquin
Software Language Engineering: Creating Domain-specific Languages Using Metamodels
  • A Kleppe