Search

Context: The popularity of domain-specific languages and model driven development has made the tacit use of domain knowledge in system development more tangible. Our vision is a development process where a (software) system specification is based on multiple domain models, and where the specification method is built from cognitive concepts, presumably derived from natural language. Goal: To realize this vision, we evaluate and reflect upon the existing literature in domain-oriented specification techniques. Method: We designed and conducted a systematic literature review on domain-oriented specification techniques. Results: We identified 53 primary studies, populated the classification framework for each study, and summarized our findings per classification aspect. We found many approaches for creating domain models or domain-specific languages. Observations include: (i) most methods are defined incompletely; (ii) none offers methodical support for the use of domain models or domain-specific languages to create other specifications; (iii) there are specification techniques to integrate models in general, but no study offers methodical support for multiple domain models. Conclusion: The results indicate which topics need further research and which can instead be reused to realize our vision on system development. Editor's note: Open Science material was validated by the Journal of Systems and Software Open Science Board.

Critical infrastructure (CIs) such as power grids link a plethora of physical components from many different vendors to the software systems that control them. These systems are constantly threatened by sophisticated cyber attacks. The need to improve the cybersecurity of such CIs, through holistic system modeling and vulnerability analysis, cannot be overstated. This is challenging since a CI incorporates complex data from multiple interconnected physical and computation systems. Meanwhile, exploiting vulnerabilities in different information technology (IT) and operational technology (OT) systems leads to various cascading effects due to interconnections between systems. The paper investigates the use of a comprehensive taxonomy to model such interconnections and the implied dependencies within complex CIs, bridging the knowledge gap between IT security and OT security. The complexity of CI dependence analysis is harnessed by partitioning complicated dependencies into cyber and cyber-physical functional dependencies. These defined functional dependencies further support cascade modeling for vulnerability severity assessment and identification of critical components in a complex system. On top of the proposed taxonomy, the paper further suggests power-grid reference models that enhance the reproducibility and applicability of the proposed method. The methodology followed was design science research (DSR) to support the designing and validation of the proposed artifacts. More specifically, the structural, functional adequacy, compatibility, and coverage characteristics of the proposed artifacts are evaluated through a three-fold validation (two case studies and expert interviews). The first study uses two instantiated power-grid models extracted from existing architectures and frameworks like the IEC 62351 series. The second study involves a real-world municipal power grid. CC BY 4.0© 2023 Springer Nature Switzerland AG. Part of Springer Nature.Paper is partly based on the results of the EU ISF project ELVIRA, his.se/elviraWe thank the colleagues from the ELVIRA project for their contributions to earlier versions of the taxonomy. We are in particular grateful to Yacine Atif for his support and encouragement. Many thanks also to the interview partners for helping to validate the usefulness of our approach. Finally, we thank the anonymous reviewers for their diligent and constructive evaluationsOpen access funding provided by University of Skövde.

Assessing business operations’ ethical, social, and environmental impacts is a key practice for establishing sustainable development. There is a multitude of methods that describes how to perform such assessments. Often these methods are supported by an ICT tool. In most cases, the tools are developed to support a single method only and do not allow any tailoring. Therefore, they are rigid and inflexible. In this article, we present a novel model-driven approach for alleviating managerial issues that arise as a consequence of the complex landscape of ethical, social, and environmental accounting methods and tools. We have developed an open-source, model-driven tool, called openESEA. OpenESEA parses and interprets textual models, that are specified according to a domain-specific language (DSL). We have performed another iteration of the DSL engineering process, which is in line with the design science paradigm. We have validated the new DSL version by means of a user study. As a result, we present a new version of the openESEA modeling language and interpreter. The results of the user study with regards to performance, perceived usefulness, and perceived ease of use of modeling language are encouraging and provide us with a basis to continue developing new versions with more functionalities. The contributions of this work include a new version of the modeling language, a new version of the interpreter, knowledge surrounding the development of these artifacts, and a protocol for evaluating the quality of textual DSLs. The modeling language and interpreter are relevant for sustainability practitioners and consultants since our tool support has the potential to reduce redundancy in ethical, social, and environmental accounting. Our work is valuable to researchers that aim to assess and reduce the complexity of their modeling languages.

