scholarly journals Model driven engineering of a tableau algorithm for description logics

2009 ◽  
Vol 6 (1) ◽  
pp. 23-43 ◽  
Author(s):  
Nenad Krdzavac ◽  
Dragan Gasevic ◽  
Vladan Devedzic
Keyword(s):  
Programming Languages ◽  
Description Logics ◽  
Abstract Syntax ◽  
Model Driven Engineering ◽  
Model Driven ◽  
Model Repository ◽  
Tableau Algorithm ◽  
Original Definition ◽  
Concrete Syntax ◽  
Definition Of

This paper presents a method for implementing tableau algorithm for description logics (DLs). The architectures of the present DL reasoners such as RACER or FaCT were developed using programming languages as Java or LISP. The implementations are not based on original definition of the abstract syntax, but they require transformation of abstract syntax into concrete syntax implementation languages use. In order to address these issues, we propose the use of model-driven engineering principles for the development of a DL reasoner where a definition of a DL abstract syntax is provided by means of metamodels. The presented approach is based on the use of a MOF-based model repository and QVT-like transformations, which transform models compliant to the DL metamodel taken from the OMG's Ontology Definition Metamodel specification into models compliant to the Tableau metamodel defined in this paper. .

scholarly journals Development of custom notation for XML-based language: A model-driven approach

2017 ◽  
Vol 14 (3) ◽  
pp. 939-958 ◽  
Author(s):  
Sergej Chodarev ◽  
Jaroslav Porubän
Keyword(s):  
User Experience ◽  
Explicit Representation ◽  
Abstract Syntax ◽  
Iterative Design ◽  
Model Driven ◽  
Domain Specific ◽  
Concrete Syntax ◽  
Definition Of ◽  
Model Driven Approach

In spite of its popularity, XML provides poor user experience and a lot of domain-specific languages can be improved by introducing custom, more humanfriendly notation. This paper presents an approach for design and development of the custom notation for existing XML-based language together with a translator between the new notation and XML. The approach supports iterative design of the language concrete syntax, allowing its modification based on users feedback. The translator is developed using a model-driven approach. It is based on explicit representation of language abstract syntax (metamodel) that can be augmented with mappings to both XML and the custom notation. We provide recommendations for application of the approach and demonstrate them on a case study of a language for definition of graphs.

Formal Metamodeling for Secure Model-Driven Engineering

2021 ◽  
Vol 12 (2) ◽  
pp. 46-67
Author(s):  
Liliana Maria Favre
Keyword(s):  
Cloud Computing ◽  
Formal Specifications ◽  
Model Driven Engineering ◽  
Model Driven ◽  
Transformation Rules ◽  
Systematic Development ◽  
Definition Of ◽  
Context Specific ◽  
Theoretical Foundations

Systems and applications aligned with new paradigms such as cloud computing and internet of the things are becoming more complex and interconnected, expanding the areas in which they are susceptible to attacks. Their security can be addressed by using model-driven engineering (MDE). In this context, specific IoT or cloud computing metamodels emerged to support the systematic development of software. In general, they are specified through semiformal metamodels in MOF style. This article shows the theoretical foundations of a method for automatically constructing secure metamodels in the context of realizations of MDE such as MDA. The formal metamodeling language Nereus and systems of transformation rules to bridge the gap between formal specifications and MOF are described. The main contribution of this article is the definition of a system of transformation rules called NEREUStoMOF for transforming automatically formal metamodeling specifications in Nereus to semiformal-MOF metamodels annotated in OCL.

FROM TYPE SYSTEMS TO KNOWLEDGE REPRESENTATION: NATURAL SEMANTICS SPECIFICATIONS FOR DESCRIPTION LOGICS

1992 ◽  
Vol 01 (01) ◽  
pp. 93-126 ◽  
Author(s):  
ALEXANDER BORGIDA
Keyword(s):  
Programming Languages ◽  
Description Logics ◽  
Denotational Semantics ◽  
Type Systems ◽  
Management Systems ◽  
Base Management ◽  
Similarities And Differences ◽  
Definition Of ◽  
Knowledge Base Management Systems

We first explore the similarities and differences between concept definitions in description/terminological logics such as KL-ONE, Classic, Back, Loom, etc. and the types normally encountered in programming languages. The similarities lead us to consider the application of natural semantics — the mechanism most frequently used to describe type systems — to the definition of knowledge base management systems that use such description logics. The paper presents inference rules in the natural semantics style for a variety of judgments involving descriptions, such as “subsumption” and “object membership”, and provides the full definition of subsumption in the Classic KBMS as a proof system. One of our objectives is to document some advantages of this approach, including the utility of multiple complementary semantics, and especially the characterization of implementations that are computationally tractable but are incomplete relative to standard denotational semantics.

