Model-driven engineering

Last updated November 27, 2023

Model-driven engineering (MDE) is a software development methodology that focuses on creating and exploiting domain models, which are conceptual models of all the topics related to a specific problem. Hence, it highlights and aims at abstract representations of the knowledge and activities that govern a particular application domain, rather than the computing (i.e. algorithmic) concepts.

Overview

The MDE approach is meant to increase productivity by maximizing compatibility between systems (via reuse of standardized models), simplifying the process of design (via models of recurring design patterns in the application domain), and promoting communication between individuals and teams working on the system (via a standardization of the terminology and the best practices used in the application domain). For instance, in model-driven development, technical artifacts such as source code, documentation, tests, and more are generated algorithmically from a domain model.^[2]

A modeling paradigm for MDE is considered effective if its models make sense from the point of view of a user that is familiar with the domain, and if they can serve as a basis for implementing systems. The models are developed through extensive communication among product managers, designers, developers and users of the application domain. As the models approach completion, they enable the development of software and systems.

Some of the better known MDE initiatives are:

The Object Management Group (OMG) initiative Model-Driven Architecture (MDA) which is leveraged by several of their standards such as Meta-Object Facility, XMI, CWM, CORBA, Unified Modeling Language (to be more precise, the OMG currently promotes the use of a subset of UML called fUML together with its action language, ALF, for model-driven architecture; a former approach relied on Executable UML and OCL, instead), and QVT.^[3]
The Eclipse "eco-system" of programming and modelling tools represented in general terms by the (Eclipse Modeling Framework). This framework allows the creation of tools implementing the MDA standards of the OMG; but, it is also possible to use it to implement other modeling-related tools.

History

The first tools to support MDE were the Computer-Aided Software Engineering (CASE) tools developed in the 1980s. Companies like Integrated Development Environments (IDE - StP), Higher Order Software (now Hamilton Technologies, Inc., HTI), Cadre Technologies, Bachman Information Systems, and Logic Works (BP-Win and ER-Win) were pioneers in the field.

The US government got involved in the modeling definitions creating the IDEF specifications. With several variations of the modeling definitions (see Booch, Rumbaugh, Jacobson, Gane and Sarson, Harel, Shlaer and Mellor, and others) they were eventually joined creating the Unified Modeling Language (UML). Rational Rose, a product for UML implementation, was done by Rational Corporation (Booch) responding automation yield higher levels of abstraction in software development. This abstraction promotes simpler models with a greater focus on problem space. Combined with executable semantics this elevates the total level of automation possible. The Object Management Group (OMG) has developed a set of standards called model-driven architecture (MDA), building a foundation for this advanced architecture-focused approach.

Advantages

According to Douglas C. Schmidt, model-driven engineering technologies offer a promising approach to address the inability of third-generation languages to alleviate the complexity of platforms and express domain concepts effectively.^[4]

Tools

Notable software tools for model-driven engineering include:

AADL from Carnegie-Mellon Software Engineering Institute
Acceleo an open source code generator from Obeo
Actifsource
AgileUML an open source MDE toolset from AgileMDE Ltd
ATLAS Transformation Language or ATL, a model transformation language from Obeo
DUALLy, an MDE framework to create interoperability
Eclipse Modeling Framework (EMF)
Enterprise Architect from Sparx Systems
eTrice an Open Source implementation of the Real-Time Object-Oriented Modeling standard
Generic Eclipse Modeling System (GEMS)
GeneXus a Knowledge-based, declarative, multi-platform, multi-language development solution
Graphical Modeling Framework (GMF)
JetBrains MPS, a metaprogramming system from JetBrains
MagicDraw from No Magic Inc
MERODE JMermaid from KU Leuven (educational)
MetaEdit+ from MetaCase
ModelCenter from Phoenix Integration
Open ModelSphere
OptimalJ from Compuware
PREEvision from Vector Informatik
Rhapsody from IBM
RISE Editor from RISE to Bloome Software
PowerDesigner from SAP
Simulink from MathWorks
Software Ideas Modeler from Dusan Rodina
Sirius an Eclipse Open Source project to create custom graphical modeling workbenches
Together Architect from Borland
Umbrello by KDE
Umple from the University of Ottawa
Uniface from Compuware
YAKINDU Statechart Tools open source tool build on top of Eclipse

Related Research Articles

The unified modeling language (UML) is a general-purpose visual modeling language that is intended to provide a standard way to visualize the design of a system.

A platform-independent model (PIM) in software engineering is a model of a software system or business system that is independent of the specific technological platform used to implement it.

A platform-specific model is a model of a software or business system that is linked to a specific technological platform. Platform-specific models are indispensable for the actual implementation of a system.

Model Driven Architecture (MDA) is a software design approach for the development of software systems. It provides a set of guidelines for the structuring of specifications, which are expressed as models. Model Driven Architecture is a kind of domain engineering, and supports model-driven engineering of software systems. It was launched by the Object Management Group (OMG) in 2001.

The Object Constraint Language (OCL) is a declarative language describing rules applying to Unified Modeling Language (UML) models developed at IBM and is now part of the UML standard. Initially, OCL was merely a formal specification language extension for UML. OCL may now be used with any Meta-Object Facility (MOF) Object Management Group (OMG) meta-model, including UML. The Object Constraint Language is a precise text language that provides constraint and object query expressions on any MOF model or meta-model that cannot otherwise be expressed by diagrammatic notation. OCL is a key component of the new OMG standard recommendation for transforming models, the Queries/Views/Transformations (QVT) specification.

