This paper introduces a domain-specific modelling language (DSML) called DSML4JaCaMo to develop belief-desireintention (BDI) agents.The DSML's design covers aspects of Jason, Cartago, and Moise from viewpoints that follow the metamodelling approach.In this way, the DSML4JaCaMo enables graphical modelling of JaCaMo's multi-agent systems (MASs), providing comprehensive support for defining agents' beliefs, desires, and intentions (BDI) using Jason, specifying artifacts and their operations with Cartago, and outlining organizational structures and norms via Moise.The DSML's operational semantics ensure seamless integration of these components, facilitating automatic code generation and artifact construction for creating a JaCaMo-based system.The graphical syntax contributes to ease of use, making it accessible for novice and experienced developers.This work aims to enhance the JaCaMo ecosystem by offering a model-driven approach to provide abstraction on MAS development as well as facilitating design and implementation.

This paper proposes a new blockchain-based transaction verification infrastructure for co-payment and data verification for multi-modal public transportation systems.Our solution offers a decentralized platform that ensures secure copayments and data integrity while addressing interoperability, data security and transactional transparency.With a private blockchain, transportation providers act as nodes and validated, consensus-approved transactions increase trust and transparency.A standardized data format and robust algorithms for data contribution by transport operators are developed as well as a model for operators, assets, and transactions.Including zero-knowledge proofs improves user privacy by allowing secure authentication without revealing sensitive data.We believe that this research may lead a closer collaboration between public transport operators and provide an enhanced user experience while enabling transport transaction security and data verification.

Intermittent computing requires custom programming models to ensure the correct execution of applications despite power failures. However, existing programming models lead to the programs that are hardware dependent and not reusable. This article aims at virtualizing intermittent computing to remedy these problems. We introduce PureVM, a virtual machine that abstracts a transiently powered computer, and PureLANG, a continuation-passing-style programming language to develop programs that run on PureVM. This virtualization, for the first time, paves the way for portable and reusable transiently powered applications.

To cope with the challenges of constructing Cyberphysical Production Systems (CPPS), many studies propose benefiting from agent systems.However, industrial processes should be mostly emulated while agent-based solutions are integrating with CPPS since it is not always possible to apply cyber-based solutions to these systems directly.The target system can be miniaturised while sustaining its functionality.Hence, in this paper, we introduce an agent-based industrial production line and discuss the system development using Lego technology while providing integration of software agents as well as focusing on low-level requirements.In this way, a CPPS is emulated while agents control the system.

One of the main aims in the layered software architecture is to divide the code into different layers so that each layer contains related modules and serves its upper layers. Although layered software architecture is matured now; many legacy information systems do not benefit from the advantages of this architecture and their code for the process/business and data access are mostly in a single layer. In many legacy systems, due to the integration of the code in one layer, changes to the software and its maintenance are mostly difficult. In addition, the big size of a single layer causes the load concentration and turns the server into a bottleneck where all requests must be executed on it. In order to eliminate these deficiencies, this paper presents a refactoring mechanism for the automatic separation of the business and data access layers by detecting the data access code based on a series of patterns in the input code and transferring it to a new layer. For this purpose, we introduce a code scanner which detects the target points based on these patterns and hence automatically makes the changes required for the layered architecture. According to the experimental evaluation results, the performance of the system is increased for the layer separated software using the proposed approach. Furthermore, it is examined that the application of the proposed approach provides additional benefits considering the qualitative criteria such as loosely coupling and tightly coherency.

In this paper, we introduce a tool-supported reverse engineering methodology, called RE4TinyOS to create or update application models from TinyOS programs for the construction of Wireless Sensor Networks.Integrating with an existing modeldriven engineering (MDE) environment, use of RE4TinyOS enables the model-code synchronization where any modification made in the TinyOS application code can be reflected into the application model and vice versa.Conducted case studies exemplified this model-code synchronization as well as the capability of creating application models completely from already existing TinyOS applications without models, which is crucial to integrate the implementations of the third party TinyOS applications into the MDE processes.Evaluation results showed that RE4TinyOS succeeded in the reverse engineering of all main parts of two well-known TinyOS applications taken from the official TinyOS Github repository and generated models were able to be visually processed in the MDE environment for further modifications.