Building conceptual models for software design, in particular for high-tech applications such as smart home systems, is a complex task that significantly affects the efficiency of their development processes. One of the innovative methods of solving this problem is the use of domain-specific modeling languages (DSMLs), which can reduce the time and other project resources required to create such systems. The subject of research in this paper is approaches to the development of DSML for Smart Home systems as a separate class of Internet of Things systems. The purpose of this work is to propose an approach to the development of DSMLs based on amodel of variability of the properties of such a system. The following tasks are being solved: analysis of some existing approaches to the creation of DSMLs; construction of a multifaceted classification of requirements for them, application of these requirements to the design of the syntax of a specific DSML-V for the creation of variable software in smart home systems; development of atechnological scheme and quantitative metrics for experimental evaluation of the effectiveness of the proposed approach. The following methods are used: variability modeling based on the property model, formal notations for describing the syntax of the DSML-V language, and the use of the open CASE tool metaDepth. Results: a multifaceted classification of requirements for a broad class of DSML languages is built; the basic syntactic constructions of the DSML-V language are developed to support the properties of software variability of "Smart Home" systems; a formal description of such syntax in the Backus-Naur notation is given; atechnological scheme for compiling DSML-V specifications into the syntax of the language of the open CASE tool metaDepth is created; the effectiveness of the proposed approach using quantitative metrics is experimentally investigated. Conclusions: the proposed method of developing a specialized problem-oriented language for smart home systems allows for multilevel modeling of the variability properties of its software components and provides an increase in the efficiency of programming such models by about 14% compared to existing approaches., Побудова концептуальних моделей для проєктування програмного забезпечення (ПЗ), зокрема для таких високотехнологічних застосунків, як системи "Розумний будинок", є складним завданням, від результатів виконання якого суттєво залежить ефективність процесів їхнього розроблення. Одним з інноваційних методів вирішення цієї проблеми є використання предметно орієнтованих мов моделювання (DSML), що дають змогу скоротити витрати часу та інших проєктних ресурсів, потрібних для створення таких систем. Предметом дослідження в роботі є підходи з метою розроблення DSML для систем "Розумний будинок" як окремого класу систем Internet of Things. Мета роботи – запропонувати підхід до розроблення DSML на основі моделі варіабельності властивостей такої системи. Вирішуються такі завдання: аналіз деяких уже наявних підходів до створення DSML; побудова багатоаспектної класифікацій вимог до них, застосування цих вимог щодо проєктування синтаксису конкретного DSML-V для створення варіабельного ПЗ у системах "Розумний будинок"; розроблення технологічної схеми й кількісних метрик для експериментального оцінювання ефективності запропонованого підходу. Використовуються такі методи: моделювання варіабельності, основане на моделі властивостей, формальні нотації для опису синтаксису мови DSML-V, застосування відкритого інструментального CASE-засобу metaDepth. Здобуті результати: побудовано багатоаспектну класифікацію вимог до широко класу мов DSML; розроблено основні синтаксичні конструкції мови DSML-V для підтримки властивостей варіабельності ПЗ систем "Розумний будинок"; надано формальний опис такого синтаксису в нотації Бекуса – Наура; створено технологічну схему компіляції специфікацій мовою DSML-V у синтаксис мови відкритого інструментального CASE-засобу metaDepth; експериментально досліджено ефективність застосування запропонованого підходу з використанням кількісних метрик. Висновки: запропонований метод розроблення спеціалізованої проблемно орієнтованої мови для систем "Розумний будинок" дає змогу проводити багаторівневе моделювання властивостей варіабельності її програмних компонентів і забезпечує зростання ефективності програмування таких моделей приблизно на 14% порівняно з наявними підходами.

This manual describes the syntax and semantics of a domain-specific modelling language for definition of functionally modelled sensor interfaces, called SensOr Interfacing Language (SOIL)., Funded by the Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) under Germany's Excellence Strategy – EXC-2023 Internet of Production – 390621612. Funded by the Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) under Project-ID 432233186 – AIMS., {"references":["http://dx.doi.org/10.1007/978-3-662-62138-7_45","https://doi.org/10.1016/j.measen.2021.100206","https://doi.org/10.18154/RWTH-2021-10238","https://doi.org/10.1117/12.252746"]}

Since the 60's the architectural model used by processors is the 'Von Neumann' model in which a processor fetches instructions and data to process in the same memory. The increase of the transistor density on a chip has allowed to increase its operating frequency but has produced a 'bottleneck' towards the memory which cannot provide instructions and data at the same frequency: the memory wall.Many architectural solutions have been proposed to solve this bottleneck. One of the solutions we are studying is an architecture in which computations are performed in memory, without moving data to the processor. Evaluation of this solution has shown impressive potential gains in speed and energy.To exploit this potential, a change in programming model is required, as instructions will no longer be read from memory but generated by a processor that will drive one or more memory planes.The contributions of the thesis are the specification of a transfer mechanism for complex memory access patterns to near-memory computing architectures.The thesis also presents a high-level programming model allowing the programming of a near-memory computing architecture, as well as the above-mentioned transfer mechanism.This programming model can be parameterized to compile specialized applications through static compilation, or dynamic code generation to perform run-time optimizations.The evaluation of these contributions through a simulation model shows results that demonstrate the interest of dynamic code specialization for heterogeneous architectures.; Depuis les années 60 le modèle architectural utilisé par les processeurs est le modèle ’von Neumann’ dans lequel un processeur va chercher instructions et données à traiter dans la même mémoire. L’augmentation de la densité de transistor sur une puce a permis d’augmenter sa fréquence de fonctionnement, mais a produit un ’goulot d’étranglement’ vers la mémoire qui ne peut pas fournir instructions et données à la même fréquence : le mur de la mémoire. Beaucoup de solutions architecturales ont été proposées pour résoudre ce goulot d’étranglement. Une des solutions que nous étudions est une architecture dans laquelle les calculs sont réalisés dans la mémoire, sans déplacer les données vers le processeur. L’évaluation de cette solution a montré des gains potentiels impressionnants en vitesse et en énergie. Pour exploiter ce potentiel, il faut changer de modèle de programmation, car les instructions ne seront plus lues en mémoire, mais générées par un processeur qui pilotera un ou plusieurs plans mémoire. Les contributions de la thèse sont la spécification d’un mécanisme de transfert pour les motifs d’accès mémoire complexes à destination des architectures de calcul proche-mémoire. La thèse présente également un modèle de programmation haut-niveau permettant la programmation d’une architecture de calcul proche-mémoire, ainsi que du mécanisme de transfert susmentionné. Ce modèle de programmation peut être paramétré pour compiler des applications spécialisées grâce à la compilation statique, ou la génération dynamique de code pour effectuer des optimisations lors du run-time. L’évaluation de ces contributions par le biais d’un modèle de simulation montre des résultats qui témoignent de l’intérêt de la spécialisation dynamique de code pour les architectures de calcul proche-mémoire, et par extension des nœuds de calcul hétérogènes.

