Search

Current practice in simulation and implementation of robot controllers is usually undertaken with guidance from high-level design diagrams and pseudocode. Thus, no rigorous connection between the design and the development of a robot controller is established. This paper presents a framework for designing robotic controllers with support for automatic generation of executable code and automatic property checking. A state-machine based notation, RoboChart, and a tool (RoboTool) that implements the automatic generation of code and mathematical models from the designed controllers are presented. We demonstrate the application of RoboChart and its related tool through a case study of a robot performing an exploration task. The automatically generated code is platform independent and is used in both simulation and two different physical robotic platforms. Properties are formally checked against the mathematical models generated by RoboTool, and further validated in the actual simulations and physical experiments. The tool not only provides engineers with a way of designing robotic controllers formally but also paves the way for correct implementation of robotic systems. [ABSTRACT FROM AUTHOR]

Copyright of Journal of Cryptologic Research (2097-4116) is the property of Editorial Board of Journal of Cryptologic Research 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.)

The importance of smart contracts at the legal level is increasing. However, the contract is written in natural language, and the computers cannot process it directly. Thus, accurately understanding contract content and meaning representation remains challenging. This problem leads to a lack of regularization in generating smart contract programs and legal recognition and effectiveness. Therefore, it is necessary to develop a new approach to transform real-life legal contracts into smart contract programs and ensure the regularization of legal element extraction and program conversion. In this paper, we propose a contract text markup language (CTML), which is a normative computer processing language for expressing meaning in legal contracts. A method for regulating the content and meaning representation of legal contract text is established by annotating the content and meaning representation of the syntax, structure, and vocabulary in the contract using CTML to achieve the extraction and conversion of contract elements. First, a contract metamodel of CTML, which includes a three-layer “element−property−component” semantic structure and metadata markup representation, is established. Thereafter, the contract text information is gradually refined from “large to small” and “coarse to fine” to build the corresponding relationship from real-life contracts to smart legal contracts. Furthermore, the syntax of CTML is designed such that the legal elements can be extracted and regularized to form an annotated contract using CTML. Second, we designed specific conversion rules from CTML to smart legal contract language to generate smart legal contract programs by recursively abstracting syntax trees and establishing a mapping relationship. These rules help users write contracts, improve the efficiency of converting contract text to executable code, and ensure that smart legal contracts are written on solid grounds, thereby improving the conversion chain from legal contracts to executable smart contracts. In addition, considering a factoring contract as an example, we illustrated the details of semantic extraction and code generation. Accordingly, the contract semantic extraction is clearer, the conversion is more normative, and the code development is more effective. Thus, the proposed CTML provides an alternative regularization method to generate smart legal contracts.

The Internet of Things (IoT) has revolutionized numerous sectors, with healthcare being a prominent beneficiary. One key area of advancement is Ambient Assisted Living (AAL), which leverages Information and Communication Technologies (ICT) like IoT to improve the quality of life for vulnerable populations, particularly seniors. However, despite efforts to tailor solutions to the needs of these environments, the prevailing approach often becomes overly focused on intricate implementation details rather than the core characteristics of the problem domain. This narrow focus inhibits generalization and leads to unsustainable solutions due to these environments’ diverse, dynamic, and scalable nature. In response, emerging technology paradigms, such as Fog Computing (FC), have emerged to enhance performance and other quality aspects. FC enables the deployment of distributed, latency-aware applications and services. Therefore, this paper introduces FOGAAL, a Domain-Specific Language (DSL) tool crafted to design AAL architectures, including the FC advantages. To demonstrate FOGAAL’s practical applicability, this contribution uses FOGAAL to build an AAL architecture for a real scenario; in addition, it has an empirical evaluation employing the Technology Acceptance Model (TAM) to gauge user perceptions while utilizing the tool for modeling AAL Architectures. The evaluation, conducted as a quasi-experiment, underscore the tool’s alignment with requirements and its potential for adoption, as evidenced by software engineers who have expressed their intention to use FOGAAL when creating architecture for AAL environments.

Copyright of Dokuz Eylul University Muhendislik Faculty of Engineering Journal of Science & Engineering / Dokuz Eylül Üniversitesi Mühendislik Fakültesi Fen ve Mühendislik Dergisi is the property of Dokuz Eylul Universitesi Muhendislik Fakultesi Fen ve Muhendislik Dergisi 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.)