scholarly journals Jolie and LEMMA: Model-Driven Engineering and Programming Languages Meet on Microservices

2021 ◽  
pp. 276-284
Author(s):  
Saverio Giallorenzo ◽  
Fabrizio Montesi ◽  
Marco Peressotti ◽  
Florian Rademacher ◽  
Sabine Sachweh
Keyword(s):  
Programming Languages ◽  
Model Driven Engineering ◽  
Model Driven

scholarly journals Declarative Transformation for Object-Oriented Models

2011 ◽  
pp. 127-147 ◽  
Author(s):  
Keith Duddy ◽  
Anna Gerber ◽  
Michael Lawley ◽  
Kerry Raymond
Keyword(s):  
Software Engineering ◽  
Model Transformation ◽  
Object Oriented ◽  
Software Systems ◽  
Abstract Syntax ◽  
Model Driven ◽  
Concrete Syntax

This chapter provides a context and motivation for a language to describe transformations of models within an object-oriented framework. The requirements for such a language are given, and then an object-oriented model of the language’s abstract syntax is provided that meets these requirements. A concrete syntax is introduced along with some example transformations. Finally, we discuss the tools required to use the language within a model-driven software engineering paradigm. The authors aim to demonstrate the principles of model transformation within an object-oriented framework, and show how this can be applied to the development of software systems.

scholarly journals Model transformations to bridge concrete and abstract syntax of web rule languages

2009 ◽  
Vol 6 (2) ◽  
pp. 47-85 ◽  
Author(s):  
Milan Milanovic ◽  
Dragan Gasevic ◽  
Adrian Giurca ◽  
Gerd Wagner ◽  
Sergey Lukichev ◽  
...  
Keyword(s):  
Good Practice ◽  
Model Transformations ◽  
Abstract Syntax ◽  
Object Constraint Language ◽  
Model Driven ◽  
Transformation Language ◽  
Rule Languages ◽  
Constraint Language ◽  
Concrete Syntax ◽  
Model Transformation Language

This paper presents a solution to bridging the abstract and concrete syntax of a Web rule languages by using model transformations. Current specifications of Web rule languages such as Semantic Web Rule Language (SWRL) or RuleML define their abstract syntax (e.g., metamodel) and concrete syntax (e.g., XML schema) separately. Although the recent research in the area of Model-Driven Engineering (MDE) demonstrates that such a separation of two types of syntax is a good practice (due to the complexity of languages), one should also have tools that check validity of rules written in a concrete syntax with respect to the abstract syntax of the rule language. In this study, we use the REWERSE I1 Rule Markup Language (R2ML), SWRL, and Object Constraint Language (OCL), whose abstract syntax is defined by using metamodeling, while their textual concrete syntax is defined by using either XML/RDF schema or Extended Backus-Naur Form (EBNF) syntax. We bridge this gap by a bi-directional transformation defined in a model transformation language (ATLAS Transformation Language, ATL). This transformation allowed us to discover a number of issues in both web rule language metamodels and their corresponding concrete syntax, and thus make them fully compatible. This solution also enables for sharing web rules between different web rule languages.

scholarly journals RESTful Web Services Development With a Model-Driven Engineering Approach

2019 ◽  
pp. 191-228
Author(s):  
Rafael Corveira da Cruz Gonçalves ◽  
Isabel Azevedo
Keyword(s):  
Web Service ◽  
Code Generation ◽  
Service Development ◽  
Generation Process ◽  
Model Driven Engineering ◽  
Model Driven ◽  
Model Driven Software Development ◽  
Restful Web Service ◽  
Definition Of ◽  
Restful Web Services

A RESTful web service implementation requires following the constrains inherent to REST architectural style, which, being a non-trivial task, often leads to solutions that do not fulfill those requirements properly. Model-driven techniques have been proposed to improve the development of complex applications. In model-driven software development, software is not implemented manually based on informal descriptions but partially or completely generated from formal models derived from metamodels. A model-driven approach, materialized in a domain specific language that integrates the OpenAPI specification, an emerging standard for describing REST services, allows developers to use a design first approach in the web service development process, focusing in the definition of resources and their relationships, leaving the repetitive code production process to the automation provided by model-driven engineering techniques. The code generation process covers the entire web-service flow from the description and exposure of the endpoints to the definition of database tables.

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.

Sign in / Sign up

Export Citation Format

Share Document