Designing software that meets the stringent requirements of functional safety standards imposes a significant development effort compared to conventional software. A key aspect is the integration of safety mechanisms into the functional design to ensure a safe state during operation even in the event of hardware errors. These safety mechanisms can be applied at different levels of abstraction during the development process and are usually implemented and integrated manually into the design. This does not only cause significant effort but does also reduce the overall maintainability of the software. To mitigate this, we present the Universal Safety Format (USF), which enables the generation of safety mechanisms based on the separation of concerns principle in a model-driven approach. Safety mechanisms are described as generic patterns using a transformation language independent from the functional design or any particular programming language. The USF was designed to be easily integrated into existing tools and workflows that can support different programming languages. Tools supporting the USF can utilize the patterns in a functional design to generate and integrate specific safety mechanisms for different languages using the transformation rules contained within the patterns. This enables not only the reuse of safety patterns in different designs, but also across different programming languages. The approach is demonstrated with an automotive use-case as well as different tools supporting the USF.

Cyber–Physical Systems (CPS) are increasingly used in safety–critical scenarios where ensuring their correct behavior at runtime becomes a crucial task. Therefore, the behavior of the CPS needs to be monitored at runtime so that violations of requirements can be detected. With the inception of edge devices that facilitate runtime analysis at the edge and the increasingly diverse environments that CPS operate in, flexible monitoring approaches are needed that consider the data that needs to be monitored and the analyses performed on that data. In this paper, we propose AMon, a flexible adaptive monitoring framework that supports the specification and validation of monitoring adaptation rules, using a domain-specific language. Based on these rules, AMon automatically generates code for direct deployment onto devices. We evaluated AMon by applying it to TurtleBot Robots and a fleet of Unmanned Aerial Vehicles. Furthermore, we conducted a user study assessing the understandability and ease of use of our language. Results show that creating multiple adaptation rules with our DSL is feasible with minimal effort, and that adaptive monitoring can reduce the amount of runtime data transmitted from the edge device according to the current state of the system and its monitoring needs. Version of record

For the last decade, teams at Oracle relied on the Spoofax language workbench to develop a family of domain-specific languages for graph analytics in research projects and in product development. In this paper, we analyze the requirements for integrating language processors into large-scale graph analytics toolkits and for the development of these language processors as part of a larger product development process. We discuss how Spoofax helps to meet these requirements and point out the need for future improvements., OASIcs, Vol. 109, Eelco Visser Commemorative Symposium (EVCS 2023), pages 5:1-5:8

Textual editors are omnipresent in all software tools. Editors provide basic features, such as copy-pasting and searching, or more advanced features, such as error checking and text completion. Current technologies in model-driven engineering can automatically generate textual editors to manipulate domain-specific languages (DSLs). However, the customization and addition of new features to these editors is often limited to changing the internal structure and behavior. In this paper, we explore a new generation of self-descriptive textual editors for DSLs, allowing full configuration of their structure and behavior in a convenient formalism, rather than in source code. We demonstrate the feasibility of the approach by providing a prototype implementation and applying it in two domain-specific modeling scenarios, including one in architecture modeling.

A digital twin is a virtual model to reflect a physical object and helps it by making proper decisions. The decision-making process is based on the same input data that the simulated physical object has access to. Due to exploiting artificial intelligence, the decision-making process of the digital twin is more sophisticated than that of the physical object. In this study, the digital twin is applied to the sports training domain, where it addresses those questions that have arisen during the implementation of interval cycling training sessions. Thus, the digital twin runs on a mobile device (i.e., the Raspberry Pi platform), with which a cycle is equipped and demonstrates user-friendliness, robustness, reliability, and accuracy. The interval training sessions are transferred to the mobile device in the form of the domain-specific language EasyTrain, ensuring higher expressive power and ease of use. During the implementation, the digital twin advises the athlete with predicted information obtained by a sophisticated prediction model via a screen. The results of a huge experimental work showed that the difference in the average efficiency of the interval training implementation between the two cyclists that performed the experiments is prominent, as the efficiency of the professional training surpassed 90%, while the amateur training efficiency barely achieved 70%.