Block cipher (BC) is a type of symmetric cipher used to encrypt data. Despite its advantages, it faces a substantial challenge. Writing the script code for the BC scheme accurately using General-Purpose Programming Languages (GPPLs) poses a significant challenge for programmers. The aim of this paper is to present the first graphical domain-specific modeling language (DSML) for designing and implementing BC algorithms, called BCLang. It is an extension to our previous DSML that was developed for Stream cipher. Programming efficiency and expressiveness were increased by reducing grammar and runtime errors and providing a high level of abstraction. BCLang provides the fundamental components of the BC three structures, which enable the programmer to design and implement BC algorithms in a graphical manner. Two keystream generation methods, performance analysis, and tests of the National Institute of Standards and Technology (NIST) for randomness analysis were provided. The presented language was evaluated based on five subjective metrics specific to graphical DSML evaluation. The design, evaluation details, and properties are explained in depth in this paper. [ABSTRACT FROM AUTHOR]

Data volumes are exploding as sensors proliferate and become more capable. Edge computing is envisioned as a path to distribute processing and reduce latency. Many models of Edge computing consider small devices running conventional software. Our model includes a more lightweight execution engine for network microservices and a network scheduling framework to configure network processing elements to process streams and direct the appropriate traffic to them. In this article, we describe INDIANA, a complete framework for in-network microservices. We will describe how the two components-the INDIANA network Processing Element (InPE) and the Flange Network Operating System (NOS)-work together to achieve effective in-network processing to improve performance in edge to cloud environments. Our processing elements provide lightweight compute units optimized for efficient stream processing. These elements are customizable and vary in sophistication and resource consumption. The Flange NOS provides first-class flow based reasoning to drive function placement, network configuration, and load balancing that can respond dynamically to network conditions. We describe design considerations and discuss our approach and implementations. We evaluate the performance of stream processing and examine the performance of several exemplar applications on networks of increasing scale and complexity. [ABSTRACT FROM AUTHOR]

Integrating simulation in the design process of production systems allows the predicted performance of design alternatives to be compared. However, many iterations of specifying the design, constructing the simulation model, performing simulation experiments, and evaluating the simulation results for each (re)design are required. The process of specifying, modelling, simulating, and evaluating a design can be automated using a framework for automated design space exploration of production systems. This paper presents a formal specification language for the design space of a production system topology. Using the specification of the design space, feasible designs can be generated. The language supports the specification of component types, component instances, and constraints such as how many instances of a type are allowed and how components are allowed to be connected. The specification language is validated through an adaptation of an industrial case study. [ABSTRACT FROM AUTHOR]

As the scale of digital circuit design increases, design and verification using conventional hardware description languages (HDLs), such as verilog-HDL and VHDL, limit efficiency. Consequently, high level synthesis (HLS), as well as domain specific languages (DSLs), which alternates conventional HDLs, are beginning to garner attention. We proposed a design framework that uses the C language as a register transfer level descriptive language. In this study, we introduced a LLVM compiler infrastructure to extend our previous work, support the C/C++ standard as the input code, and aggressively optimize the circuit design. In addition to supporting a single module generation, we extended our framework to support the hierarchical module description for efficient system design. We demonstrated the conversion of the input of C/C++ code into the verilog code, optimize its logic, and construct pipelined logic to achieve the original behavior in multiple clock cycles. Our framework offers a significantly efficient system-level hardware design and a powerful debugging environment with software development platforms and tool-sets. The generated hardware logic performs as well as or better than hand-written logic using conventional HDLs. [ABSTRACT FROM AUTHOR]

IntroductionThe complexity of Magnetic Resonance Imaging (MRI) sequences requires expert knowledge about the underlying contrast mechanisms to select from the wide range of available applications and protocols. Automation of this process using machine learning (ML) can support the radiologists and MR technicians by complementing their experience and finding the optimal MRI sequence and protocol for certain applications.MethodsWe define domain-specific languages (DSL) both for describing MRI sequences and for formulating clinical demands for sequence optimization. By using various abstraction levels, we allow different key users exact definitions of MRI sequences and make them more accessible to ML. We use a vendor-independent MRI framework (gammaSTAR) to build sequences that are formulated by the DSL and export them using the generic file format introduced by the Pulseq framework, making it possible to simulate phantom data using the open-source MR simulation framework JEMRIS to build a training database that relates input MRI sequences to output sets of metrics. Utilizing ML techniques, we learn this correspondence to allow efficient optimization of MRI sequences meeting the clinical demands formulated as a starting point.ResultsML methods are capable of capturing the relation of input and simulated output parameters. Evolutionary algorithms show promising results in finding optimal MRI sequences with regards to the training data. Simulated and acquired MRI data show high correspondence to the initial set of requirements.DiscussionThis work has the potential to offer optimal solutions for different clinical scenarios, potentially reducing exam times by preventing suboptimal MRI protocol settings. Future work needs to cover additional DSL layers of higher flexibility as well as an optimization of the underlying MRI simulation process together with an extension of the optimization method.

