PaperlayerView exact revision on arXiv

Source-linked AI summary

Model-Driven Development of Complex Software: A Research Roadmap

Robert France, Bernhard Rumpe

arXiv:1409.6620v1cs.SE

TL;DR

MDE seeks to manage increasing software complexity by systematically connecting abstract models with concrete implementations. This paper surveys the technical and social challenges of that vision, including modeling languages, composition, management, analysis, and runtime use. It concludes that the full vision is unlikely in the near to medium term, but progressively better approximations can deepen understanding and potentially yield order-of-magnitude productivity and quality improvements.

  • Problem

    MDE must address complex, interrelated technical and social problems while bridging software's problem and implementation domains.

  • Method

    The paper surveys major MDE challenges and develops a vision of environments for creating, transforming, analyzing, synchronizing, and managing models and runtime artifacts.

  • Results

    The paper presents an ambitious MDE-environment vision that could conceivably produce order-of-magnitude improvements in software development productivity and quality.

  • Takeaways & Limitations

    Progressively closer approximations to the MDE vision can increasingly reduce the effort required to develop complex software and provide a reference for assessing research progress.

  • Takeaways & Limitations

    Full realization is unlikely in the near to medium term because MDE is a wicked problem, and current limitations reflect incomplete understanding of software modeling.

Abstract

from arXiv · show

The term Model-Driven Engineering (MDE) is typically used to describe software development approaches in which abstract models of software systems are created and systematically transformed to concrete implementations. In this paper we give an overview of current research in MDE and discuss some of the major challenges that must be tackled in order to realize the MDE vision of software development. We argue that full realizations of the MDE vision may not be possible in the near to medium-term primarily because of the wicked problems involved. On the other hand, attempting to realize the vision will provide insights that can be used to significantly reduce the gap between evolving software complexity and the technologies used to manage complexity.

1. Introduction

MDE addresses growing software complexity by using models and automated transformations to reduce the gap between problem-level abstractions and implementations. The paper surveys technical and social challenges, including runtime adaptation, while framing the broader vision as a wicked problem.

  • Complex software must operate across diverse distributed and embedded devices, communicate through varied paradigms, adapt dynamically, and remain dependable.
  • MDE uses models at multiple abstraction levels and perspectives, together with automated model transformation and analysis, to reduce the problem-implementation gap.
  • Current MDE work mainly generates implementation and deployment artifacts from detailed design models, while runtime modeling is emerging for monitoring and managing executing software.
  • Runtime models are envisioned as interfaces through which human or software change agents can adapt, repair, extend, or retrofit executing software in a controlled manner.
  • Realizing the broad MDE vision is a wicked problem because it combines interrelated social and technical difficulties whose solutions are costly and may generate further problems.
  • The paper discusses major technical challenges and social challenges involving the identification and use of high-quality modeling experience.

2. The Value of Modeling

The paper treats software development as an inherently modeling-based activity and asks how modeling can tame the problem-implementation gap. It distinguishes development and runtime models while proposing research on models as tools for managing and changing running systems.

  • A model is an abstraction of some aspect of a system, created for purposes such as human understanding or mechanical analysis.
  • MDE encompasses research using software models beyond UML, including formal specifications, control-system models, specialized property analyses, and software-risk models.
  • Development models represent software above code level, whereas runtime models abstract aspects of executing systems and support dynamic adaptation.
  • As MDE matures, development models may serve as runtime models, while runtime models may support software evolution and thereby act as development models.
  • Because software development involves creating and evolving models, the central research question is how modeling can tame the problem-implementation gap.
  • The paper proposes runtime-model research on cost-effective management of executing software and controlled changes mediated between running systems and human or software agents.

3. MDE Research Concerns

MDE research addresses the problem-implementation gap through models, transformations, and technologies that raise development abstraction levels. Its concerns span modeling languages, multiple viewpoints, model manipulation, reuse, and integration with related software-engineering research, while remaining a wicked problem requiring industrial feedback.

  • MDE develops techniques and tools to narrow the problem-implementation gap between problem-level abstractions and software implementations.Using methods relying almost exclusively on human effort introduces significant accidental complexities.
  • Raising implementation abstraction levels can improve productivity and quality, but may enable more complex software systems that renew development concerns.
  • MDE research should develop domain-specific environments whose languages and tools encode knowledge about recurring gap-bridging processes.
  • MDE must evolve progressively because the full vision may be unattainable, while industrial participation supplies feedback about development problems.
  • Major challenge categories include modeling languages, separation of concerns, and model manipulation and management.Model manipulation includes transformations, traceability, viewpoint consistency, version tracking, and runtime model use.
  • MDE connects with requirements, architecture, formal specification, systematic reuse, and related software-engineering research communities.Formal specification techniques are relevant because analyzable models require formally defined semantics.

4. Major Model Driven Engineering Initiatives

Major MDE initiatives pursue model-based abstraction, domain-specific development environments, and systematic transformation toward implementations. They differ in standards, viewpoints, reusable experience, and adaptive tooling, while sharing foundations such as MOF-based language engineering.

  • MDA provides an industry-driven framework of standards for integrating infrastructures, generating application artifacts, and separating computation-independent, platform-independent, and platform-specific views.Its pillars are MOF, UML, and QVT.
  • Software Factories provide domain-specific development environments that associate reusable patterns, templates, guidelines, and transformations with lifecycle viewpoints.This supports context-based validation, guidance, and enactment.
  • A Software Factory realization includes a schema, a reusable template, and an extensible environment configured to produce environments for product families.
  • Xactium and Vanderbilt’s Generic Modeling Environment support engineering MOF-based domain-specific modeling languages.Xactium additionally uses reflection so environments can adapt when their underlying modeling languages change.
  • Model Integrated Computing began with model-driven development support for distributed embedded real-time systems and is being aligned with MDA within the OMG.