Inferring reliable brain-behavior associations requires synthesizing evidence from thousands of functional neuroimaging studies through meta-analysis. However, existing meta-analysis tools are limited to investigating simple neuroscience concepts and expressing a restricted range of questions. Here, we expand the scope of neuroimaging meta-analysis by designing NeuroLang: a domain-specific language to express and test hypotheses using probabilistic first-order logic programming. By leveraging formalisms found at the crossroads of artificial intelligence and knowledge representation, NeuroLang provides the expressivity to address a larger repertoire of hypotheses in a meta-analysis, while seamlessly modelling the uncertainty inherent to neuroimaging data. We demonstrate the language’s capabilities in conducting comprehensive neuroimaging meta-analysis through use-case examples that address questions of structure-function associations. Specifically, we infer the specific functional roles of three canonical brain networks, support the role of the visual word-form area in visuospatial attention, and investigate the heterogeneous organization of the fronto-parietal control network.

A smart contract is an agreement whose execution is automated or semi-automated. DasContract was introduced in 2019-2021 as a domain-specific language for smart-contract modeling, with the ability to generate code in a programming language. DasContract’s former modeling environment had various limitations, both technical and design related. Some of these limitations have previously been recognized in the literature in several dimensions. In this study, we propose further guidelines for contract modeling to address error prevention in the modeling environment, thus contributing to improved smart-contract specifications.

FPGA-based accelerators are increasingly popular across a broad range of applications, because they offer massive parallelism, high energy efficiency, and great flexibility for customizations. However, difficulties in programming and integrating FPGAs have hindered their widespread adoption. Since the mid 2000s, there has been extensive research and development toward making FPGAs accessible to software-inclined developers, besides hardware specialists. Many programming models and automated synthesis tools, such as high-level synthesis, have been proposed to tackle this grand challenge. In this survey, we describe the progression and future prospects of the ongoing journey in significantly improving the software programmability of FPGAs. We first provide a taxonomy of the essential techniques for building a high-performance FPGA accelerator, which requires customizations of the compute engines, memory hierarchy, and data representations. We then summarize a rich spectrum of work on programming abstractions and optimizing compilers that provide different trade-offs between performance and productivity. Finally, we highlight several additional challenges and opportunities that deserve extra attention by the community to bring FPGA-based computing to the masses.

Globalization has increased the need for society to master new languages. This need has encouraged the launch of many applications dedicated to language learning. This paper presents a graphical notation for a domain specific language to represent language learning activities. It describes how this notation enables developers to represent language learning activity characteristics using workflow, presentation, content, media and activity model conforming a metamodel that defines the abstract syntax of the domain specific language. This notation is implemented as part of an integrated development environment to build model-based applications. Finally, this proposal is evaluated with a framework that uses the cognitive dimensions of notations for notational systems. The proposed graphic diagram editor exceeds the experience that the user has with the reflexive model editor. In relation to the creation and editing of workflow models and presentation/activity models, the proposed graphical notation its more intuitive and easy to maintain visually than the traditional reflexive tree notation used by many model-based development frameworks.

Improving network traffic in networks is one of the concerns between networking researchers and network operators since the architecture of modern networks still faces challenges to process large data traffic without the cost of consuming a significant amount of resources not related to computing specifically. On the other hand, network programmability has enabled the development of new applications and network services, from software-defined networking to domain-specific languages created to program network devices and specify their behavior. The development of programmable hardware and hardware accelerators like FPGAs, GPUs, and CPUs help this new paradigm go one step further. Use the artifact of programmability of these devices to solve problems, such as improve the processing of data traffic is the key of in-network computing. It offers the opportunity to execute programs typically running on end-hosts within programmable network devices already incorporated on the network, thus being capable of provides a reduction on the in-network processing load and requires no extra cost, since operations can be concluded using a fewer amount of devices of the network and no extra device are needed. In this paper, we survey in-network computing, as well as we suggest classifying related works to in-network computing according to the hardware accelerator used. Also, we discuss challenges and research directions.

High-resolution simulations can deliver great visual quality, but they are often limited by available memory, especially on GPUs. We present a compiler for physical simulation that can achieve both high performance and significantly reduced memory costs, by enabling flexible and aggressive quantization. Low-precision ("quantized") numerical data types are used and packed to represent simulation states, leading to reduced memory space and bandwidth consumption. Quantized simulation allows higher resolution simulation with less memory, which is especially attractive on GPUs. Implementing a quantized simulator that has high performance and packs the data tightly for aggressive storage reduction would be extremely labor-intensive and error-prone using a traditional programming language. To make the creation of quantized simulation practical, we have developed a new set of language abstractions and a compilation system. A suite of tailored domain-specific optimizations ensure quantized simulators often run as fast as the full-precision simulators, despite the overhead of encoding-decoding the packed quantized data types. Our programming language and compiler, based on Taichi , allow developers to effortlessly switch between different full-precision and quantized simulators, to explore the full design space of quantization schemes, and ultimately to achieve a good balance between space and precision. The creation of quantized simulation with our system has large benefits in terms of memory consumption and performance, on a variety of hardware, from mobile devices to workstations with high-end GPUs. We can simulate with levels of resolution that were previously only achievable on systems with much more memory, such as multiple GPUs. For example, on a single GPU, we can simulate a Game of Life with 20 billion cells (8× compression per pixel), an Eulerian fluid system with 421 million active voxels (1.6× compression per voxel), and a hybrid Eulerian-Lagrangian elastic object simulation with 235 million particles (1.7× compression per particle). At the same time, quantized simulations create physically plausible results. Our quantization techniques are complementary to existing acceleration approaches of physical simulation: they can be used in combination with these existing approaches, such as sparse data structures, for even higher scalability and performance.

