Search

Mesh processing algorithms are often communicated via concise mathematical notation (e.g., summation over mesh neighborhoods). However, conversion of notation into working code remains a time-consuming and error-prone process, which requires arcane knowledge of low-level data structures and libraries—impeding rapid exploration of high-level algorithms. We address this problem by introducing a domain-specific language (DSL) for mesh processing called I MESH, which resembles notation commonly used in visual and geometric computing and automates the process of converting notation into code. The centerpiece of our language is a flexible notation for specifying and manipulating neighborhoods of a cell complex, internally represented via standard operations on sparse boundary matrices. This layered design enables natural expression of algorithms while minimizing demands on a code generation backend. In particular, by integrating I MESH with the linear algebra features of the I LA DSL and adding support for automatic differentiation, we can rapidly implement a rich variety of algorithms on point clouds, surface meshes, and volume meshes. [ABSTRACT FROM AUTHOR]

Software architects and developers often use Domain-Specific Languages (DSLs) to model or code applications. However, designing a DSL that effectively represents its domain can be a challenge, potentially contributing to poor uptake and usage. To the best of our knowledge, one issue is that DSL designers may evaluate their language’s usability using ad hoc processes, due to a lack of expertise in usability evaluation. Additionally, current approaches lack well-defined processes and may not yield the desired results for DSL designers. Therefore, DSL designers require a well-defined usability evaluation process to assess how architects, developers, and end users perceive their DSL. This paper introduces Usa-DSL, a Usability Evaluation Process for Domain-Specific Languages. Usa-DSL aims to assist DSL designers in evaluating their languages in terms of ease and quality of use, without requiring deep knowledge of usability evaluation. We analyze the feasibility of Usa-DSL and show that it is a useful and user-friendly tool for evaluating DSLs.

The W3C Web of Things (WoT) is a leading technology that facilitates dynamic information management in the Internet of Things (IoT). In most IoT scenarios, devices and their associated information change continuously, generating a large amount of data. Hence, to correctly use the information and the data generated by different devices, a new perspective of managing and ensuring data quality is recommended. Applying Data Science techniques to create the data model can help to manage and ensure data quality by creating a common schema that can be reused in future projects, as well as producing recommendations to facilitate Service Discovery. In addition, due to the dynamic devices that change over time or under specific circumstances, the data model created must be sufficiently abstract to add new instances and to support new requirements that devices should incorporate. The use of models helps to raise the abstraction level, adapting it to the continuous changes of devices by defining instances associated with the data model. This paper proposes two data models: one for Cyber‐Physical Systems (CPS) to define device information fetched by a Discovery Service, and another for applying Deep Learning in natural language problems through a Transformer approach. The latter matches user queries in natural language sentences with WoT devices or services. These data models expand the Thing Description model to help find similar CPSs by giving a confidence level to each CPS based on features such as security and the number of times the device was accessed. The results show how the proposed models support the search process of CPSs in syntactic and natural language searches. Furthermore, the four levels of the FAIR principles are validated for the proposed data models, thus ensuring the data's transparency, reproducibility, and reusability. [ABSTRACT FROM AUTHOR]

A safety-critical system is a system in which the software malfunctioning could result in death, injury, or damage to the environment. Addressing safety concerns early on at the architecture design level is critical to guide the subsequent life cycle activities to ensure that the eventual system is reliable. A fundamental approach to address safety at the design level is the adoption of architectural tactics. It is crucial for safety-critical systems to correctly implement the constraints as defined by the selected safety tactics. Given the limitations of traditional safety measures, particularly in conducting thorough analyses of safety tactics at the architectural design level, our motivation is to close this gap by integrating safety tactics and fault-based mutation testing. This article proposes a systematic approach for assessing the adequacy of test suites of safety-critical systems based on these architectural safety tactics. Our proposed approach involves the integration of safety tactics and fault-based mutation testing to comprehensively assess the adequacy of test suites in safety-critical systems. At the core of our methodology is the adoption of architectural safety tactics, addressing potential issues at the design level. We leverage fault-based testing, utilizing a dedicated metamodel and domain-specific language (DSL) to model safety views and their relation to the code. We use a case study to evaluate the effectiveness of our approach using fault-injection techniques. Our study shows that this systematic approach is feasible and effective for test suite assessment of safety-critical systems. [ABSTRACT FROM AUTHOR]