5. Modeling Language Challenges

MDE modeling-language research must support problem-level abstractions, formal manipulation, and language extension while controlling the complexity of general-purpose and domain-specific approaches. The UML experience exposes difficulties in semantic extension, metamodel evolution, and distilling reusable modeling concepts.

  • The abstraction challenge asks how problem-level abstractions can become first-class modeling elements.
  • The formality challenge concerns which language semantics must be formalized and how to formalize them for manipulation.
  • MDE pursues abstraction through extensible general-purpose languages or domain-specific languages engineered with meta-metamodeling mechanisms.The two schools are not mutually exclusive and may converge through shared insights.
  • Extensible general-purpose languages need abstractions above code level and mechanisms for domain-specific specialization, but identifying a small extensible core remains difficult.The paper attributes this difficulty partly to limited analyzable modeling experience.
  • Complex UML metamodels hinder understanding, tool and transformation development, and manual evolution; view-extraction and consistency-checking tools can reduce these difficulties.
  • UML semantic variation points leave modelers responsible for defining and communicating extension semantics, complicating reliable model interpretation.
  • UML profiles support domain-specific variants but cannot currently define extension semantics precisely enough for formal model manipulations in MDE environments.

6. Supporting Separation of Design Concerns

MDE separation-of-concerns techniques use multiple design views to expose interactions among pervasive, interdependent concerns, but composition and integration remain difficult. AOM can support integrated views, conflict analysis, and implementation generation, while semantic matching and verifiable composition remain open challenges.

  • Crosscutting dependability concerns interact in ways that can produce undesirable emergent behavior and complicate design balancing.
  • Concern-specific viewpoints help developers describe how a concern is addressed across abstraction levels, such as access control security viewpoints.
  • Aspect-Oriented Modeling: AOM approaches represent concerns as views and compose aspect and primary models into integrated design views.
  • Aspect-Oriented Modeling: Integrated AOM views support understanding cross-view interactions, identifying conflicts and emergent behaviors, and generating non-aspect-oriented implementations.
  • Composition Challenges: Syntactic matching enables automated composition but can fail when syntax does not reflect conceptual correspondence, motivating semantic constraints and behavioral specifications.
  • Composition Challenges: Verifiable composition requires checking whether specified properties are established or preserved, although such checks cannot be completely automated.
  • Integration Challenges: Integrating and evolving multiple interrelated model views requires infrastructure that current development processes may lack.

7. Manipulating Models

Manipulating models is central to the MDE vision, but current tools offer only basic editing, consistency checking, collaboration, and transformation support. Research therefore targets transformation analysis, model relationships, repositories, metamodel semantics, and controlled runtime change.

  • Current MDE environments provide basic model storage and manipulation, limited transformation support, and only partial syntactic consistency and team-development facilities.
  • Model Transformations: Operational transformations map source models to target models, while synchronization transformations maintain specified relationships across model sets.
  • Transformation Analysis: Transformation research must address consistency across views, testing, semantic analysis, and difficult coverage and oracle definitions for complex models.
  • Model-to-Code Integration: Model-to-code transformations have limited support for integrating generated code with handcrafted or legacy code, especially when architectural compatibility is unclear.
  • Model Management: Manually tracking versioning, refinement, realization, and dependency relationships among models adds accidental complexity that current tools do not adequately manage.
  • Repositories and Metamodels: Repositories should support heterogeneous tools, audit model manipulations, and extract audit information to establish, update, or remove model relationships.
  • Repositories and Metamodels: Metamodels need to represent semantic as well as syntactic language aspects so model-management tools can support richer manipulations.
  • Runtime Models: Runtime models could support observation, monitoring, adaptation, correction, and feature introduction, but runtime modeling and controlled change mechanisms remain immature and challenging.

8. Conclusions

The paper presents an ambitious MDE environment intended to reduce accidental complexity through explicit, manipulable models and connected repositories. Full realization is a wicked problem unlikely in the near to medium term, but incremental approximations can guide progress and improve development.

  • Explicit models and tools for manipulating, analyzing, and managing model relationships can reduce cognitive burden and accidental complexity.
  • Model creation remains an art, so faulty or convoluted models and messy descriptions can introduce accidental complexity.
  • Learning and using modeling languages and MDE tools will always involve some accidental complexity.
  • MDE technologies should leverage experience from successful and failed applications to reduce the accidental complexities of earlier approaches.
  • MDE Vision: The envisioned MDE environment could yield order-of-magnitude improvements in software development productivity and quality if realized, while serving as a reference for assessing progress.
  • MDE Vision: The vision includes domain-specific application development environments whose tools create, evolve, analyze, and transform models, with repositories tracking model relationships and manipulation metadata.
  • MDE Vision: The envisioned environments also support round-trip engineering, synchronization across abstraction levels, legacy-code integration, and runtime-model generation and use.
  • Limitations: Because realizing the vision is a wicked problem, order-of-magnitude improvements are not likely in the near to medium term absent major new insights.
Loading 1409.6620v1…