scholarly journals Challenges and directions in formalizing the semantics of modeling languages

2011 ◽  
Vol 8 (2) ◽  
pp. 225-253 ◽  
Author(s):  
Barrett Bryant ◽  
Jeff Gray ◽  
Marjan Mernik ◽  
Peter Clarke ◽  
Robert France ◽  
...  
Keyword(s):  
Software Engineering ◽  
Programming Languages ◽  
Modeling Language ◽  
Modeling Languages ◽  
Model Driven Engineering ◽  
Modeling Tools ◽  
Model Driven ◽  
Model Based ◽  
Language Specification

Developing software from models is a growing practice and there exist many model-based tools (e.g., editors, interpreters, debuggers, and simulators) for supporting model-driven engineering. Even though these tools facilitate the automation of software engineering tasks and activities, such tools are typically engineered manually. However, many of these tools have a common semantic foundation centered around an underlying modeling language, which would make it possible to automate their development if the modeling language specification were formalized. Even though there has been much work in formalizing programming languages, with many successful tools constructed using such formalisms, there has been little work in formalizing modeling languages for the purpose of automation. This paper discusses possible semantics-based approaches for the formalization of modeling languages and describes how this formalism may be used to automate the construction of modeling tools.

An overview of the unified modeling language and diagrammatic modeling language design in software engineering

2003 ◽  
Vol 11 (2-3) ◽  
pp. 151-159 ◽  
Author(s):  
M. Naci Akkøk
Keyword(s):  
Software Engineering ◽  
Unified Modeling Language ◽  
Conceptual Modeling ◽  
Language Design ◽  
Modeling Language ◽  
Modeling Languages ◽  
Modeling Tools ◽  
Short Account ◽  
Unified Modeling ◽  
Body Of Knowledge

The need to manage the immense complexity in software engineering makes tools and methods essential, and requires that they be designed in accordance with well-defined principles. Surprisingly, there is yet no explicit body of knowledge for designing diagrammatic modeling languages (DMLs), despite the fact that they are used extensively as the primary conceptual modeling tools in software engineering. This paper provides an overview of the new and growing field of DML design that aims at compiling such a body of knowledge. The paper starts with relevant definitions and a brief introduction of the current de-facto standard DML of software engineering called the Unified Modeling Language (UML), and offers a short account of efforts and directions in DML design.

Umple

2021 ◽  
pp. 1-25
Author(s):  
Timothy C. Lethbridge ◽  
Abdulaziz Algablan
Keyword(s):  
Code Generation ◽  
Product Line ◽  
Agile Development ◽  
Modeling Language ◽  
Modeling Languages ◽  
State Machines ◽  
Model Driven Engineering ◽  
Model Driven ◽  
Target Languages ◽  
Line Engineering

Umple is a technology designed to provide the benefits of model-driven engineering in a usable way. It is a textual modeling language, allowing agile developers to quickly incorporate state machines, associations, and many other modeling features into their codebase, with comprehensive code generation for multiple target languages. This significantly reduces the amount of code developers have to write. At the same time, Umple's always-on diagram generation and analysis allows quick understanding of model-driven projects and discovery of their defects. The chapter demonstrates the benefits of textual modeling languages and discusses multiple ways that Umple can help bring modeling to the agile development community, including its support for product-line engineering. Umple is in use worldwide, with the online version hosting over 200,000 user sessions a year.

The Contribution of MDA in Software-Defined Network

2021 ◽  
pp. 118-134
Author(s):  
Adra Hammoud ◽  
Mohamed Lahmer ◽  
Samir Mbarki ◽  
Fatima Sifou
Keyword(s):  
Software Defined Networking ◽  
Modeling Language ◽  
Software Defined Network ◽  
Model Driven Engineering ◽  
Model Driven ◽  
Level Of Abstraction ◽  
Comprehensive Survey ◽  
Basic Concepts ◽  
Control And Management ◽  
The Way

