Development Of Domain-specific Languages Research Articles

Development and validation of coreLang: A threat modeling language for the ICT domain

ICT infrastructures are getting increasingly complex, and defending them against cyber attacks is cumbersome. As cyber threats continue to increase and expert resources are limited, organizations must find more efficient ways to evaluate their resilience and take proactive measures. Threat modeling is an excellent method of assessing the resilience of ICT systems, for example, by building Attack Graphs that illustrate an adversary’s attack vectors. Previously, the Meta Attack Language (MAL) was proposed, which serves as a framework to develop Domain Specific Languages (DSLs) and generate Attack Graphs for modeled infrastructures. coreLang is a MAL-based threat modeling language that utilizes Attack Graphs to enable attack simulations and security assessments. In this work, we present the first release version of coreLang in which MITRE ATT&CK tactics and techniques are mapped onto to serve as a validation and identify strengths and weaknesses to benefit the development cycle. Our validation showed that coreLang does cover 46% of all the techniques included in the matrix, while if we additionally exclude the tactics that are intrinsically not covered by coreLang and MAL, the coverage percentage increases to 64%.

Empirical evaluation of a threat modeling language as a cybersecurity assessment tool

The complexity of ICT infrastructures is continuously increasing, presenting a formidable challenge in safeguarding them against cyber attacks. In light of escalating cyber threats and limited availability of expert resources, organizations must explore more efficient approaches to assess their resilience and undertake proactive measures. Threat modeling is an effective approach for assessing the cyber resilience of ICT systems. One method is to utilize Attack Graphs, which visually represent the steps taken by adversaries during an attack. Previously, MAL (the Meta Attack Language) was proposed, which serves as a framework for developing Domain-Specific Languages (DSLs) and generating Attack Graphs for modeled infrastructures. coreLang is a MAL-based threat modeling language that utilizes such Attack Graphs to enable attack simulations and security assessments for the generic ICT domain. Developing domain-specific languages for threat modeling and attack simulations provides a powerful approach for conducting security assessments of infrastructures. However, ensuring the correctness of these modeling languages raises a separate research question. In this study we conduct an empirical experiment aiming to falsify such a domain-specific threat modeling language. The potential inability to falsify the language through our empirical testing would lead to its corroboration, strengthening our belief in its validity within the parameters of our study. The outcomes of this approach indicated that, on average, the assessments generated by attack simulations outperformed those of human experts. Additionally, both human experts and simulations exhibited significantly superior performance compared to random guessers in their assessments. While specific human experts occasionally achieved better assessments for particular questions in the experiments, the efficiency of simulation-generated assessments surpasses that of human domain experts.

A Low-Code Approach for Connected Robots

Advanced robotic systems are finally becoming a reality; following the increased attention that robotics have attracted during the last few decades, new types of robotic applications are launched, from robotic space vessels and fully autonomous cars to robotic dancers and robot companions. Even more, following the advancements in the Internet of Things (IoT) domain, robots can now participate in more complex systems, namely Cyber-physical systems (CPS). In such systems, robots, software, sensors and/or “things” cooperate seamlessly in order to exhibit the desired outcome. However, the high heterogeneity of the components comprising CPS systems requires expertise in various scientific domains, a fact that makes development of CPS applications a resource- and time-consuming process. In order to alleviate this pain, model-driven (or model-based) approaches have been introduced. They employ a low code software engineering approach and hide the domain-specific knowledge needed, by providing an abstract representation that can be more easily understood. Following the low-code paradigm, current work focuses on the development of Domain-specific Languages (DSL) for ROS2 (Robot Operating System 2) systems in order to hide low-level middleware-specific setup and configuration details and enable access to robot development by non ROS experts. Furthermore, in order to enable the integration of ROS2 robots in CPS, a second DSL was developed. The first language, GeneROS, is used for the development and configuration of the core functionalities of the robot (such as hardware drivers and algorithms), while the second language, ROSbridge-DSL, implements the interfaces for connecting robots to the Edge and the Cloud, enabling this way remote monitoring and control in the context of IoT and CPS.

PEMBANGUNAN COMPILER DOMAIN SPECIFIC LANGUAGE SEBAGAI GENERATOR FORM HTML MENGGUNAKAN PYTHON SLY

