Modeling Language Engineering Research Articles

Low-code development using requirements and knowledge representation models

Low-Code Development is a new software development paradigm which is typically used to generate web applications from high-level visual notations. These notations allow to express the User Interface and Application Logic (usersystem interactions) in a way which is understandable by the end-users. Using certain model-driven approaches, the low-code environments allow for generating the front-end layer and basic CRUD operations in the back-end. Yet still, non-standard domain logic (data processing) operations still necessitate the use of traditional programming. In this article we present a visual language, called RSL-DL that can be used to represent such non-standard domain logic in a visual form. It allows to capture domain knowledge with complex domain rules aligned with requirements models. The language synthesises and extends approaches found in knowledge representation (ontologies) and software modelling language engineering. The development environment of RSL-DL enables fully automatic generation of domain logic code by reasoning over and reusing domain knowledge. The environment includes a dedicated model editor and a transformation engine. The language?s abstract syntax is defined using a meta-model expressed in MOF. Its semantics is expressed with several translational rules that map RSL-DL models onto typical programming language constructs. The article presents a list of these rules in an informal way, and then introduces their formalisation using a graphical transformation notation. The RSL-DL environment includes an inference engine that enables processing queries to domain models and selecting appropriate invocations to generated code. It was also initially validated through studies that involve understandability, operability and complexity assessment. Based on these results, we conclude that declarative knowledge representations can be successfully used to produce imperative backend code with non-trivial logic.

Guest editorial for the theme section on modeling language engineering

Guest editorial for the theme section on modeling language engineering

Safe reuse in modelling language engineering using model subtyping with OCL constraints

Low-code software development promises rapid delivery of software cloud applications by employing domain-specific languages (DSLs), requiring minimal traditional coding. Model-driven engineering (MDE) provides tools, modelling notations and practices suited for engineering such DSLs, both from a syntactic and semantic perspective. However, low-code software development is heavily reliant on software reuse. It is imperative to provide safe mechanisms that guarantee valid semantic reuse of structural components and their behaviour, most often in a stepwise manner. This article presents a semantic reuse technique based on model subtyping over metamodels to manage correct model-driven engineering of DSLs. Model subtyping is generalized to structural semantics by considering OCL constraints. Moreover, model subtyping is generalized to behavioural semantics by considering specifications of model transformation operations, which may encode operational or translational semantics. Model subtyping facilitates structural and behavioural refinement. It has been implemented atop a bounded model checker, realizing a semi-decidable procedure for verifying that DSL elements are safely reused. The algorithm finds semantic witnesses of inconsistencies when refinement principles are not satisfied, fostering a correct stepwise engineering of DSLs. Moreover, the algorithm produces an extension metamodel that permits the as-is reuse of implementations of model transformation operation specifications. Finally, the versatility of the model subtyping technique is illustrated with common use cases extracted from the research literature.

A technique for evaluating and improving the semantic transparency of modeling language notations

The notation of a modeling language is of paramount importance for its efficient use and the correct comprehension of created models. A graphical notation, especially for domain-specific modeling languages, should therefore be aligned to the knowledge, beliefs, and expectations of the targeted model users. One quality attributed to notations is their semantic transparency, indicating the extent to which a notation intuitively suggests its meaning to untrained users. Method engineers should thus aim at semantic transparency for realizing intuitively understandable notations. However, notation design is often treated poorly—if at all—in method engineering methodologies. This paper proposes a technique that, based on iterative evaluation and improvement tasks, steers the notation toward semantic transparency. The approach can be efficiently applied to arbitrary modeling languages and allows easy integration into existing modeling language engineering methodologies. We show the feasibility of the technique by reporting on two cycles of Action Design Research including the evaluation and improvement of the semantic transparency of the Process-Goal Alignment modeling language notation. An empirical evaluation comparing the new notation against the initial one shows the effectiveness of the technique.

Software language engineering in the large: towards composing and deriving languages

Suitable software languages are crucial to tackling the ever-increasing complexity of software engineering processes and software products. They model, specify, and test products, describe processes and interactions with services and serve many other purposes. Meanwhile, engineering suitable modeling languages with useful tooling also has become a challenging endeavor - and far too often, new languages are developed from scratch. We shed light on the advances of modeling language engineering that facilitate reuse, modularity, compositionality, and derivation of new languages based on language components. To this end, we discuss ways to design, combine, and derive modeling languages in all their relevant aspects. We illustrate the application of advanced language engineering throughout the paper, which culminates in the example of deriving complete domain-specific transformations language from existing language components.

Exploring Multi-Paradigm Modeling Techniques

Multi-Paradigm Modeling (MPM) addresses the necessity of using multiple modeling paradigms when designing complex systems. Because of its multidisciplinary nature, the MPM field involves research teams with technical backgrounds as different as control science, model checking, modeling language engineering or system-on-chip development. In this paper, we propose to explore the MPM domain through a survey of existing techniques from different horizons. Since the heterogeneity of models is at the heart of MPM, we first identify the sources of this heterogeneity and introduce the problems it raises. Then we show how the different existing techniques address these problems.

Correctly defined concrete syntax

Due to their complexity, the syntax of modern modeling languages is preferably defined in two steps. The abstract syntax identifies all modeling concepts whereas the concrete syntax should clarify how these concepts are rendered by graphical and/or textual elements. While the abstract syntax is often defined in form of a metamodel, there does not exist such standard format yet for concrete syntax definitions. The diversity of definition formats—ranging from EBNF grammars to informal text—is becoming a major obstacle for advances in modeling language engineering, including the automatic generation of editors. In this paper, we propose a uniform format for concrete syntax definitions. Our approach captures both textual and graphical model representations and even allows to assign more than one rendering to the same modeling concept. Consequently, following our approach, a model can have multiple, fully equivalent representations, but—in order to avoid ambiguities when reading a model representation—two different models should always have distinguishable representations. We call a syntax definition correct, if all well-formed models are represented in a non-ambiguous way. As the main contribution of this paper, we present a rigorous analysis technique to check the correctness of concrete syntax definitions.