Rodrigo B. de Paes

Refinement operators to facilitate the reuse of interaction laws in open multi-agent systems

As new software demands and requirements appear, the system and its interaction laws must evolve to support these changes. Languages and models should provide the tools for dealing with this evolution. Poor support for evolution has a negative impact on system maintainability. In this paper, we propose some refinement operators to extend the interaction laws in open multi-agent systems. As an example of this idea, we implemented a customizable application in the supply chain management domain as an open system environment.

Enhancing the environment with a law-governed service for monitoring and enforcing behavior in open multi-agent systems

Environment is an essential part of any multi-agent system (MAS), since it provides the surrounding conditions for agents to exist. For some sort of systems, the environment can be viewed as providing a set of services, in which some of them, such as directory facilities, are used explicitly by the agents to perform their tasks, and other such as monitoring, behavioral enforcement and security can be done transparently by the environment. We join the idea that the specification of environments of open multi-agent systems should include laws that define what and when something can happen in an open system. Laws are restrictions imposed by the environment to tame uncertainty and to promote open system dependability. This paper proposes a design approach and application of a middleware based on laws in multi-agent systems. The approach can be viewed as a set of services provided by the environment.

On Fault Tolerance in Law-Governed Multi-agent Systems

The dependability of open multi-agent systems is a particular concern, notably because of their main characteristics as decentralization and no single point of control. This paper describes an approach to increase the availability of such systems through a technique of fault tolerance known as agent replication, and to increase their reliability through a mechanism of agent interaction regulation called law enforcement mechanism. Therefore, we combine two frameworks: one for law enforcement, named XMLaw, and another for agent adaptive replication, named DimaX, in which the decision of replicating an agent is based on a dynamic estimation of its criticality. Moreover, we will describe how we can reuse some of the information expressed by laws in order to help at the estimation of agent criticality, thus providing a better integration of the two frameworks. At the end of the paper, we recommend a means to specify criticality monitoring variation through a structured argumentation approach that documents the rationale around the decisions of the law elements derivation.

An event-driven high level model for the specification of laws in open multi-agent systems

The agent development paradigm poses many challenges to software engineering researchers, particularly when the systems are distributed and open. They have little or no control over the actions that agents can perform. Laws are restrictions imposed by a control mechanism to deal with uncertainty and to promote open system dependability. In this paper, we present a high level event-driven conceptual model of laws. XMLaw is an alternative approach to specifying laws in open multi-agent systems that presents high level abstractions and a flexible underlying event-based model. Thus XMLaw allows for flexible composition of the elements from its conceptual model and is flexible enough to accept new elements.

Interaction laws for dependability explicit computing in open multi-agent systems

In an open multi-agent system (MAS), agent autonomy and heterogeneity may possibly exploit cooperation, leading the system to an undesirable state. Since an MAS has no central control, a coordination mechanism must be developed to allow agents to fulfill their design goals. It is proposed to incorporate the dependability explicit computing (DepEx) ideas into a law-governed approach in order to build a dependable open MAS. The authors show that the law specification can explicitly incorporate dependability concerns, collect data and publish them in a metadata registry. This data can be used to realise DepEx and, for example, it can help to guide design and runtime decisions. The advantages of using a law-governed approach are (i) the explicit specification of the dependability concerns; (ii) the automatic collection of the dependability metadata reusing the infrastructure of the mediators presenting in law-governed approaches; and (iii) the ability to specify reactions to undesirable situations, thus preventing service failures.

Domain engineering to ensure flexibility on interaction laws of multi-agent systems

Law enforcement approaches have been proposed to promote dependability in open multi-agent systems. Interaction laws are defined and then enforced to promote predictability. As new software demands and requirements appear, the system and its interaction laws must evolve to support those changes. The purpose of domain engineering is to produce a set of reusable assets for a family of systems, which are then used to build concrete members of the family. Flexibility is the ease with which a system or component can be modified for use in applications other than those for which it was originally designed. In this paper, we discuss how the MLaw infrastructure was designed to support interaction law evolution providing support to produce a set of reusable laws for a family of systems. As an example, we have implemented two customizable applications in the area of electronic negotiation expressed as an open system environment.

Identifying design problems in the source code: a grounded theory

The prevalence of design problems may cause re-engineering or even discontinuation of the system. Due to missing, informal or outdated design documentation, developers often have to rely on the source code to identify design problems. Therefore, developers have to analyze different symptoms that manifest in several code elements, which may quickly turn into a complex task. Although researchers have been investigating techniques to help developers in identifying design problems, there is little knowledge on how developers actually proceed to identify design problems. In order to tackle this problem, we conducted a multi-trial industrial experiment with professionals from 5 software companies to build a grounded theory. The resulting theory offers explanations on how developers identify design problems in practice. For instance, it reveals the characteristics of symptoms that developers consider helpful. Moreover, developers often combine different types of symptoms to identify a single design problem. This knowledge serves as a basis to further understand the phenomena and advance towards more effective identification techniques.