The rapid development of information technology has a significant impact on the way companies operate. Companies can utilize technology to simplify and accelerate their business processes, including recording and managing transactional data. PT XYZ is one of the largest retail companies, with a vast amount of data and requiring various types of different HTML forms. Therefore, standardization in program code writing is necessary to minimize errors and facilitate application maintenance. This research aims to build a Compiler Domain Specific Language (DSL) as a web-based HTML form generator for PT XYZ. The study uses the Python SLY library, passing the Lexer and Parser processes in DSL development. The result of this research is a web-based HTML form generator that facilitates developers in creating standardized and automatic HTML forms. The use of DSL can speed up the program code writing process, minimize errors, and create structured and easily understood code by developers.

The meta attack language - a formal description

Nowadays, IT infrastructures are involved in making innumerable aspects of our lives convenient, starting with water or energy distribution systems, and ending with e-commerce solutions and online banking services. In the worst case, cyberattacks on such infrastructures can paralyze whole states and lead to losses in terms of both human lives and money.One of the approaches to increase security of IT infrastructures relies on modeling possible ways of compromising them by potential attackers. To facilitate creation and reusability of such models, domain specific languages (DSLs) can be created. Ideally, a user will employ a DSL for modeling their infrastructure of interest, with the domain-specific threats and attack logic being already encoded in the DSL by the domain experts.The Meta Attack Language (MAL) has been introduced previously as a meta-DSL for development of security-oriented DSLs. In this work, we define formally the syntax and a semantics of MAL to ease a common understanding of MAL’s functionalities and enable reference implementations on different technical platforms. It’s applicability for modeling and analysis of security of IT infrastructures is illustrated with an example.

Automatic compiler/interpreter generation from programs for Domain-Specific Languages: Code bloat problem and performance improvement

Using advanced AI approaches, the development of Domain-Specific Languages (DSLs) can be facilitated for domain experts who are not proficient in programming language development. In this paper, we first addressed the aforementioned problem using Semantic Inference. However, this approach is very time-consuming. Namely, a lot of code bloat is present in the generated language specifications, which increases the time required to evaluate a solution. To improve this, we introduced a multi-threaded approach, which accelerates the evaluation process by over 9.5 times, while the number of fitness evaluations using the improved Long Term Memory Assistance (LTMA) was reduced by up to 7.3%. Finally, a reduction in the number of input samples (fitness cases) was proposed, which reduces CPU consumption further.

GasMASk Annotation-based Code Generator as an Embedded Domain-Specific Language in Collaborative Multi-Agent Systems

Multi-agent systems have evolved with their application framework, analysis approaches and design complexities over the past few decades. In order for programming software agents, you need to handle analysis, design and implementation together; furthermore, privacy and trust should be integrated externally into the agent-oriented applications. Current frameworks do not consider privacy, trust, and data integrity in agent applications. In this study, we propose a domain-specific language that can be used for agent behaviors that consist of roles, organizational entity, goals through annotation processing with templates. Smart contracts can be generated to decrease the time for deployment and development stages. Templates and annotations are popular techniques to reduce boilerplate codebases from agent-oriented programming. These techniques can also be used for model-driven software engineering. This study will take the software agent development as a whole with analysis, design, and development with embedded domain-specific language development in terms of smart contract applications. Furthermore, we would like to refer to methodology, results of the research, and case study to enlighten readers in a better way. Finally, we summarize findings and highlight the main research points by inferencing in the conclusion section.

Systematic mapping study on domain-specific language development tools

Domain-specific languages (DSL) are programming or modeling languages devoted to a given application domain. There are many tools used to support the implementation of a DSL, making hard the decision-making process for one or another. In this sense, identifying and mapping their features is relevant for decision-making by academic and industrial initiative on DSL development. Objective: The goal of this work is to identify and map the tools, Language Workbenches (LW), or frameworks that were proposed to develop DSLs discussed and referenced in publications between 2012 and 2019. Method: A Systematic Mapping Study (SMS) of the literature scoping tools for DSL development. Results: We identified 59 tools, including 9 under a commercial license and 41 with non-commercial licenses, and analyzed their features from 230 papers. Conclusion: There is a substantial amount of tools that cover a large number of features. Furthermore, we observed that usually, the developer adopts one type of notation to implement the DSL: textual or graphical. We also discuss research gaps, such as a lack of tools that allow meta-meta model transformations and that support modeling tools interoperability.

A Categorical Model of Process Co-Simulation