In this work, we make the case for Python as a first-class language for high-performance computing (HPC) applications. Our rationale is based on three trends: an increasing desire for applications to be user friendly; the shift toward such applications becoming primarily consumers of third-party application programming interfaces; and growing use of code generation for performance sensitive kernels. In each instance, we argue why Python is better placed to ride these trends than traditional languages such as C or Fortran. Further, we will also address two additional concerns regarding the suitability of Python: long start-up times and limited support for multithreading. An as exemplar of Python in HPC, we consider the high-order computational fluid dynamics code PyFR. The novel architecture of PyFR is described including examples showcasing its domain-specific language.

Smart contracts are contracts made of executable code running on Blockchain platforms. DasContract was introduced in 2019-2020 as a domain-specific language (DSL) for smart contract modeling with the ability to generate code in a programming language (Solidity), yet its environment exhibits various limitations, both in technical and design aspects. In this work, we propose a user interface with improved usability that includes tools for syntax verification, develop a software prototype, demonstrate its usage with a case study, and identify future lines of research.

Poster for award numbers SHF-1911019 and SHF-1909176.

Presentation given at the RD4 seminar of the Potsdam Institute for Climate Impact Research (PIK) on joint work with the TiPES WP6 team (Nicola Botta, Michel Crucifix, Marina Martínez Montero).

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.

When applying formal verification to a system that interacts with the real world, we must use a model of the environment. This model represents an abstraction of the actual environment, so it is necessarily incomplete and hence presents an issue for system verification. If the actual environment matches the model, then the verification is correct; however, if the environment falls outside the abstraction captured by the model, then we cannot guarantee that the system is well behaved. A solution to this problem consists in exploiting the model of the environment used for statically verifying the system’s behaviour and, if the verification succeeds, using it also for validating the model against the real environment via runtime verification. The article discusses this approach and demonstrates its feasibility by presenting its implementation on top of a framework integrating the Agent Java PathFinder model checker. A high-level Domain Specific Language is used to model the environment in a user-friendly way; the latter is then compiled to trace expressions for both static formal verification and runtime verification. To evaluate our approach, we apply it to two different case studies: an autonomous cruise control system and a simulation of the Mars Curiosity rover.

This article presents a framework, Genesis (genome analysis), to efficiently and flexibly accelerate generic data manipulation operations that have become performance bottlenecks in the genomic data processing pipeline utilizing FPGAs-as-a-service. Genesis conceptualizes genomic data as a very large relational database and uses extended SQL as a domain-specific language to construct data manipulation queries. To accelerate the queries, we designed a Genesis hardware library of efficient coarse-grained primitives that can be composed into a specialized dataflow architecture. This approach explores a systematic and scalable methodology to expedite domain-specific end-to-end accelerated system development and deployment.

Cyber attacks on IT and OT systems can have severe consequences for individuals and organizations, from water or energy distribution systems to online banking services. To respond to these threats, attack simulations can be used to assess the cyber security of systems to foster a higher degree of resilience against cyber attacks; the steps taken by an attacker to compromise sensitive system assets can be traced, and a time estimate can be computed from the initial step to the compromise of assets of interest. Previously, the Meta Attack Language (MAL) was introduced as a framework to develop security-oriented domain-specific languages. It allows attack simulations on modeled systems and analyzes weaknesses related to known attacks. To produce more realistic simulation results, probability distributions can be assigned to attack steps and defenses to describe the efforts required for attackers to exploit certain attack steps. However, research on assessing such probability distributions is scarce, and we often rely on security experts to model attackers’ efforts. To address this gap, we propose a method to assign probability distributions to the attack steps and defenses of MAL-based languages. We demonstrate the proposed method by assigning probability distributions to a MAL-based language. Finally, the resulting language is evaluated by modeling and simulating a known cyber attack

Parallel implementations of swarm intelligence algorithms such as the ant colony optimization (ACO) have been widely used to shorten the execution time when solving complex optimization problems. When aiming for a GPU environment, developing efficient parallel versions of such algorithms using CUDA can be a difficult and error-prone task even for experienced programmers. To overcome this issue, the parallel programming model ofAlgorithmic Skeletonssimplifies parallel programs by abstracting from low-level features. This is realized by defining common programming patterns (e.g. map, fold and zip) that later on will be converted to efficient parallel code. In this paper, we show how algorithmic skeletons formulated in the domain specific languageMusketcan cope with the development of a parallel implementation of ACO and how that compares to a low-level implementation. Our experimental results show thatMusketsuits the development of ACO. Besides making it easier for the programmer to deal with the parallelization aspects,Musketgenerates high performance code with similar execution times when compared to low-level implementations.