Software-defined networking is changing the way we design and manage networks. This prominent paradigm based on the separation of control and management plane is highly heterogeneous with different devices from various technologies and leads to an incredible growing of materials. As SDN expands in size of devices and complexity, it faces greater administrative and management challenges. The paradigm of MDA was introduced using NETCONF/YANG as a way to model in order to deal with these management challenges and soften the development of SDN applications. The researchers joined the MDA and its related concepts as model-driven engineering to SDN to implement a platform called model-driven networking increasing the level of abstraction on development. This chapter presents a comprehensive survey of the research relating to MDN paradigm. It starts by introducing the basic concepts of SDN. Next, it presents the concepts related to MDA, and the YANG which is a modeling language. Last, it highlights the studies introducing the MDN paradigm and its benefits in SDN applications.

On Developing Hybrid Modeling Methods using Metamodeling Platforms

2015 ◽  
Vol 6 (1) ◽  
pp. 47-66
Author(s):  
Srdjan Zivkovic ◽  
Krzystof Miksa ◽  
Harald Kühn
Keyword(s):  
Complex Systems ◽  
Hybrid Modeling ◽  
Modeling Languages ◽  
Modeling Tools ◽  
Analysis And Design ◽  
Domain Specific ◽  
Modeling Methods ◽  
Model Based ◽  
Domain Specific Modeling ◽  
Specific Modeling

It has been acknowledged that model-based approaches and domain-specific modeling (DSM) languages, methods and tools are beneficial for the engineering of increasingly complex systems and software. Instead of general-purpose one-size-fits-all modeling languages, DSM methods facilitate model-based analysis and design of complex systems by providing modeling concepts tailored to the specific problem domain. Furthermore, hybrid DSM methods combine single DSM methods into integrated modeling methods, to allow for multi-perspective modeling. Metamodeling platforms provide flexible means for design and implementation of such hybrid modeling methods and appropriate domain-specific modeling tools. In this paper, we report on the conceptualization of a hybrid DSM method in the domain of network physical devices management, and its implementation based on the ADOxx metamodeling platform. The method introduces a hybrid modeling approach. A dedicated DSM language (DSML) is used to model the structure of physical devices and their configurations, whereas the formal language for knowledge representation OWL2 is used to specify configuration-related constraints. The outcome of the work is a hybrid, semantic technology-enabled DSM tool that allows for efficient and consistency-preserving model-based configuration of network equipment.

A Multidimensional Approach for Concurrent Model-Driven Automation Engineering

2011 ◽  
pp. 90-113 ◽  
Author(s):  
Sebastian Rose ◽  
Marius Lauder ◽  
Michael Schlereth ◽  
Andy Schürr
Keyword(s):  
Graph Grammar ◽  
Modeling Languages ◽  
Graph Grammars ◽  
Modeling Tools ◽  
Model Driven ◽  
Domain Specific ◽  
Management Group ◽  
Domain Specific Modeling ◽  
Design Activities ◽  
Synchronization Mechanisms

Automation engineering heavily relies on concurrent model-driven design activities across multiple disciplines. The customization and integration of domain-specific modeling languages and tools play an important role. This contribution introduces a conceptual framework for this purpose that combines the modeling standards of the Object Management Group (OMG) with precisely defined specification techniques based on metamodeling and graph grammars. The main focus is on the development of synchronization mechanisms between modeling tools and on the presentation of some extensions of the underlying graph grammar formalism motivated by its application to a real-world scenario. These techniques are presented by a case study about the application of graph grammars within automation engineering.

ANALISIS KEMAMPUAN WEBRATIO UNTUK PENGEMBANGAN APLIKASI WEB MENGGUNAKAN INTERACTION FLOW MODELING LANGUAGE (IFML)

2020 ◽  
Vol 3 (2) ◽  
Author(s):  
Joe Lian Min
Keyword(s):  
Web Applications ◽  
Transformation Process ◽  
Modeling Language ◽  
Modeling Languages ◽  
Functional Requirements ◽  
Application Development ◽  
Model Driven ◽  
Measurement Results ◽  
Mdd Method

The model-driven development (MDD) method is a method that can accelerate the application development process. With this method, the model can be immediately transformed into an executable application. Model-driven architecture is one kind of MDD approaches. MDA has a standard modeling language that is used to facilitate the transformation process. One of the modeling languages in MDA is Interaction Flow Management Language (IFML). IFML models an application based on the interaction flow and interface of the application. This paper explains the capabilities of WebRatio in developing Web applications and their effectiveness. The effectiveness is calculated from the effort required for the development. On the other side, the effort is calculated from the line of code (LOC) generated from the model. The experiment's case study is a  simple web-shop application, with some functional and non-functional requirements. The measurement results show that to develop a web-shop, the effort required is quite efficient, only 13% of the total application. However, another study still needs to be done because many variables affect the productivity of application development.