Model-based GUI testing has achieved widespread recognition in academy thanks to its advantages compared to code-based testing due to its potentials to automate testing and the ability to cover bigger parts more efficiently.In this study design paper, we address the scalability part of the model-based GUI testing by using community detection algorithms.A case study is presented as an example of possible improvements to make a model-based testing approach more efficient.We demonstrate layered ESG models as an example of our approach to consider the scalability problem.We present rough calculations with expected results, which show 9 times smaller time and space units for 100 events in the ESG model when a community detection algorithm is applied.

Elasticsearch is a distributed RESTful search engine, capable of solving growing number of use cases and can handle petabytes of data in seconds.However, Elasticsearch comes with a complex query language which causes a steep learning curve for the developers and, therefore, creation of queries can be difficult and time-consuming in many cases.Hence, in this paper, we introduce a Domain-specific Modeling Language (DSML), called Dimension Query Language (DQL), to support the model-driven development of Elasticsearch queries.Elasticsearch queries can be automatically generated from DQL models and DQL's IDE is capable of executing these auto-generated Elasticsearch queries on remote repositories.An evaluation of using DQL has been performed at the industrial level with the participation of a group of developers.The conducted evaluation showed that the use of the language significantly decreases the development time required for creating Elasticsearch queries.Finally, qualitative assessment, based on the developers' feedback, exposed how DQL facilitates the development of Elasticsearch queries.

Development of software agents according to belief–desire–intention (BDI) model usually becomes challenging due to autonomy, distributedness, and openness of multi‐agent systems (MAS). Hence, here, a domain‐specific modelling language (DSML), called DSML4BDI, is introduced to support development of BDI agents. The syntax of the language provides the design of agent components required for the construction of the system according to the specifications of BDI architecture. The implementation of designed MAS on Jason BDI platform is also possible via model‐to‐text transformations built in the DSML. The comparative evaluation results showed that a significant amount of artefacts required for the exact MAS implementation can be automatically achieved by employing DSML4BDI. Moreover, time needed for developing a BDI agent system from scratch can be reduced to one‐third in the case of using DSML4BDI. Finally, qualitative assessment, based on the developers’ feedback, exposed how DSML4BDI facilitates development of BDI agents.

The ModelWriter platform provides a generic framework for automated traceability analysis. In this paper, we demonstrate how this framework can be used to trace the consistency and completeness of technical documents that consist of a set of System Installation Design Principles used by Airbus to ensure the correctness of aircraft system installation. We show in particular, how the platform allows the integration of two types of reasoning: reasoning about the meaning of text using semantic parsing and description logic theorem proving; and reasoning about document structure using first-order relational logic and finite model finding for traceability analysis.