There is an inherent tension between knowledge representation and reasoning. For an optimal representation and validation, an expressive language should be used. For an optimal automated reasoning, a simple one is preferred. Which language should we choose for our legal knowledge representation if our goal is to apply automated legal reasoning? In this paper, we investigate the properties and requirements of each of these two applications. We suggest that by using Legal Linguistic Templates, one can solve the above tension in some practical situations.

TVM (tensor virtual machine) is a deep learning compiler, that translates the deep learning operators described by tensor expression to TVM IR (TVM intermediate representation) programs. After a series of operatorlevel optimizations on TVM IR, TVM generates the target code across diverse hardware back-ends. Tensor expression, a domain- specific language for tensor computation, performs loop transformation to operators. The result of loop transformation is a number of complicated expressions emerging in nested loop statements, which contain loop invariant code. However, in the context of deep learning applications, the traditional loop invariant code motion algorithm has severe limitations. Firstly, it's difficult to determine the extra-benefit of moving certain invariant code out of loops. Secondly, it's difficult to detect loop invariant code which has different orders of operands. Thirdly, it cannot process nested condition expressions well. Furthermore, there are conflicts with target hardware compiler optimizations. The application of loop invariant code motion technique is constrained by the aforementioned problems. In this paper, a new loop invariant code motion algorithm is proposed, which takes deep learning application characteristics into consideration in a heuristics way. The algorithm normalizes the program by manipulating the expression operands and simplifying the nested condition expression. This paper introduces a new cost model, which evaluates the cost of moving certain loop invariant code while the characteristics of TVM IR and target hardware back-ends are fully considered. The algorithm is implemented as a registered TVM pass on opensource compiler TVM version 0.7. To testify the effectiveness and correctness of this algorithm, experiments are conducted on TVM TOPI benchmark with 27 operators and 511 test cases under different input. Experimental results show that this algorithm improves 47.6% of operators'performance, and achieves speedups up to 40.0%. [ABSTRACT FROM AUTHOR]

We propose a technique for synthesizing bidirectional programs from the corresponding unidirectional code plus input/output examples. The core ideas are: (1) constructing a sketch using the given unidirectional program as a specification, and (2) filling the sketch in a modular fashion by exploiting the properties of bidirectional programs. These ideas are enabled by our choice of programming language, HOBiT, which is specifically designed to maintain the unidirectional program structure in bidirectional programming, and keep the parts that control bidirectional behavior modular. To evaluate our approach, we implemented it in a tool called Synbit and used it to generate bidirectional programs for intricate microbenchmarks, as well as for a few larger, more realistic problems. We also compared Synbit to a state-of-the-art unidirectional synthesis tool on the task of synthesizing backward computations. This is an extended version of the paper "Synbit: Synthesizing Bidirectional Programs using Unidirectional Sketches", published at OOPSLA 2021. In addition to the OOPSLA'21 paper, this journal will contain additional formalization and detailed examples. [ABSTRACT FROM AUTHOR]

With the advancement of blockchain, smart contracts have become increasingly popular. However, the uncertain status by law severely limits their practical applications. To address the problem, smart legal contract (SLC) is proposed as a transitional technology between legal and smart contracts. Starting with the basic concept of SLCs, in this paper, we discussed the legalization of smart legal contracts based on the requirements of existing legislation items and highlight that legalization should meet three elementary principles, including the specified grammatical requirements (for regulating terminology and eliminating ambiguity), the principle of nonempowerment (for resolving the inherent contradiction between automatic execution and the rights of parties), and examination criteria (for handling legal validity and code security issues). Moreover, we analyzed SLC’s legal effect by taking typical smart legal contract languages, SPESC and CML as examples, and show that the contract program or chaincode has the same legal effect as the original contract, if and only if they satisfy three necessary conditions: (1) adopting the technical specification for generation and conclusion of SLCs; (2) complying with three abovementioned elementary principles; and (3) agreeing on declaration with the same legal effect. Furthermore, investigating the smart contract architecture and deployment, the legal status of both contract program and compiled chaincode was demonstrated in legal analysis of the deployed smart contract. Last, we discussed and evaluated the current situation of smart legal contract logic models and language models on SLCs. This work shows that the research on smart legal contracts is a suitable approach to guarantee the legal status of smart contracts, and the results will contribute to grasping the future research directions in several fields, such as contract logic, arbitration process, and formal verification, from the existing legislation viewpoint.