Technology roadmapping is an important yet challenging strategic process involving inter‐disciplinary knowledge and requiring key decision‐makers participation. To improve and facilitate this activity, a concept of model‐based technology roadmapping has been proposed in the literature as an application of model‐based systems engineering practices to the strategic planning domain. At the same time, many modern complex technical systems are required to be not only functional, efficient, and reliable, but also useful, usable, and desirable, which shifts the focus of planning to the user experience (UX). In this paper, we developed a Domain‐specific language that uniformly represents key concepts related to the four levels essential for strategic planning in the user‐oriented business context: market, UX design, engineering design, and technology. A collaborative interactive software was developed to support the proposed methodology. As a case study, a sustainable transformation of the automotive sector was tested and implemented in the software. [ABSTRACT FROM AUTHOR]

Large-scale distributed systems are becoming key engines of the IT industry due to their scalability and extensibility. A distributed system often involves numerous complex interactions among components, suffering anomalies such as data inconsistencies between components and unanticipated delays in response times. Existing anomaly detection techniques, which extract knowledge from system logs using either statistical or machine learning techniques, exhibit limitations. Statistical techniques often miss implicit anomalies that are related to complex interactions manifested by logs, whereas machine learning techniques lack explainability and they are usually sensitive to log variations. In this paper, we propose KAD, a knowledge formalization-based anomaly detection approach for distributed systems. KAD includes a general knowledge description language (KDL), leveraging the general structure of system logs and extended Backus-Naur form (EBNF) for complex knowledge extraction. Particularly, the semantic set is constructed based on the bidirectional encoder representation from the transformer (BERT) model to improve the expressive capabilities of KDL in knowledge description. In addition, KAD incorporates distributed scheduling computation module to improve the efficiency of anomaly detection processes. Experimental results based on two widely used benchmarks show that KAD can accurately describe the knowledge associated with anomalies, with a high F1-score in detecting various anomaly types. [ABSTRACT FROM AUTHOR]

In this paper, we focus on some aspects of structural operational semantics for a selected domain-specific language for robot control. After defining a syntax for two independent languages for control of a robot's movements, we define a structural operational semantics for them. The integrated part of structural operational semantics is abstract implementation, which consists of defining abstract machine and transformation of a programming language to abstract machine instructions. The achieved results as well as the mentioned research are a part of the research in the field of semantic methods, where we focus on the formalization of semantic methods for software engineering. This area is also very important for the training of students and young IT experts because the semantic methods can help to understand program behavior and detect errors in program design. To make the teaching of formal semantics in the field of domain-specific languages more attractive, we have also prepared an application that serves to visualize the individual steps of the program on an abstract machine - simulation of translated code with visualization of a robot's movement. [ABSTRACT FROM AUTHOR]

This paper focuses on the formal semantics of programming languages, with a specific focus on Domain-Specific Languages (DSLs). It introduces the Robot DSL, characterized by total semantic functions, an infinite network size, and an obstacle-free environment. The study explores denotational and natural semantics, aiming to define and prove their equivalence. This work contributes to the understanding of programming languages with unique features, laying the groundwork for future developments in language design and formal semantics. [ABSTRACT FROM AUTHOR]

Convolutional Neural Networks (CNNs) have been utilised in many image and video processing applications. The convolution operator, also known as a spatial filter, is usually a linear operation, but this linearity compromises essential features and details inherent in the non-linearity present in many applications. However, due to its slow processing, the use of a nonlinear spatial filter is a significant bottleneck in many software applications. Further, due to their complexity, they are difficult to accelerate in FPGA or VLSI architectures. This paper presents novel FPGA implementations of linear and nonlinear spatial filters. More specifically, the arithmetic computations are carried out in custom floating-point, enabling a tradeoff of precision and hardware compactness, reducing algorithm development time. Further, we show that it is possible to process video at a resolution of 1080p with a frame rate of 60 frames per second, using a low-cost FPGA board. Finally, we show that using a domain-specific language will allow the rapid prototyping of image processing algorithms in custom floating-point arithmetic, allowing non-experts to quickly develop real-time video processing applications.