A set of dynamic systems in which some entities undergo transformations, or receive certain services in successive phases, can be modeled by processes. The specification of a process consists of a description of the properties of this process as a mathematical object in a suitable modeling language. The language chosen for specifying a process should facilitate the writing of this specification in a very clear and simple form. This raises the need for the use of various types of formalisms that are faithful to the component subsystems of such a system and which are capable of mimicking their varied dynamics. Often in practice, the development of domain specific languages is used to provide building blocks adapted to the processes. Thus, the concept of multi-paradigm modeling arises which involves the combination of different types of models, the decomposition and composition of heterogeneous specified models as well as their simulation. Multi-paradigm modeling presents a variety of challenges such as coupling and transforming the models described in various formalisms, the relationship between models at different levels of abstraction, and the creation of metamodels to facilitate the rapid development of varied formalisms for model specification. The simulation can be seen as a set of state variables that evolve over time. Co-simulation is a synthesis of all simulations of the components of the system, coordinated and synchronized based on interactions between them. The theory of categories provides a framework for organizing and structuring formal systems in which heterogeneous information can be transferred, thus allowing for the building of rigorous cohesion bridges between heterogeneous components. This paper proposes a new model of co-simulation of processes based on the category theory.

Automatic production of end user documentation for DSLs

Domain-specific languages (DSL) are developed for answering specific problems by leveraging the expertise of domain stakeholders. The development of DSLs requires a significant software engineering effort: editors, code generators, etc, must be developed to make a DSL usable. Documenting a DSL is also a major and time-consuming task required to promote it and address its learning curve. Recent research work in software language engineering focus on easing the development of DSLs. This work focuses on easing the production of documentation of textual DSLs. The API documentation domain identified challenges we adapted to DSL documentation. Based on these challenges we propose a model-driven approach that relies on DSL artifacts to extract information required to build documentation. Our implementation, called Docywood, targets two platforms: Markdown documentation for static web sites and Xtext code fragments for live documentation while modeling. We used Docywood on two DSLs, namely ThingML and Target Platform Definition. Feedback from end users and language designers exhibits qualitative benefits of the proposal with regard to the DSL documentation challenges. End user experiments conducted on ThingML and Target Platform Definition show benefits on the correctness of the created models when using Docywood on ThingML.

FLANDM: a development framework of domain-specific languages for data mining democratisation

Companies have an increasing interest in employing data mining to take advantage of the vast amounts of data their systems store nowadays. This interest confronts two problems: (1) business experts usually lack the skills required to apply data mining techniques, and (2) the specialists who know how to use these techniques are a scarce and valuable asset. To help democratise data mining, we proposed, in a previous work, the development of domain-specific languages (DSLs) that hide the complexity of data mining techniques. The objective of these DSLs is to allow business experts to specify analysis processes by using high-level primitives and terminology from the application domain. These specifications would then be automatically transformed into a low-level, executable form. Although these DSLs might offer a promising solution to the aforementioned problems, their development from scratch requires a considerable effort and, consequently, they are costly. In order to make these languages affordable, we present FLANDM, an ecosystem devised for the rapid development of DSLs for data mining democratisation. FLANDM provides a base infrastructure that can be easily customised for the particularities of each domain, enabling controlled and systematic reuse of previously developed artefacts. By using FLANDM, new DSLs for data mining democratisation can be defined achieving a 50% of reduction in their development costs.

Concern-oriented language development (COLD): Fostering reuse in language engineering

Domain-Specific Languages (DSLs) bridge the gap between the problem space, in which stakeholders work, and the solution space, i.e., the concrete artifacts defining the target system. They are usually small and intuitive languages whose concepts and expressiveness fit a particular domain. DSLs recently found their application in an increasingly broad range of domains, e.g., cyber-physical systems, computational sciences and high performance computing. Despite recent advances, the development of DSLs is error-prone and requires substantial engineering efforts. Techniques to reuse from one DSL to another and to support customization to meet new requirements are thus particularly welcomed. Over the last decade, the Software Language Engineering (SLE) community has proposed various reuse techniques. However, all these techniques remain disparate and complicate the development of real-world DSLs involving different reuse scenarios.In this paper, we introduce the Concern-Oriented Language Development (COLD) approach, a new language development model that promotes modularity and reusability of language concerns. A language concern is a reusable piece of language that consists of usual language artifacts (e.g., abstract syntax, concrete syntax, semantics) and exhibits three specific interfaces that support (1) variability management, (2) customization to a specific context, and (3) proper usage of the reused artifact. The approach is supported by a conceptual model which introduces the required concepts to implement COLD. We also present concrete examples of some language concerns and the current state of their realization with metamodel-based and grammar-based language workbenches. We expect this work to provide insights into how to foster reuse in language specification and implementation, and how to support it in language workbenches.