We present Tarski, a tool for specifying configurable trace semantics to facilitate automated reasoning about traces. Software development projects require that various types of traces be modeled between and within development artifacts. For any given artifact (e.g., requirements, architecture models and source code), Tarski allows the user to specify new trace types and their configurable semantics, while, using the semantics, it automatically infers new traces based on existing traces provided by the user, and checks the consistency of traces. It has been evaluated on three industrial case studies in the automotive domain (https://modelwriter.github.io/Tarski/).

In this paper, we present our approach which aims at improving the mechanism of constructing language semantics over the interoperability of domain-specific modeling languages (DSMLs) developed for Multi-agent Systems (MAS) and hence providing a more efficient way of extension for the executability of modeled agent systems on various underlying agent platforms.Differentiating from the existing MAS DSML studies, our proposal is based on determining entity mappings and building horizontal model transformations between the metamodels of MAS DSMLs which are in the same abstraction level.The applicability of the approach is demonstrated in the paper by constructing horizontal transformations between two full-fledged agent DSMLs, called SEA_ML and DSML4MAS.Use of these transformations has enabled SEA_ML instance models now to be executable on new agent platforms and that feature has been provided with less effort comparing with the implementation of needed transformations between SEA_ML and those new agent platforms from scratch.

Abstract In peer‐to‐peer (P2P) video streaming systems, one of the most challenging parts is to schedule video data dissemination, that is, each peer should carefully select the partner(s) it receives video from and the partner(s) it sends data to. We believe that an agent‐based partner selection approach may improve the quality of streaming by taking both autonomy and dynamic plan selection into account in a goal‐oriented manner. In this study, a Belief‐Desire‐Intention agent architecture for partner selection in P2P video streaming systems is introduced. The major concern of our study is to exhibit how to select the best partner during video streaming session whilst maximizing the quality of video and minimizing delay and hop count. The effects and comparative results of executing proposed agent behaviours are evaluated in the study. The proposed autonomous agent‐based approach also provides an infrastructure in which the best plan for the achievement of optimum streaming goal can be dynamically determined and executed at runtime. Experimental results of the implementation have revealed to us that both of the partner selection methods (with or without agents) manage to increase the video quality. However, the agent‐based approach performs better in terms of received bitrate, delay and hop count during streaming.

Development of agent systems is without question a complex task when autonomous, reactive and proactive characteristics of agents are considered. Furthermore, internal agent behavior model and interaction within the agent organizations become even more complex and hard to implement when new requirements and interactions for new agent environments such as the Semantic Web are taken into account. We believe that the use of both domain specific modeling and a Domain-specific Modeling Language (DSML) may provide the required abstraction and support a more fruitful methodology for the development of Multi-agent Systems (MASs) especially when they are working on the Semantic Web environment. Although syntax definition based on a metamodel is an essential part of a modeling language, an additional and required part would be the determination and implementation of DSML constraints that constitute the (formal) semantics which cannot be defined solely with a metamodel. Hence, in this paper, formal semantics of a MAS DSML called Semantic Web enabled Multi-agent Systems (SEA_ML) is introduced. SEA_ML is a modeling language for agent systems that specifically takes into account the interactions of semantic web agents with semantic web services. What is more, SEA_ML also supports the modeling of semantic agents from their internals to MAS perspective. Based on the defined abstract and concrete syntax definitions, we first give the formal representation of SEA_ML's semantics and then discuss its use on MAS validation. In order to define and implement semantics of SEA_ML, we employ Alloy language which is declarative and has a strong description capability originating from both relational and first-order logic in order to easily define complex structures and behaviors of these systems. Differentiating from similar contributions of other researchers on formal semantics definition for MAS development languages, SEA_ML's semantics, presented in this paper, defines both static and dynamic aspects of the interaction between software agents and semantic web services, in addition to the definition of the semantics already required for agent internals and MAS communication. Implementation with Alloy makes definition of SEA_ML's semantics to include relations and sets with a simple notation for MAS model definitions. We discuss how the automatic analysis and hence checking of SEA_ML models can be realized with the defined semantics. Design of an agent-based electronic barter system is exemplified in order to give some flavor of the use of SEA_ML's formal semantics. Lessons learned during the development of such a MAS DSML semantics are also reported in this paper.

SUMMARY Stock trading is one of the key items in an economy and estimating its behavior and taking the best decision in it are among the most challenging issues. Solutions based on intelligent agent systems are proposed to cope with those challenges. Agents in a multiagent system (MAS) can share a common goal or they can pursue their own interests. That nature of MASs exactly fits the requirements of a free market economy. Although existing studies include noteworthy proposals on agent‐based market simulation and researchers discuss theoretical design issues of agent‐based stock exchange systems, unfortunately only a very few of the studies consider exact development and implementation of multiagent stock trading systems within the software engineering perspective and guides to the software engineers for constructing such software systems starting from scratch. To fill this gap, in this paper, we discuss the development of a multiagent‐based stock trading system by taking into consideration software design according to a well‐defined agent oriented software engineering methodology and implementation with a widely‐used MAS software development framework. Each participant in the system is first designed as belief–desire–intention agents with their facts, goals, and plans, and then belief–desire–intention reasoning and behavioral structure of the designed agents are implemented. Lessons learned during design and development within the software engineering perspective and evaluation of the implemented multiagent stock exchange system are also reported. Copyright © 2011 John Wiley & Sons, Ltd.

Semantic Web evolution brought a new vision into agent research. The interpretation of this second generation web will be realized by autonomous computational entities, called agents, to handle the semantic content on behalf of their human users. Surely, Semantic Web environment has specific architectural entities and a different semantic which must be considered to model a Multi-agent System (MAS) within this environment. Hence, in this study, we introduce a MAS development process which supports the Semantic Web environment. Our approach is based on Model Driven Development (MDD) which aims to change the focus of software development from code to models. We first define an architecture for Semantic Web enabled MASs and then provide a MAS metamodel which consists of the first class meta-entities derived from this architecture. We also define a model transformation process for MDD of such MASs. We present a complete transformation process in which the source and the target metamodels, entity mappings between models and the implementation of the transformation for two different real MAS frameworks by using a well-known model transformation language are all included. In addition to the model-to-model transformation, the implementation of the model-to-code transformation is given as the last step of the system development process. The evaluation of the proposed development process by considering its use within the scope of a real commercial software project is also discussed.