Conference Paper

A Deep View-Point Language for Projective Modeling

Authors:
If you want to read the PDF, try requesting it from the authors.

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.

... However, for one frequently occurring view type this approach is unnecessarily complex -"subsetting views" which simply shows a subset of the elements in the SUM without changing their form. For this kind of view, the general, deep ATL approach described in [11] is unnecessarily complex. In this paper we therefore present a "lightweight" mechanism for projecting subsetting views which avoids much of the complexity of the current approach but still allows views to be edited. ...
... The projection traces are used to update the model elements in the view footprint if and when the corresponding model elements in the view content are edited. The view language and the projection rules together define a "view type" in this approach [11]. ...
... This paper focuses on the DOSM approach supported by the Doreen tool [11] which is implemented using Melanee's deep modeling technology. ...
Conference Paper
Full-text available
Projective modeling environments offer a more efficient and scalable way of supporting multiple views of large software systems than traditional, synthesis-based approaches to view-based development. However , the definition of the view projection transformations needed to create views, on demand, from the single underlying model and ensure that they remain synchronized is a complex and time-consuming process. In particular, to make views editable, the projection process involves the creation of "traces" to map view model elements to their sources in the single underlying model. While this is unavoidable for most view types, for a commonly occurring special case this level of complexity is not required. In this paper we therefore present a simpler approach, based on the OCL language, which simplifies the projection definitions for this kind of view. The approach is defined in the context of a deep, view-based modeling environment which combines support for views with multi-level modeling in order to seamlessly cover all phases of a system's life cycle.
... In OSM, the SUM is displayed or manipulated exclusively through partial, user-specific, and customizable views. Model transformations create these views dynamically from the SUM Tunjic and Atkinson, 2015;Burger and Schneider, 2016;Atkinson and Tunjic, 2017). The views allow the users to make modifications to the system and operate on a temporarily inconsistent state of the system description. ...
... We define our formal notion of views and view types in Section 5.4. Since the view generation is mostly independent from the way the SUM is constructed (i.e., whether it is a monolithic SUM or a V-SUM), we refer to existing and current work, e.g., Burger et al. (2014), Tunjic and Atkinson (2015), Burger and Schneider (2016) and Atkinson and Tunjic (2017), for that topic and do not discuss it in more detail in this article. ...
Article
Full-text available
During the development of large software-intensive systems, developers use several modeling languages and tools to describe a system from different viewpoints. Model-driven and view-based technologies have made it easier to define domain-specific languages and transformations. Nevertheless, using several languages leads to fragmentation of information, to redundancies in the system description, and eventually to inconsistencies. Inconsistencies have negative impacts on the system’s quality and are costly to fix. Often, there is no support for consistency management across multiple languages. Using a single language is no practicable solution either, as it is overly complex to define, use, and evolve such a language. View-based development is a suitable approach to deal with complex systems, and is widely used in other engineering disciplines. Still, we need to cope with the problems of fragmentation and consistency. In this paper, we present the Vitruvius approach for consistency in view-based modeling. We describe the approach by formalizing the notion of consistency, presenting languages for consistency preservation, and defining a model-driven development process. Furthermore, we show how existing models can be integrated. We have evaluated our approach at two case studies from component-based and embedded automotive software development, using our prototypical implementation based on the Eclipse Modeling Framework.
... The number of correspondence links between stacks would be minimized if all redundancy were removed by maximizing the sharing of concepts and data between stacks [18]. Retrieving the original stacks would still be possible by using views that synthesize the desired perspective. ...
Article
Digital twins (DTs) lie at the heart of a new vision to support manufacturing and cyber-physical systems. The realization of their full potential requires complex technical solutions, due to unprecedented synchronization requirements, the need to support scenario playing and solution space exploration, and their nature as hubs that tie together numerous heterogeneous technological spaces. Hence, a key factor in making the notion of DTs succeed in large scale scenarios is to manage overall system complexity. It is therefore critical that DT standards support DTs and their integration with other systems by introducing as little accidental complexity as possible. Unfortunately, the DT standards developed to date are based on architectures that have been shown to be detrimental to this goal. We first elaborate on why current DT standards do not sufficiently address the faced challenges and subsequently present two modeling paradigms that synergistically reduce and manage complexity.
... This EA model typically consists of a large number of model elements capturing various aspects of the enterprise. To deal with this high complexity, each stakeholder of the team perhaps view only a certain aspect of her enterprise model [13]. Diagramming views that comprehensibly represent a relatively high number of EA elements is non-trivial for the following reasons: (a) upon creating a view, we need to determine the layout used for rendering it; (b) aesthetics of the created views should be preserved while the views themselves are being edited. ...
Article
Full-text available
Today’s enterprise architecture should incorporate high-level enterprise services that are considered as wrappers of business processes and ICT capabilities. This service-oriented enterprise model consists of a large number of model elements capturing various aspects of the enterprise in question, making any attempt to browse it too cumbersome. Enterprise architecture modeling, therefore, often resorts to a multi-view representation where views are focused and scoped. We define a visual modeling language and develop a supporting tool called SeamCAD that together lay the foundation for further multi-level enterprise modeling techniques. This article is dedicated to our tool realizing a notation schema and reinforcing a distinctive diagramming layout designed to visually capture the hierarchical containment in enterprise models. We demonstrate our real-life EA applications that were constructed thanks to SeamCAD. We report users’ feedback on SeamCAD.
... This EA model typically consists of a large number of model elements capturing various aspects of the enterprise. To deal with this high complexity, each stakeholder of the team perhaps view only a certain aspect of her enterprise model [13]. Diagramming views that comprehensibly represent a relatively high number of EA elements is non-trivial for the following reasons: (a) upon creating a view, we need to determine the layout used for rendering it; (b) aesthetics of the created views should be preserved while the views themselves are being edited. ...
Article
Most view-based modeling approaches are today based on a “synthetic” approach in which the views hold all the information modeled about a system and are kept consistent using explicit, inter-view correspondence rules. The alternative “projective” approach, in which the contents of views are “projected” from a single underlying model on demand, is far less widely used due to the lack of suitable conceptual frameworks and languages. In this paper we take a step towards addressing this problem by presenting the foundations of a suitable language and conceptual framework for defining and applying views for projective modeling. The framework leverages deep modeling in order to seamlessly support views that exist at, and span, multiple levels of classification. The viewpoint language was developed in the context of Orthographic Software Modeling but is more generally applicable to any projective modeling approach.
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.
Chapter
Full-text available
The cloud has the potential to revolutionize the way software is developed and governed, and to consign much of the artificial complexity involved in software engineering today to history. The cloud promises to unlock the potential of large, heterogeneous distributed development teams by supporting social interaction, group dynamics and key project management principles in software engineering. . It not only holds the key to reducing the tensions between agile and “heavyweight” methods of developing software it also addresses the problem of software license management and piracy – software in the cloud cannot be copied! We outline the motivation for such a cloud-driven approach to software engineering which we refer to as Cloud Aided Software Engineering (CASE 2.0), and introduce some key innovations needed to turn it into reality. We also identify some of the main challenges that still need to be addressed, and some of the most promising strategies for overcoming them.
Conference Paper
Full-text available
Although they are significantly different in how they decompose and conceptualize software systems, one thing that all advanced software engineering paradigms have in common is that they increase the number of different views involved in visualizing a system. Managing these different views can be challenging even when a paradigm is used independently, but when they are used together the number of views and inter-dependencies quickly becomes overwhelming. In this paper we present a novel approach for organizing and generating the different views used in advanced software engineering methods that we call Orthographic Software Modeling (OSM). This provides a simple metaphor for integrating different development paradigms and for leveraging domain specific languages in software engineering. Development environments that support OSM essentially raise the level of abstraction at which developers interact with their tools by hiding the idiosyncrasies of specific editors, storage choices and artifact organization policies. The overall benefit is to significantly simplify the use of advanced software engineering methods.
Conference Paper
Full-text available
Existing bidirectional model transformation languages are mainly state-based: a transformation is considered composed from functions whose inputs and outputs only consist of original and updated models, but alignment relationships between the models are not specified. In the paper we identify and discuss three major problems caused by this under-specification. We then propose a novel formal framework based on a graphical language: models are nodes and updates are arrows, and show how the three problems can be fixed.
Article
Full-text available
We propose a novel approach to the view update problem for tree-structured data: a domain- specific programming language in which all expressions denote bi-directional transformations on trees. In one direction, these transformations—dubbed lenses—map a “concrete” tree into a simplified “abstract view”; in the other, they map a modified abstract view, together with the original concrete tree, to a correspondingly modified concrete tree. Our design emphasizes both robustness and ease of use, guaranteeing strong well-behavedness and totality properties for well- typed lenses. We begin by identifying a natural mathematical space of well-behaved bi-directional transformations over arbitrary structures, studying definedness and continuity in this setting. We then instantiate this semantic framework in the form of a collection of lens combinators that can be assembled to describe bi-directional transformations on trees. These combinators include familiar constructs from functional programming (composition, mapping, projection, conditionals, recursion) together with some novel primitives for manipulating trees (splitting, pruning, copying, merging, etc.). We illustrate the expressiveness of these combinators by developing a number of bi-directional list-processing transformations as derived forms. An extended example shows how our combinators can be used to define a lens that translates between a native HTML representation of browser bookmarks and a generic abstract bookmark format.
Conference Paper
Full-text available
For many companies, the strategic as well as the organizational fit of their information systems is a pivotal factor for staying competitive. At the same time, there is an increasing demand for integrating business processes and informations systems with those of customers and suppliers. The resulting need for organizational changes and the introduction of corresponding information systems is a challenging task. The complexity of the task requires a separation of concerns. At the same time it causes language barriers between various stakeholders, especially between business people and information technology professionals. Enterprise models provide various abstractions that help with the design of corporate information systems which are in line with a company's organization and its long term strategy. They also promise to provide a common conceptual foundation to foster the communication between people with different professional backgrounds. In this paper we introduce a model for enterprise modelling that is based on an extendable set of special purpose modeling languages, e.g. for describing corporate strategies, business processes, resources or information. The visual languages provide intuitive abstractions for various observers. The languages are defined in metamodels which in turn are specified through a common meta-metamodel. Similar to a specialized technical language, they provide concepts that help with structuring and analyzing a domain according to specific objectives. Since the languages are specified in a semi formal way, the models allow for the generation of software prototypes. The languages share common concepts which allow for a tight integration of the various parts of an enterprise model. In addition to offering specialized modeling languages, the modeling method also includes examples, case studies and reference models - to promote the re-use of concepts and artefacts. The use of the method is illustrated by an example, where two different partial models are being integrated.
Conference Paper
All Enterprise Architecture Modeling (EAM) approaches revolve around the use of multiple, inter-related views to describe the properties of a system and its surrounding environment - that is, they are multi-view specification (MVS) approaches. However, there is still little consensus on how such modeling environments should be realized and on the pros and cons of the different fundamental design choices involved in building them. In this paper we identify the different design choices put forward in the literature, evaluate their mutual compatibility, and discuss the extent to which they scale up to large enterprise systems. Finally we present some additional choices and outline some of the key features that future multi-view modeling environments should ideally support.
Article
One of the most important features of enterprise architecture modeling approaches is the set of views and viewpoints they use to convey the properties of enterprise systems - that is, their viewpoint framework. All mainstream approaches such as Zachman, RM-ODP, TOGAF and Archimate use the notion of independent 'concerns' or dimensions to organize their views and viewpoints, but often do so in ways that are inconsistent and overly complex. In this paper we compare the viewpoint framework of one well known Enterprise Architecture Modeling approach, Archimate, to the Orthographic Modeling approach which was developed to apply the idea of dimension-based view identification and selection in a pure, comprehensive form. After identifying weakness in Archimate's viewpoint framework from an orthographic modeling perspective we suggest how the former can be realized by, and adapted for, the latter.
Conference Paper
ATL (Atlas Transformation Language) has been defined to perform general transformations within the MDA framework (Model Driven Architecture) recently proposed by the OMG. We are currently learning from the first applications developed with this language. The example used here is a transformation from XSLT to XQuery. Since these are two standard notations that dont pertain to the MDA space, we first need to provide some justification about this work. The global organization of technological spaces presented at the beginning of the paper is intended to answer this first question. Furthermore we propose the original characterization of a technological space as a framework based on a given unique meta-model. After having briefly presented the ATL framework, we describe the XSLT2XQuery transformation. We may then draw several conclusions from this experiment, suggesting possible improvements to general model transformation frameworks. ATL is still evolving since it is supposed to match the forthcoming QVT/RFP recommendation when it is ready. As a consequence, the concrete expression of the transformation presented in this paper may change, but the general ideas should remain stable.
Article
As practical tools for disciplined multi-level modeling have begun to mature, the problem of supporting simple and efficient transformations to-and-from multi-level models to facilitate interoperability has assumed growing importance. The challenge is not only to support efficient transformations between multi-level models, but also between multi-level and two-level model content represented in traditional modeling infrastructures such as the UML and programming languages. Multi-level model content can already be accessed by traditional transformation languages such as ATL and QVT, but in a way that is blind to the ontological classification information they contain. In this paper, we present an approach for making rule-based transformation languages “multi-level aware” so that the semantics of ontological classification as well as linguistic classification can be exploited when writing transformations.
Conference Paper
Model-Driven Engineering provides an abstract representation of systems through the use of models and views. For complex systems, however, finding a single model and a single view to represent all relevant information of the system is infeasible. Specialized models for specific subsystems, domains or abstractions are more concise and thus more efficient than monolithic models. Furthermore, different tasks and concerns often require different views on the same model. Sustaining the consistency between different views and models is hard, especially if new models and views are dynamically added. In this paper, we present an approach that supports flexible views that may involve multiple models conforming to different metamodels. The approach is based on Orthographic Software Modeling and synchronizes individual instances using model transformations. These transformations are generated from view type definitions, metamodel correspondence rules and invariants, which are defined in a domain-specific language. We illustrate our approach with an application that combines component-based architectures with object-oriented source code and class diagrams.
Conference Paper
Orthographic Software Modeling (OSM) is a view-centric software engineering approach that aims to leverage the orthographic projection metaphor used in the visualization of physical objects to visualize software systems. Although the general concept of OSM does not prescribe specific sets of views, a concrete OSM environment has to be specific about the particular views to be used in a particular project. At the University of Mannheim we are developing a prototype OSM environment, nAOMi, that supports the views defined by the KobrA 2.0 method, a version of KobrA adapted for OSM. In this paper we provide an overview of the KobrA 2.0 metamodel underpinning nAOMi and give a small example of its use to model a software system.
Article
Domain-Specific Modeling Languages (DSMLs) have received great attention in recent years and are expected to play a big role in the future of software engineering as processes become more view-centric. However, they are a “two-edged sword”. While they provide strong support for communication within communities, allowing experts to express themselves using concepts tailored to their exact needs, they are a poor vehicle for communication across communities because of their lack of common, transcending concepts. In contrast, General-Purpose Modeling Languages (GPMLs) have the opposite problem — they are poor at the former but good at the latter. The value of models in software engineering would therefore be significantly boosted if the advantages of DSMLs and GPMLs could be combined and models could be viewed in a domain-specific or general-purpose way depending on the needs of the user. In this paper we present an approach for achieving such a synergy based on the orthogonal classification architecture. In this architecture model elements have two classifiers: a linguistic one representing their “general-purpose” and an ontological one representing their “domain-specific” type. By associating visualization symbols with both classifiers it is possible to support two concrete syntaxes at the same time and allow the domain-specific and general-purpose notation to support each other — that is, to form a symbiotic relationship.
Article
A database view is a portion of the data structured in a way suitable to a specific application. Updates on views must be translated into updates on the underlying database. This paper studies the translation process in the relational model. The procedure is as follows: first, a “complete” set of updates is defined such that together with every update the set contains a “return” update, that is, one that brings the view back to the original state; given two updates in the set, their composition is also in the set. To translate a complete set, we define a mapping called a “translator,” that associates with each view update a unique database update called a “translation.” The constraint on a translation is to take the database to a state mapping onto the updated view. The constraint on the translator is to be a morphism. We propose a method for defining translators. Together with the user-defined view, we define a “complementary” view such that the database could be computed from the view and its complement. We show that a view can have many different complements and that the choice of a complement determines an update policy. Thus, we fix a view complement and we define the translation of a given view update in such a way that the complement remains invariant (“translation under constant complement”). The main result of the paper states that, given a complete set U of view updates, U has a translator if and only if U is translatable under constant complement.
Archimate 2. 0 specification: The open group.
  • M Iacob
  • D H Jonkers
  • M Lankhorst
  • E Proper
  • D D Quartel
Deep, seamless, multi-format, multi-notation definition and use of domain-specific languages
  • R Gerbig
Providing OLAP to User-Analysts: An IT Mandate. Codd & Date
  • E Codd
Meta Object Facility (MOF) 2. 0 Query/View/Transformation Specification, Version 1. 1, Object Management Group Std., Rev. 1. 1
  • Meta Object
Effective Devops: Building a Culture of Collaboration, Affinity, and Tooling at Scale
  • K Davis
  • Jennifer Daniels
A unified framework for multi-level modeling
  • B Kennel