Elsevier

Information Systems

Volume 101, November 2021, 101440
Information Systems

A deep view-point language and framework for projective modeling

https://doi.org/10.1016/j.is.2019.101440Get rights and content

Abstract

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.

Introduction

Due to their complexity and size, enterprise architectures can only be effectively modeled using collections of intertwined views, each describing a system from distinct perspectives or viewpoints [1], [2], [3]. However, there is little consensus on what these views and perspectives should be and what kinds of properties the associated viewpoint frameworks should support. In fact, contemporary Enterprise Architecture Modeling (EAM) approaches differ quite considerably in terms of the fundamental relationships they assume between the views and the system under description, the way in which inter-view consistency is handled and how the focus of views is characterized, with significant consequences for their flexibility and/or coherence.

In a previous article [4], the authors of this paper identified seven fundamental design choices involved in the realization of EAM viewpoint frameworks based on existing literature and approaches/tools. The paper also identified the combination of choices which appear to offer the best platform for EAM in the future — namely, a rigorous framework, based on an essential underlying model which supports nestable (i.e. both abstract and concrete) views that are projective, component-centric and related by implicit and intentional correspondences. At that time no viewpoint framework possessed this combination of characteristics. In this paper we present a new viewpoint language and framework that has been specially designed to support the proposed combination of properties in a clean, efficient and uniform way. More specifically, we describe the conceptual foundations of the approach and illustrate the basic elements of a prototype environment to support it known as doreen.

Although the framework was originally conceived to support a specific view-based modeling methodology called Orthographic Software Modeling (OSM) [5], it is not restricted to this approach and can be used to support any approach based on projective views. Nor is it tied to any specific modeling language. The framework can just as easily be used with a general purpose modeling language such as the UML as with an EAM language such as Archimate [6] or RM-ODP [7]. However, some authors have pointed out that multi-level modeling languages are better suited to the EAM domain than traditional “two-level languages” such as the UML [8]. Not only do they simplify the definition and use of domain-specific modeling languages, they are able to describe instance-oriented run-time information just as easily and efficiently as type-oriented design time information within a single coherent formalism. They are therefore well suited to supporting views over an enterprise system’s full life-cycle which is an important requirement on EAM frameworks. The approach presented in this paper therefore uses, and is integrated with, a specific form of multi-level modeling known as deep modeling.

The paper is an extended version of a paper published at the EDOC 2017 conference [9]. It provides enhanced descriptions of the view type and SUM definition languages, including the underlying deep modeling environment and deep transformation language, as well as an enhanced discussion of the approach’s strengths and weaknesses. In the following section we present the background to the approach, which includes the motivation for the design choices identified above as well as an overview of the chosen deep modeling approach. The next three section then describe the three key elements of the framework: Section 3 explains how the Single Underlying Model (SUM) that serves as the source of content for the views is structured while Sections 4 View types, 5 View instances describe the languages and projection artifacts used to define and populate views at the type and instance levels respectively. Finally, Section 6 discusses the pros and cons of the approach while Section 7 concludes with some closing remarks.

Section snippets

Background

The use of the terms “synthetic” and “projective” to characterize the two basic strategies for supporting multiple views of a system was popularized by the IEEE1471/ISO42010 standard for describing the architecture of software-intensive systems [10], [11]. This standard also introduces the distinction between viewpoints and views where the former refers to the languages (including notations, models or product types) to be used to describe the latter. In short, viewpoints are characterized as

Single underlying model

The basic idea behind projective views is that they display content that it automatically “projected” from a single underlying source of information according to a well defined transformation. In order to emphasize the abstract nature of this information (i.e. that it is not just code, or some other low-level artifact) this underlying source of information is referred to as the Single Underlying Model (SUM). The basic relationship between the SUM and a view is shown in Fig. 5. This shows that a

View types

While there is never more than one SUM, there can be many view types and each view type can have many instances. View types defines the “view language” used to represent content in view instances as well as the projection rules used to map the SUM language concepts to view language concepts and vice versa. This section explains the principles behind the view language and the projection rules.

View instances

The artifacts presented in the previous section are defined when the doreen environment is configured to support a particular approach or methodology. It is generic to the information belonging to a specific system of interest and thus can be reused for different projects to describe different systems. The presented languages for the SUM and the view types define the kinds of views that can be used to described the system and how they are related to the SUM. To specify a specific system using

Discussion

Although the example used to illustrate our approach in the previous sections is very simple, it is sufficient to demonstrate its novel features and key ideas. Like all approaches involving tradeoffs, however, it has both strengths and weaknesses. These are discussed in this section.

Scalability. First and foremost, since it is inherently projective, the approach addresses arguably the biggest drawback of synthetic, view-based approaches — namely, the exponential explosion in the number of

Conclusion

In this paper we have presented an approach and a language for addressing two of the core requirements, identified in [4], for an ideal view-based EAM environment — projective views generated automatically from a SUM and component-based views whose content is determined by both their subject (i.e. what you are looking at) and their view type (i.e. where you are looking from). In particular, we presented a new conceptual meta-model that provides the necessary foundation through the extensive use

Declaration of Competing Interest

The authors declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper.

References (37)

  • ZachmanJ.A.

    A framework for information systems architecture

    IBM Syst. J.

    (1987)
  • LankhorstM.

    Enterprise architecture at work

  • LiningtonP.F. et al.

    Building Enterprise Systems with ODP: an Introduction to Open Distributed Processing

    (2011)
  • AtkinsonC. et al.

    Fundamental realization strategies for multi-view specification environments

  • AtkinsonC. et al.

    Orthographic software modeling: A practical approach to view-based development

  • IacobM. et al.

    ArchiMate 2.0 Specification: The Open Group

    (2012)
  • ISO/IECM.

    RM-ODP. Reference model for open distributed processing

    (1997)
  • FrankU.

    Multilevel modeling: Toward a new paradigm of conceptual modeling and information systems design

    Bus. Inf. Syst. Eng.

    (2014)
  • AtkinsonC. et al.

    A deep view-point language for projective modeling

  • IEEE Architecture Working GroupC.

    IEEE Std 1471–2000, Recommended Practice for Architectural Description of Software-Intensive SystemsTech. report

    (2000)
  • ISO/IEC/IEEEC.

    Systems and software engineering – Architecture description

    (2011)
  • C. Atkinson, C. Tunjic, Towards orthographic viewpoints for enterprise architecture modeling, in: 2014 IEEE 18th...
  • AtkinsonC. et al.

    The essence of multilevel metamodeling

  • AtkinsonC. et al.

    Rearchitecting the UML infrastructure

    ACM Trans. Model. Comput. Simul.

    (2002)
  • KühneT.

    Matters of (meta-) modeling

    Softw. Syst. Model.

    (2006)
  • R. Gerbig, Deep, seamless, multi-format, multi-notation definition and use of domain-specific languages (Ph.D. thesis),...
  • KennelB.

    A Unified Framework for Multi-Level Modeling

    (2012)
  • C. Atkinson, R. Gerbig, Melanie: multi-level modeling and ontology engineering environment, in: Proceedings of the 2nd...
  • Cited by (2)

    View full text