Evolution in Model-Driven Software Product-Line Architectures

2009 ◽  
pp. 102-132 ◽  
Author(s):  
Gan Deng ◽  
Douglas C. Schmidt ◽  
Aniruddha Gokhale ◽  
Jeff Gray ◽  
Yuehua Lin ◽  
...  
Keyword(s):  
Model Transformation ◽  
Product Line ◽  
Domain Model ◽  
Modeling Language ◽  
Model Driven Engineering ◽  
Model Driven ◽  
Transformation Rules ◽  
Domain Evolution ◽  
Software Product

This chapter describes our approach to model-driven engineering (MDE)-based product line architectures (PLAs) and presents a solution to address the domain evolution problem. We use a case study of a representative software-intensive system from the distributed real-time embedded (DRE) systems domain to describe key challenges when facing domain evolution and how we can evolve PLAs systematically and minimize human intervention. The approach uses a mature metamodeling tool to define a modeling language in the representative DRE domain, and applies a model transformation tool to specify modelto- model transformation rules that precisely define metamodel and domain model changes. Our approach automates many tedious, time consuming, and error-prone tasks of model-to-model transformation, thus significantly reducing the complexity of PLA evolution.

Model-Based Development

2011 ◽  
pp. 289-312 ◽  
Author(s):  
Juan D. Lara ◽  
Esther Guerra ◽  
Hans Vangheluwe
Keyword(s):  
Programming Languages ◽  
Graphical Models ◽  
Code Generation ◽  
Simulation Analysis ◽  
Model Simulation ◽  
General Purpose ◽  
Test Case ◽  
Model Driven ◽  
Model Based ◽  
Design Activities

Since the beginning of computer science more than 50 years ago, software engineers have sought techniques resulting in higher levels of quality and productivity. Some of these efforts have concentrated in increasing the level of abstraction in programming languages (from assembler to structured languages to object-oriented languages). In the last few years, we have witnessed an increasing focus on development based on high-level, graphical models. They are used not only as a means to documentthe analysis and design activities, but also as the actual “implementation” of the application, as well as for automatic analysis, code, and test case generation. The notations used to describe the models can be standard and general purpose (for example, UML) or tightly customized for the application domain. Code generation for the full application is only accomplished for specific, well-understood application domains. A key initiative in this direction is OMG’s Model-Driven Architecture (MDA), where models are progressively transformed until executable code is obtained. In this chapter, we give an overview of these technologies and propose ideas following this line (concerning metamodeling and the use of visual languages for the specification of model transformation, model simulation, analysis and code generation), and examine the impact of model-based techniques in the development process.

Using a Model Quality Framework for Requirements Specification of an Enterprise Modeling Language

2005 ◽  
pp. 142-158 ◽  
Author(s):  
John Krogstie ◽  
Vibeke Dalberg ◽  
Siri Moe Jenson
Keyword(s):  
Model Development ◽  
Enterprise Modeling ◽  
Process Models ◽  
Requirements Specification ◽  
Modeling Language ◽  
Modeling Languages ◽  
Model Quality ◽  
Modeling Tools ◽  
Model Interpretation ◽  
Specialized Language

As more and more modern modeling tools provide the possibility of developing specialized and new modeling languages (also called meta modeling or method engineering), the need for methodologies and guidelines to perform requirements specification in the development and evolution of these languages increases. Based on work on quality of models and modeling languages, we have defined a methodology to attack this problem, taking as an outset the goals of modeling, modeling tasks, and related roles involved in model development and model interpretation. This chapter presents the application of this methodology for selection and refinement of a modeling language for a process harmonization project in an international organization. The harmonization project uses process models as the basis for developing a support environment for the new harmonized process. The process models were used for many different tasks, and it proved to be very beneficial to structure the modeling language requirements specification process to be able to prioritize what was to be implemented in the specialized language.

Sign in / Sign up

Export Citation Format

Share Document