Rapid technological advancements have resulted in increasingly complex software systems, posing challenges during development in terms of time and cost. Adopting domain-specific modeling (DSM) brings numerous benefits to software engineering, including enhanced efficiency, improved maintenance capabilities, higher software quality, reduced development time, and increased potential for cost-effective software solutions through improved reusability. Despite the proven effectiveness of DSM in various domains, a study summarizing recent advancements is hard to find in the state-of-the-art. Therefore, in this article, we present a comprehensive systematic literature review that examines the application of DSM in various domains (4). We selected 99 studies and classified those into four categories, i.e., meta-modeling (42), domain-specific languages (39), UML profiles (9), and general (9) based on the use of DSM approaches. We identified various tools from the selected studies, i.e., 21 existing and 91 proposed or developed. Moreover, model-driven engineering (MDE) techniques, including validation (12), simulation (5), verification (4), and software architectural modeling (3), are presented and analyzed. We further explained the type of model transformation employed in each study, i.e., model-to-text (49) and model-to-model (4). Finally, the regions participating in DSM’s growth are also investigated. It is concluded that Ecore is the leading meta-modeling tool, Xtext is the often-used domain-specific tool, Sirius is graphical, and UPPAAL is the most utilized verification tool identified. Moreover, Validation is a frequently used MDE technique, and Model-to-text transformation with Acceleo is the most utilized transformation type in the selected studies. The comprehensive results of this research provide valuable guidance for DSM researchers and practitioners in choosing a suitable tool and technique that meets their specific requirements.

Filtering is a fundamental tool in image processing, and its acceleration affects many applications. Therefore, various algorithmic and hardware accelerations have been proposed for filtering. Recursive processing using infinite impulse response (IIR) filtering is an efficient algorithm, and various hardware acceleration methods have been applied to IIR filtering. In addition, a domain-specific language (DSL) of RecFilter was proposed to generate efficient IIR code for various hardware applications as an extension of image processing language, Halide. Recursive filters based on sliding discrete cosine transform (SDCT) have been the most efficient approximations in recent years. For hardware acceleration, parallelization of recursive filters is challenging. One of the most efficient methods is tile-based parallelization. However, even if a function is optimized and modularized, it is not sufficiently optimized for applications where various pre/post-processing steps are coupled before and after filtering. Additionally, multiplatform deployment requires reimplementation of the code. In this study, we extended Halide for SDCT convolutions to realize efficient computing of image processing applications with filtering, named SlidingConv. The experimental results showed that SlidingConv is faster than the hand-tuned CPU code and 1/1900 of the hand-tuned code length, running more efficiently than de facto libraries like OpenCV. To verify its efficiency, we deployed the code on various hardware (x86/64 CPU with AVX2/AVX-512, ARM CPU, and GPU). In addition, we verified that the proposed method can accelerate image processing with pre/post-processing for filtering. Our code is available at https://fukushimalab.github.io/SlidingConv/.

Specification languages for runtime verification are commonly rooted in formal languages, such as temporal logic, automata, or regular expressions. We argue that, for practical purposes, specification languages for monitoring should allow language features similar to those found in general purpose programming languages, in addition to providing specialized monitoring constructs. Using a realistic and large event-log, we compare two such programming-oriented monitoring language systems to a temporal logic-based monitoring system that was previously evaluated on the same log. The first programming-oriented language is a library in Scala developed for runtime verification. The other language is a scripting language, originally developed for fast static code analysis. We formulate the same reasonably complex properties as in the temporal logic case, using both methods, and compare the efficiency with which they can be checked against the large event log, and the ease with which the properties can be formulated. [ABSTRACT FROM AUTHOR]

Conversational agents (CA) are software programs that can converse with users using natural language. They are now widely used in various domains, such as tourism, healthcare, and others, to perform tasks and provide permanent assistance to users by interacting with them in natural language. The development of such applications is a task that requires expertise in several fields, such as software engineering, machine learning, deep learning, and natural language processing (NLP). However, several platforms and frameworks on the market facilitate the building of CA, such as Dialogflow, Rasa, and others. Recently, several research studies have proposed solutions to reduce the workload of developers and designers by offering their model-driven development approaches using domain-specific languages (DSLs), which facilitate the automation of the development of CA. This work aims to provide an Overview of CA to identify and describe their architecture and the details of its key components. and discuss the tools and technologies for their development. At the same time, discover the research topics that focus on using DSLs for model-driven development to automate and speed up the creation of these agents and discover approaches and technologies employed to implement each of these DSLs. [ABSTRACT FROM AUTHOR]