Neural network (NN) components are being increasingly incorporated into software systems. Neural network properties are determined by their architecture, as well as the training and testing datasets used. The engineering of datasets and neural networks is a challenging task that requires methods and tools to satisfy customers’ expectations. The lack of tools that support requirements specification languages makes it difficult for engineers to describe dataset and neural network recognition skill requirements. Existing approaches often rely on traditional ad hoc approaches, without precise requirement specifications for data selection criteria, to build these datasets. Moreover, these approaches do not focus on the requirements of the neural network’s expected recognition skills. We aim to overcome this issue by defining a domain-specific language that precisely specifies dataset requirements and expected recognition skills after training for an NN-based system. In this paper, we present a textual domain-specific language (DSL) called SEMKIS-DSL (Software Engineering Methodology for the Knowledge management of Intelligent Systems) that is designed to support software engineers in specifying the requirements and recognition skills of neural networks. This DSL is proposed in the context of our general SEMKIS development process for neural network engineering. We illustrate the DSL’s concepts using a running example that focuses on the recognition of handwritten digits. We show some requirements and recognition skills specifications and demonstrate how our DSL improves neural network recognition skills.

We present the Dynamic Stack Decider (DSD), a lightweight open-source control architecture. It combines different well-known approaches and is inspired by behavior trees as well as hierarchical state machines. The DSD allows to design and structure complex behavior of robots as well as software agents while providing easy maintainability. Challenges that often occur in robotics, i.e., a dynamic environment and situation uncertainty, remain well-manageable. Furthermore, it allows fast modifications of the control flow, while providing the state-fullness of a state machine. The approach allows developing software using a simple Domain Specific Language (DSL) which defines the control flow and two types of elements that contain the programmed parts. The framework takes care of executing the demanded portions of the code and gives, due to its stack-like internal representation, the ability to verify preconditions while maintaining a clear structure. The presented software was used in different robotic scenarios and showed great performance in terms of flexibility and structuredness.

U radu je predstavljena integracija NewWave workflow engine i OpenPonk alata. Model je nacrtan u OpenPonk editoru za meta-modelovanje. Plugin je zadužen za parsiranje modela u jeziku specifičnom za domen i mapiranje na NewWave elemente.

Solving partial differential equations on unstructured grids is a cornerstone of engineering and scientific computing. Nowadays, heterogeneous parallel platforms with CPUs, GPUs, and FPGAs enable energy-efficient and computationally demanding simulations. We developed the HighPerMeshes C++-embedded Domain-Specific Language (DSL) for bridging the abstraction gap between the mathematical and algorithmic formulation of mesh-based algorithms for PDE problems on the one hand and an increasing number of heterogeneous platforms with their different parallel programming and runtime models on the other hand. Thus, the HighPerMeshes DSL aims at higher productivity in the code development process for multiple target platforms. We introduce the concepts as well as the basic structure of the HighPerMeshes DSL, and demonstrate its usage with three examples, a Poisson and monodomain problem, respectively, solved by the continuous finite element method, and the discontinuous Galerkin method for Maxwell’s equation. The mapping of the abstract algorithmic description onto parallel hardware, including distributed memory compute clusters, is presented. Finally, the achievable performance and scalability are demonstrated for a typical example problem on a multi-core CPU cluster.

Domain adaptation in sentiment analysis is one of the areas where a classifier trained in one domain often classifies sentiments poorly when applied to another domain due to domain-specific words. Extracting features and their relevant opinion words from different domain sources and mapping them to the target domains are herculean tasks as far as domain adaptation is concerned. In this paper, the feature extraction technique is refined by which the mapping task is enhanced. The feature extraction technique uses both the syntactic and semantic properties of the features for extracting similar words. The features are further refined by merging synonyms and by replacing negative polarity terms with the appropriate antonyms. This refinement in the feature selection improves the mapping functionality of the domain adaptation and also exploits the relationship between domain-specific words and domain-independent words from different domains.

Both music creation tools and novice coding environments often use highly visual interfaces to aid in writing, editing, and navigation. Such designs fail to include blind users and may be totally inaccessible. This work sets out to develop a novel domain specific language, interface, and curriculum in partnership with students and teachers at the Filomen M. D'Agostino Greenberg (FMDG) School, a community music school that reaches blind and visually impaired musicians of all ages and skill levels. The project will consist of an iterative co-design phase and an implementation/evaluation phase in which a small number of students at the school will use the technology during a music composition course to create original works.

Low code development environments are gaining attention due to their potential as a development paradigm for very large scale adoption in the future IT. In this paper, we propose a method to extend the (application) Domain Specific Languages supported by two low code development environments based on formal models, namely DIME (native Java) and Pyro (native Python), to include functionalities hosted on heterogeneous technologies and platforms. For this we follow the analogy of micro services. After this integration, both environments can leverage the communication with pre-existing remote RESTful and enterprise systems’ services, in our case Amazon Web Services (AWS) (but this can be easily generalized to other cloud platforms). Developers can this way utilize within DIME and Pyro the potential of sophisticated services, potentially the entire Python and AWS ecosystems, as libraries of drag and drop components in their model driven, low-code style. The new DSLs are made available in DIME and Pyro as collections of implemented SIBs and blocks. Due to the specific capabilities and checks underlying the DIME and Pyro platforms, the individual DSL functionalities are automatically validated for semantic and syntactical errors in both environments.