Event-driven programming based on Event-Condition-Action (ECA) rules allows users to define complex automation routines in a simple, declarative way; for this reason, in recent years ECA rules have been adopted by the majority of companies in the Internet of Things (IoT) industry as a promising paradigm for implementing ubiquitous and pervasive systems. Unfortunately, programming simplicity comes to a price: most implementations of ECA rules are bound to a strongly centralized communication infrastructure, that poses serious limitations on the application scenarios for the IoT, due to scalability, security and availability issues. To mitigate these issues, recent works introduced abstractions for communication and coordination of ensembles of IoT devices in a decentralized setting, effectively moving the computation towards the edge of the network without sacrificing the programming simplicity prerogative of ECA rules. In particular, Attribute-based memory Updates is a communication model transparently enhancing ECA rules-based systems with an interaction mechanism where communication is similar to broadcast but actual receivers are selected on the spot, by means of predicates (i.e., properties) over devices attributes. In this paper, we introduce AbU-dsl, a Domain Specific Language for the IoT that compiles on top of an implementation of Attribute-based memory Updates. In this way, AbU-dsl provides a practical development interface, based on ECA rules, to effectively program IoT devices in a fully decentralized setting, by exploiting a full-fledged attribute-based interaction model. Thus, programmers can specify interactions between devices in a declarative way, abstracting from details such as devices identity, number, or even their existence, without the need for a central controlling service.

Currently the design of mechanical parts requires multiple iterations to reach a manufacturable part. This leads to high rework costs and long lead times, as manual checking of design rules is time consuming and error prone. By formalizing manufacturing knowledge, the design rules and the process window boundary become more clear and actionable for both designers and manufacturers. This paper proposes a design rule formalism that simplifies the formalization process by means of decomposing rules in expressions of surface properties and bounds. Textual design rule expressions are converted in Abstract Syntax Trees. Such a representation describes the computation steps for a design rule evaluation. We propose an efficient method for automatic manufacturability assessment of CAD models. We argue that a discretization is needed for analysis of relevant surface properties. The results are validated on an injection moulding case, whith illustration of the added value of the approach. [ABSTRACT FROM AUTHOR]

A domain specific language (DSL), called the Finite Element Interpreter (FEI), is developed and presented. The FEI DSL is designed and developed specifically for linear and nonlinear finite element analysis of static and dynamic behavior of soils and structures. While the main focus is on soils and structures, developed DSL can be used in many other fields of linear and nonlinear analysis of solids and structures in other fields of engineering. The design of FEI takes advantage of modern computer capabilities and text editing software to develop a language which promotes (i) self-documenting analysis scripts, (ii) promotes understanding of finite element modeling, (iii)awareness to physical units, (iv) provides problem specific language constructs, and (v) is safe to execute. Simple examples are used to describe FEI DSL, while many other, more sophisticated, realistic examples are available through the Real-ESSI web site http://real-essi.info. • Domain Specific Language for Finite Element Method. • Self-documenting analysis scripts. • Awareness to physical units. [ABSTRACT FROM AUTHOR]

Full-Waveform Inversion (FWI) is a high-resolution numerical technique for seismic waves used to estimate the physical characteristics of a subsurface region. The continuous problem involves solving an inverse problem on an infinite domain, which is impractical from a computational perspective. In limited area models, absorbing boundaries conditions (ABCs) are usually imposed, to avoid wave reflections. Several relevant ABCs have been proposed, with extensive literature on their effectiveness on the direct wave problem. Here, we investigate and compare the theoretical and computational characteristics of several ABCs in the full inverse problem. After a brief review of the most widely used ABCs, we derive their formulations in their respective adjoint problems. The different ABCs are implemented in a highly optimized domain-specific language (DLS) computational framework, Devito, which targets seismic modeling problems. We evaluate the effectiveness, computational efficiency, and memory requirements of the ABC methods, considering from simple models to realistic ones. Our findings reveal that, even though the popular Perfectly Matching Layers (PMLs) are effective in avoiding wave reflections on the boundaries, they can be computationally more demanding than less used Hybrid ABCs. We show here that a proposed Hybrid ABC formulation, with nested Higdon's boundary conditions, is the most cost-effective method among the methods considered here, being as effective, or more, as PML and other schemes, but being computationally more efficient. [ABSTRACT FROM AUTHOR]