In agent-based simulation methods and applications, discrete timestep approaches prevail. To support continuous-time agent-based simulation, we analyze how methods for simulating population-based Continuous- Time Markov Chains (CMTCs) can be adopted and derive implications for the concrete realization. To corroborate our findings, we develop an efficient internal domain-specific language (DSL) based on ML3, a modeling language for linked lives in demography. The design as an internal DSL, implemented within the Rust programming language, allows the modeler to exploit the complete feature set of the host language, such as data types and structures, when programming decision processes. A concise and expressive modeling of an agent’s discrete decisions and behavior introducing exponentially distributed sojourn times can be supported by adapting the concept of guarded commands from population-based CTMCs. The execution of models relies on an optimized version of the direct method. This method is a variant of stochastic simulation algorithms, an established method for executing population-based CTMCs in other application areas, notably biochemistry. To efficiently handle the large set of possible transitions inherent to continuous-time agent-based models, we use a dependency graph whose updating scheme caters to the dynamic dependencies within agent-based models and the need for efficient implementation. The presented case studies include implementations of a continuous-time, agent-based migration model and a comparative performance study based on an extended SIR model of infection spread, allowing us to draw conclusions about the impact of different design choices on efficiency. [ABSTRACT FROM AUTHOR]

Since its introduction by Mark Weiser, ubiquitous computing has received increased interest in the dawn of technological advancement. Supported by wireless technology advancement, embedded systems, miniaturization, and the integration of various intelligent and communicative devise, context-aware ubiquitous applications actively and intelligently use rich contextual information to assist their users. However, their designs are subject to continuous changes imposed by external factors. Nowadays, software engineering, particularly in the fields of Model-Driven Engineering, displays a strong tendency towards developing applications for pervasive computing. This trend is also fueled by the rise of generative artificial intelligence, paving the way for a new generation of no-code development tools and models specifically trained on open-source code repositories to generate applications from their descriptions. The specificities of our approach lies in starting with a graphical model expressed using a domain-specific language (DSL) composed of symbols and formal notations. This allows for graphically instantiating and editing applications, guiding and assisting experts from various engineering fields in defining ubiquitous applications that are eventually transformed into peculiar models. We believe that creating intelligent models is the best way to promote software development efficiency. We have used and evaluated recurrent neural networks, leveraging the recurrence of processing the same contextual information collected within this model, and enabling iterative adaptation to future evolutions in ubiquitous systems. We propose a prototype instantiated by our meta-model which tracks the movements of individuals who were positive for COVID-19 and confirmed to be contagious. Different deep learning models and classical machine learning techniques are considered and compared for the task of detection/classification of COVID-19. Results obtained from all techniques were evaluated with confusion matrices, accuracy, precision, recall and F1-score. In summary, most of the results are very impressive. Our deep learning approach used a RNN architecture produced up to 92.1% accuracy. With the recent development of OpenAI Codex, optimized for programming languages, we provided the same requirements to the Codex model and asked it to generate the source code for the COVID-19 application, comparing it with the application generated by our workshop. [ABSTRACT FROM AUTHOR]

Maintenance of Data Warehouse (DW) systems is a critical task because any downtime or data loss can have significant consequences on business applications. Existing DW maintenance solutions mostly rely on concrete technologies and tools that are dependent on: the platform on which the DW system was created; the specific data extraction, transformation, and loading (ETL) tool; and the database language the DW uses. Different languages for different versions of DW systems make organizing DW processes difficult, as minimal changes in the structure require major changes in the application code for managing ETL processes. This article proposes a domain-specific language (DSL) for ETL process management that mitigates these problems by centralizing all program logic, making it independent from a particular platform. This approach would simplify DW system maintenance. The platform-independent language proposed in this article also provides an easier way to create a unified environment to control DW processes, regardless of the language, environment, or ETL tool the DW uses. [ABSTRACT FROM AUTHOR]