Static analysis is an essential way to find code smells and bugs. It checks the source code without execution and no test cases are required, therefore its cost is lower than testing. Moreover, static analysis can help in software engineering comprehensively, since static analysis can be used for the validation of code conventions, for measuring software complexity and for executing code refactorings as well. Symbolic execution is a static analysis method where the variables (e.g. input data) are interpreted with symbolic values. Clang Static Analyzer is a powerful symbolic execution engine based on the Clang compiler infrastructure that can be used with C, C++ and Objective-C. Validation of resources’ usage (e.g. files, memory) requires finite state automata (FSA) for modeling the state of resource (e.g. locked or acquired resource). In this paper, we argue for an approach in which automata are in-use during symbolic execution. The generic automaton can be customized for different resources. We present our domain-specific language to define automata in terms of syntactic and semantic rules. We have developed a tool for this approach which parses the automaton and generates Clang Static Analyzer checker that can be used in the symbolic execution engine. We show an example automaton in our domain-specific language and the usage of generated checker.

Macros provide a powerful means of extending languages. They have proven useful in both general-purpose and domain-specific programming contexts. This paper presents an architecture for implementing macro-extensible DSLs on top of macro-extensible host languages. The macro expanders of these DSLs inherit the syntax system, hygienic expansion, and more from the host. They transform the extensible DSL syntax into a DSL core language. This arrangement has several important consequences. It becomes straightforward to integrate the syntax of various DSLs and the host language when their expanders share these inherited components. Also, a DSL compiler may be designed around a fixed core language, even for an extensible DSL. Finally, macros empower programmers to safely grow DSLs on their own and tailor them to their needs.

A robot’s code needs to sense the environment, control the hardware, and communicate with other robots. Current programming languages do not provide suitable abstractions that are independent of hardware platforms. Currently, developing robot applications requires detailed knowledge of signal processing, control, path planning, network protocols, and various platform-specific details. Further, porting applications across hardware platforms remains tedious. We present Koord—a domain specific language for distributed robotics—which abstracts platform-specific functions for sensing, communication, and low-level control. Koord makes the platform-independent control and coordination code portable and modularly verifiable. Koord raises the level of abstraction in programming by providing distributed shared memory for coordination and port interfaces for sensing and control. We have developed the formal executable semantics of Koord in the K framework. With this symbolic execution engine, we can identify assumptions (proof obligations) needed for gaining high assurance from Koord applications. We illustrate the power of Koord through three applications: formation flight, distributed delivery, and distributed mapping. We also use the three applications to demonstrate how platform-independent proof obligations can be discharged using the Koord Prover while platform-specific proof obligations can be checked by verifying the obligations using physics-based models and hybrid verification tools.

As a part of domain-specific development, Domain-Specific Language (DSL) is widely used in both the academia and industry to solve different aspects of the problems in engineering. A DSL is a customized language whose expressiveness is tailored to a well-defined application domain, so as to offer an effective interface for the domain experts. To mitigate the programming complexity of the General-Purpose Programming Languages, and meanwhile maintain the precise expression towards some exact engineering domains, DSLs present a higher level of abstraction than low-level interfaces, while providing much more flexibility than high-level interfaces. Nevertheless, it lacks a survey to have a systematic overview of the essential commonalities shared by those works. In this survey, we take a brand-new perspective, to categorize the state-of-the-art works into different categories, tailored to three fundamental implementation concerns of DSLs: abstract syntax, concrete syntax, and semantics. Specifically, they are characterized according to their parsing and mapping strategy (external/internal) between the abstract syntax and concrete syntax, the mapping results (textual/graphical symbols), and also the functions they emphasize (modeling, visualizing, etc.). Integrated with the literature, we finally summarized the research overview of DSLs.

Verification of correctness of control programs is an essential task in the development of space electronics; it is difficult and typically outweighs design and programming tasks in terms of development hours. This article presents a verification approach designed to help spacecraft engineers reduce the effort required for formal verification of low-level control programs executed on custom hardware. The verification approach is demonstrated on an industrial case study. We present a REDuced instruction set for Fixed-point and INteger arithmetic (REDFIN), a processing core used in space missions, and its formal semantics expressed using the proposed metalanguage for state transformers, followed by examples of verification of simple control programs.

Ad hoc code generation is a state-of-the-art processing paradigm for database execution engines. It minimizes resource consumption by generating specialized code, tailored and streamlined for the single query at hand. In this work, we apply ad hoc code generation to regular path queries (RPQs), an advanced query type in declarative graph query languages. We investigate code generation from multiple angles. We propose COAT, an embedded domain specific language (EDSL) in C++ to improve accessibility of code generation by simplifying the interaction with compiler APIs. Furthermore, we analyze and compare two back ends for COAT providing the just-in-time (JIT) compilation functionality: LLVM, a compiler framework popularly used in databases for code generation, and AsmJit, a JIT assembler with very low compilation latency. We evaluate various compilation techniques for RPQs on different synthetic graph workloads.

Due to the conceptual discrepancy between legal contract terms and code, understanding and creating smart contracts without errors can be difficult. This article proposes smart contract design patterns and their automated application through (the use of) a domain-specific language and code generation.