Ontology-based DSL development using graph transformations methods

The article is related to the problem of implementing consistent changes in the model of some subject area and in the syntax of domain specific language (DSL), dealing with problems in that domain. In our research, we explore an opportunity to provide the method of development and modification of the DSL meta-model, using the ontology as a model of the subject area. This method combines graph representation of the ontology and DSL with the set of rules, formulated in terms of an automated graph-transformation language. Applicability of the proposed approach is demonstrated using a real-life example of modification of the DSL meta-model according to changes of the ontology in the railway transportation domain.

Usability driven DSL development with USE-ME

The adoption of Domain-Specific Languages (DSLs) is regarded as an approach to reduce the accidental complexity of software systems development. The availability of sophisticated language workbenches facilitates the development of DSLs making them increasingly more popular. The adoption of DSLs at large comes at the risk that a poorly designed DSL can be too hard to adopt by its domain users. As such, Usability is one of the essential characteristics to mitigate this risk as it has an important impact on the productivity achieved by DSL users.The current state of practice in Software Language Engineering (SLE) neglects the Usability of DSLs. A pertinent research question in SLE is how to engineer Usability into DSLs systematically. We argue that a timely systematic approach based on User Interface experimental evaluation techniques should be used to assess the impact of DSLs during their development process, while the cost of fixing the usability problems is relatively small, when compared to fixing them at the end of the development process.For that purpose, we introduce a conceptual framework, called USE-ME, which supports the iterative incremental development process of DSLs concerning the issue of their Usability evaluation. We illustrate the feasibility of the approach on a case study of the development of a DSL meant for children to program robots.

Language Oriented Modularity: From Theory to Practice

Language-oriented modularity (LOM) is a methodology that complements language-oriented programming (LOP) in providing on-demand language abstraction solutions during software development. It involves the implementation and immediate utilization of domain-specific languages (DSLs) that are also aspect-oriented (DSALs). However, while DSL development is affordable thanks to modern language workbenches, DSAL development lacks similar tool support. Consequently, LOM is often impractical and underutilized. The challenge we address is making the complexity of DSAL implementation comparable to that of DSLs and the effectiveness of programming with DSALs comparable to that of general-purpose aspect languages (GPALs). Today, despite being essentially both domain-specific and aspect-oriented, DSALs seem to be second-class. Aspect development tools (e.g., AJDT) do not work on DSAL code. DSL development tools like language workbenches (e.g., Spoofax) neither deal with the backend weaving nor handle the composition of DSALs. DSAL composition frameworks (e.g., Awesome) do not provide frontend development tools. DSAL code transformation approaches (e.g., XAspects) do not preserve the semantics of DSAL programs in the presence of other aspect languages. We extend AspectJ with a small set of annotations and interfaces that allows DSAL designers to define a semantic-preserving transformation to AspectJ and interface with AspectJ tools. Our transformation approach enables the use of standard language workbench to implement DSALs and use of standard aspect development tools to program with those DSALs. As a result, DSALs regain first-class status with respect to both DSLs and aspect languages. This, on the one hand, lowers the cost of developing DSALs to the level of DSLs and, on the other hand, raises the effectiveness of using a DSAL to the level of a GPAL. Consequently, LOM becomes cost-effective compared to the LOP baseline. We modified the ajc compiler to support our approach. Using two different language workbenches (Spoofax and Xtext) we then implemented several DSALs. AspectJ was supported out-of-the-box. We implemented Cool to demonstrate that the non-trivial composition of AspectJ and Cool can be accommodated using our approach. We applied LOM to crosscutting concerns in two open source projects (oVirt and muCommander), implementing in the process application-specific DSALs, thus providing a sense of the decrease in the cost of developing composable DSALs and the increase in the effectiveness of programming with them. Crosscutting concerns remain a problem in modern real-world projects (e.g., as observed in oVirt). DSALs are often the right tool for addressing these concerns. Our work makes LOM practical, thus facilitating use of DSAL solutions in the software development process.