In order to address the issue of rapid growth of program space in SQUARES, which led to low efficiency in program synthesis, a program space reducer based on deep neural network (DNN) was introduced into the SQUARES framework.A given ＆lt;Queried tables, Query result＆gt; pair was represented as a 2D tensor which was used as input for a DNN.And the output of the DNN was the relevance vector of the target SQL statement synthesis rules.Based on the output of the DNN, the last N rules with weak correlation to the target SQL statement were eliminated, thereby shrinking the program search space and improving the system synthesis efficiency.The architecture of DNN, the method of generating training datasets, and the training process of DNN were described in detail.Furthermore, experimental comparisons between PSR-SQUARES and other representative SQL reverse synthesis systems were conducted.The results show that the overall performance of PSR-SQUARES is superior to other synthesis systems to varying degrees, with the average synthesis time reduced from 251 s in SQUARES to 130 s and the target program synthesis success rate increased from 80% to 89%.

Maintenance of Data Warehouse (DW) systems is a critical task because any downtime or data loss can have significant consequences on business applications. Existing DW maintenance solutions mostly rely on concrete technologies and tools that are dependent on: the platform on which the DW system was created; the specific data extraction, transformation, and loading (ETL) tool; and the database language the DW uses. Different languages for different versions of DW systems make organizing DW processes difficult, as minimal changes in the structure require major changes in the application code for managing ETL processes. This article proposes a domain-specific language (DSL) for ETL process management that mitigates these problems by centralizing all program logic, making it independent from a particular platform. This approach would simplify DW system maintenance. The platform-independent language proposed in this article also provides an easier way to create a unified environment to control DW processes, regardless of the language, environment, or ETL tool the DW uses.

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. [ABSTRACT FROM AUTHOR]

Copyright of Journal on Communication / Tongxin Xuebao is the property of Journal on Communications Editorial Office and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

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.

To meet increasingly restrictive requirements and improve quality of service (QoS), Internet of Things (IoT) systems have embraced multi-layered architectures leveraging edge and fog computing. However, the dynamic and changing IoT environment can impact QoS due to unexpected events. Therefore, proactive evolution and adaptation of the IoT system becomes a necessity and concern. In this paper, we present a model-based approach for the specification and execution of self-adaptive multi-layered IoT systems. Our proposal comprises the design of a domain-specific language (DSL) for the specification of such architectures, and a runtime framework to support the system behaviuor and its self-adaptation at runtime. The code for the deployment of the IoT system and the execution of the runtime framework is automatically produced by our prototype code generator. Moreover, we also show and validate the extensibility of such DSL by applying it to the domain of underground mining. The complete infrastructure (modeling tool, generator and runtime components) is available in a online open source repository. [ABSTRACT FROM AUTHOR]

RADENN is a domain-specific language designed to rapidly develop fully connected neural networks for classification and regression problems. The primary objective of this language is to make neural network algorithms more accessible to a broader audience. RADENN is built on top of Keras API with Tensorflow as its back-end. This language follows the imperative paradigm; it uses dynamic scoping, is weakly typed, and utilizes type inference. The contribution of RADENN is to incorporate specific data types and built-in functions to facilitate the creation, training, and evaluation of neural networks. All these features make RADENN an ideal tool for Data Scientists, Data Analysts, Big Data Engineers, Software Enginers, and anyone who needs a fast and efficient way to create prototypes and models without extensive programming or deep learning knowledge. This work provides a detailed overview of the features of RADENN and compares it to Keras and PyTorch, which are currently among the most widely used libraries in industry and research.

Abstract Secure multiparty computation (MPC) is a cryptographic tool that allows computation on top of sensitive biomedical data without revealing private information to the involved entities. Here, we introduce Sequre, an easy-to-use, high-performance framework for developing performant MPC applications. Sequre offers a set of automatic compile-time optimizations that significantly improve the performance of MPC applications and incorporates the syntax of Python programming language to facilitate rapid application development. We demonstrate its usability and performance on various bioinformatics tasks showing up to 3–4 times increased speed over the existing pipelines with 7-fold reductions in codebase sizes.