Using language adequately within technology tasks is part of technological literacy. However, this can be challenging for students, and a teacher may need to help students to master aspects of domain specific language that matter for the task at hand. In this study, a curricular design was developed through a series of trials, with the aim to arrive at general principles for a pedagogy that helps students to write about an engineering (electronics) design. The curricular design was theoretically anchored in ‘genre pedagogy’. The interventions were carried out by one experienced teacher in one course, during three consecutive cycles of trialling and improving the curricular design. The resulting design principles for teaching to write about (engineering) design are concerned with: a relevant, complete and feasible focus on language; scaffolding the writing process; procedures for teacher support. For each of these, specifications are described.

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.

Runtime verification (RV) consists in dynamically verifying that the event traces generated by single runs of a system under scrutiny (SUS) are compliant with the formal specification of its expected properties. RML (Runtime Monitoring Language) is a simple but expressive Domain Specific Language for RV; its semantics is based on a trace calculus formalized by a deterministic rewriting system which drives the implementation of the interpreter of the monitors generated by the RML compiler from the specifications. While determinism of the trace calculus ensures better performances of the generated monitors, it makes the semantics of its operators less intuitive. In this paper we move a first step towards a compositional semantics of the RML trace calculus, by interpreting its basic operators as operations on sets of instantiated event traces and by proving that such an interpretation is equivalent to the operational semantics of the calculus., In Proceedings EXPRESS/SOS 2020, arXiv:2008.12414. Author extended version is arXiv:2008.06453

This article targets the Incremental View Maintenance (IVM) of sophisticated analytics (such as statistical models, machine learning programs, and graph algorithms) expressed as linear algebra programs. We present LAGO, a unified framework for linear algebra that automatically synthesizes efficient incremental trigger programs, thereby freeing the user from error-prone manual derivations, performance tuning, and low-level implementation details. The key technique underlying our framework is abstract interpretation, which is used to infer various properties of analytical programs. These properties give the reasoning power required for the automatic synthesis of efficient incremental triggers. We evaluate the effectiveness of our framework on a wide range of applications from regression models to graph computations.

Invertibility is a fundamental concept in computer science, with various manifestations in software development (serializer/deserializer, parser/printer, redo/undo, compressor/decompressor, and so on). Full invertibility necessarily requires bijectivity, but the direct approach of composing bijective functions to develop invertible programs is too restrictive to be useful. In this paper, we take a different approach by focusing on partially-invertible functions—functions that become invertible if some of their arguments are fixed. The simplest example of such is addition, which becomes invertible when fixing one of the operands. More involved examples include entropy-based compression methods (e.g., Huffman coding), which carry the occurrence frequency of input symbols (in certain formats such as Huffman tree), and fixing this frequency information makes the compression methods invertible. We develop a language Sparcl for programming such functions in a natural way, where partial-invertibility is the norm and bijectivity is a special case, hence gaining significant expressiveness without compromising correctness. The challenge in designing such a language is to allow ordinary programming (the “partially” part) to interact with the invertible part freely, and yet guarantee invertibility by construction. The language Sparcl is linear-typed, and has a type constructor to distinguish data that are subject to invertible computation and those that are not. We present the syntax, type system, and semantics of the language, and prove that Sparcl correctly guarantees invertibility for its programs. We demonstrate the expressiveness of Sparcl with examples including tree rebuilding from preorder and inorder traversals and Huffman coding.

While many cluster and grid computing frameworks are available, the task of building secure distributed systems or implementing distributed algorithms continue to be a challenging task due to the inherent distributed nature of such systems with multiple failure modes and security issues. In this paper, we present the design and development of remote method delegation (RMD), which is a secure lightweight grid computing platform with load balancing and code migration. RMD is focused on improving the usability issues that plague related industry solutions. The platform is implemented on the JVM (Java Virtual Machine) and supports the Java and Kotlin programming languages, however, the platform should theoretically work with other JVM languages. RMD was designed to simplify the implementation of distributed algorithms by providing a Kotlin DSL (domain specific language) that allows the programmer to define jobs within dedicated code blocks. Users from around the world can donate their own computing resources by hosting their own job server. RMD is secured by placing all untrusted code within a sandbox environment that prevents potentially malicious actions from taking place. To demonstrate the feasibility of the proposed model, a proof of concept implementation has been constructed with real examples demonstrating the usefulness of the proposed solution.

The construction of models of system behavior is of great importance throughout science and engineering. In bioengineering and bionanotechnology, these often take the form of dynamic models that specify the evolution of different species over time. To ensure that scientific observations and conclusions are consistent and that systems can be reliably engineered on the basis of model predictions, it is important that models of biomolecular systems can be constructed in a reliable, principled, and efficient manner. This review focuses on efforts to address this need by using domain-specific programming languages as the basis for custom design tools for researchers working on computational nucleic acid devices, where a domain-specific language is simply a programming language tailored to a particular application domain. The underlying thesis of our review is that there is a continuum of practical implementation strategies for computational nucleic acid systems, which can all benefit from appropriate domain-specific languages and software design tools. We emphasize the need for specialized yet flexible tools that can be realized using domain-specific languages that compile to more general-purpose representations.