Semi-automated integration of domain ontologies to DSL meta-models

This paper investigates the use of ontologies for the development of Domain-Specific Languages (DSL). In Model-based Software Development (MBSD), ontologies as formal models are mostly used in the phase of domain analysis as formal representations of domain models and requirements of a system. In this paper, we extend this view by introducing a concept of a DSL meta-model ontology that is defined as consisting of system ontology of a MSDB tool linked to one or more domain ontologies and external software artefacts. According to the solution presented in this paper, the given domain ontologies are semi-automatically integrated into a DSL meta-model using a set of transformations between constructs of ontology modelling language OWL and a modelling language used for representing DSL meta-models. This approach enables a dynamic semantic composition of a DSL meta-model and is prototypically implemented in Java as an extension to the DSL development tool CoCoViLa.

Semi-automated integration of domain ontologies to DSL meta-models

This paper investigates the use of ontologies for the development of Domain-Specific Languages (DSL). In Model-based Software Development (MBSD), ontologies as formal models are mostly used in the phase of domain analysis as formal representations of domain models and requirements of a system. In this paper, we extend this view by introducing a concept of a DSL meta-model ontology that is defined as consisting of system ontology of a MSDB tool linked to one or more domain ontologies and external software artefacts. According to the solution presented in this paper, the given domain ontologies are semi-automatically integrated into a DSL meta-model using a set of transformations between constructs of ontology modelling language OWL and a modelling language used for representing DSL meta-models. This approach enables a dynamic semantic composition of a DSL meta-model and is prototypically implemented in Java as an extension to the DSL development tool CoCoViLa.

Leveraging Software Product Lines Engineering in the development of external DSLs: A systematic literature review

The use of domain-specific languages (DSLs) has become a successful technique in the development of complex systems. Consequently, nowadays we can find a large variety of DSLs for diverse purposes. However, not all these DSLs are completely different; many of them share certain commonalities coming from similar modeling patterns – such as state machines or petri nets – used for several purposes. In this scenario, the challenge for language designers is to take advantage of the commonalities existing among similar DSLs by reusing, as much as possible, formerly defined language constructs. The objective is to leverage previous engineering efforts to minimize implementation from scratch. To this end, recent research in software language engineering proposes the use of product line engineering, thus introducing the notion of language product lines. Nowadays, there are several approaches that result useful in the construction of language product lines. In this article, we report on an effort for organizing the literature on language product line engineering. More precisely, we propose a definition for the life-cycle of language product lines, and we use it to analyze the capabilities of current approaches. In addition, we provide a mapping between each approach and the technological space it supports.

Industrial Experiences with a Formal DSL Semantics to Check the Correctness of DSL Artifacts

A domain specific language (DSL) abstracts from implementation details and is aligned with the way domain experts reason about a software component. The development of DSLs is usually centered around a grammar and transformations that generate implementation code or analysis models. The semantics of the language is often defined implicitly and in terms of a transformation to implementation code. In the presence of multiple transformations from the DSL, the correctness of the generated artifacts with respect to the semantics of the DSL is a relevant issue. We show that a formal semantics is essential for checking the correctness of the generated artifacts. We exploit the formal semantics in an industrial project and use formal techniques based on equivalence checking and model-based testing for validating the correctness of the generated artifacts. We report about our experience with this approach in an industrial development project.

Formalizing and testing the consistency of DSL transformations

Abstract A domain specific language (DSL) focuses on the essential concepts in a specific problem domain, and abstracts from low-level implementation details. The development of DSLs usually centers around the meta-model, grammar and code generator, possibly extended with transformations to analysis models. Typically, little attention is given to the formal semantics of the language, whereas this is essential for reasoning about DSL models, and for assessing the correctness of the generated code and analysis models. We argue that the semantics of a DSL should be defined explicitly and independently of any code generator, to avoid all kinds of complexities from low-level implementation details. As the generated analysis models must reflect some of these implementation details, we propose to formalize them separately. To assess the correctness and consistency of the generated code and analysis models in a practical way, we use conformance testing. We extensively illustrate this general approach using specific formalizations for an industrial DSL on collision prevention. We do not aim for a generic semantic model for any DSL, but this specific DSL indicates the potential of a modular semantics to facilitate reuse among DSLs.