Round-trip engineering (RTE) in the context of model-driven architecture is a functionality of software development tools that synchronizes two or more related software artifacts, such as, source code, models, configuration files, documentation, etc. between each other. The need for round-trip engineering arises when the same information is present in multiple artifacts and when an inconsistency may arise in case some artifacts are updated. For example, some piece of information was added to/changed in only one artifact and, as a result, it became missing in/inconsistent with the other artifacts.

<span class="mw-page-title-main">Metamodeling</span> Concept of software engineering

A metamodel is a model of a model, and metamodeling is the process of generating such metamodels. Thus metamodeling or meta-modeling is the analysis, construction and development of the frames, rules, constraints, models and theories applicable and useful for modeling a predefined class of problems. As its name implies, this concept applies the notions of meta- and modeling in software engineering and systems engineering. Metamodels are of many types and have diverse applications.

A UML tool is a software application that supports some or all of the notation and semantics associated with the Unified Modeling Language (UML), which is the industry standard general-purpose modeling language for software engineering.

Object-oriented analysis and design (OOAD) is a technical approach for analyzing and designing an application, system, or business by applying object-oriented programming, as well as using visual modeling throughout the software development process to guide stakeholder communication and product quality.

VIATRA is an open-source model transformation framework based on the Eclipse Modeling Framework (EMF) and hosted by the Eclipse Foundation.

ATL is a model transformation language and toolkit developed and maintained by OBEO and AtlanMod. It was initiated by the AtlanMod team. In the field of Model-Driven Engineering (MDE), ATL provides ways to produce a set of target models from a set of source models.

QVT (Query/View/Transformation) is a standard set of languages for model transformation defined by the Object Management Group.

A model transformation language in systems and software engineering is a language intended specifically for model transformation.

Executable UML is both a software development method and a highly abstract software language. It was described for the first time in 2002 in the book "Executable UML: A Foundation for Model-Driven Architecture". The language "combines a subset of the UML graphical notation with executable semantics and timing rules." The Executable UML method is the successor to the Shlaer–Mellor method.

The UML profile for Enterprise Distributed Object Computing (EDOC) is a standard of the Object Management Group in support of open distributed computing using model-driven architecture and service-oriented architecture. Its aim is to simplify the development of component based (EDOC) systems by providing a UML-based modeling framework conforming to the MDA of the OMG.

Rational Software Modeler (RSM), made by IBM's Rational Software division, is a Unified Modeling Language (UML) 2.0-based visual modeling and design tool. Rational Software Modeler is based on the Eclipse open-source software framework and is used for visual modeling and model-driven development (MDD) with UML for creating applications and web services. IBM ceased marketing Rational Software Modeler in 2010 and ended support for it in 2015. Much of the same functionality is now available through Rational Software Architect.

Domain-driven design (DDD) is a major software design approach, focusing on modeling software to match a domain according to input from that domain's experts.

The first version of the Enterprise Collaboration Architecture (ECA) has been published by the Object Management Group (OMG) in 2001. The vision of the (ECA) is to simplify the development of component based and services oriented systems by providing a modeling framework aligned with the model-driven architecture (MDA) of the Object Management Group (OMG).

An Executable Architecture (EA), in general, is the description of a system architecture in a formalnotation together with the tools that allow the automatic or semi-automatic generation of artifacts from that notation and which are used in the analysis, refinement, and/or the implementation of the architecture described.

References

↑ "8 Reasons Why Model-Driven Approaches (will) Fail". InfoQ. Retrieved 2023-07-26.
↑ Flatt, Amelie; Langner, Arne; Leps, Olof (2022). Model-Driven Development of Akoma Ntoso Application Profiles - A Conceptual Framework for Model-Based Generation of XML Subschemas (1st ed.). Heidelberg: Sprinter Nature. ISBN 978-3-031-14131-7.
↑ Object Management Group (2006-05-24). "OMG Trademarks" . Retrieved 2008-02-26.
↑ Schmidt, D.C. (February 2006). "Model-Driven Engineering" (PDF). IEEE Computer . 39 (2). doi:10.1109/MC.2006.58. S2CID 10006139. Archived from the original (PDF) on 2006-09-09. Retrieved 2006-05-16., "A promising approach to address platform complexity—and the inability of third-generation languages to alleviate this complexity and express domain concepts effectively—is to develop Model-Driven Engineering (MDE) technologies..."

External links

Model-Driven Architecture: Vision, Standards And Emerging Technologies at omg.org

This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.

[1] "8 Reasons Why Model-Driven Approaches (will) Fail". InfoQ. Retrieved 2023-07-26.

[2] Flatt, Amelie; Langner, Arne; Leps, Olof (2022). Model-Driven Development of Akoma Ntoso Application Profiles - A Conceptual Framework for Model-Based Generation of XML Subschemas (1st ed.). Heidelberg: Sprinter Nature. ISBN 978-3-031-14131-7.

[omgtm-3] Object Management Group (2006-05-24). "OMG Trademarks" . Retrieved 2008-02-26.

[4] Schmidt, D.C. (February 2006). "Model-Driven Engineering" (PDF). IEEE Computer . 39 (2). doi:10.1109/MC.2006.58. S2CID 10006139. Archived from the original (PDF) on 2006-09-09. Retrieved 2006-05-16., "A promising approach to address platform complexity—and the inability of third-generation languages to alleviate this complexity and express domain concepts effectively—is to develop Model-Driven Engineering (MDE) technologies..."

[1]

[2]

[3]

[4]