A statecharts-based software development process for mobile agents

https://doi.org/10.1016/j.infsof.2004.04.005Get rights and content

Abstract

Although mobile agents and their supporting infrastructures have been extensively developed, it is still an emerging technology. A wider acceptance of mobile agents would be facilitated with the exploitation of suitable methodologies and tools which fully support their development lifecycle. This paper proposes a Statecharts-based development process for mobile agents, which allows for a seamless transition from the specification of mobile agent behaviour to its implementation and adaptation to target mobile agent systems. In particular, modelling of the mobile agent behaviour is visual and its coding is seamlessly supported by the Mobile Active Object Framework. The coded agent behaviour can be adapted to platform-specific mobile agents by means of the Mobile Agent Adaptation Framework thus enabling re-use of existing mobile agent systems.

Introduction

Mobile agents paradigm and technology is emerging as a powerful tool for engineering highly dynamic, reconfigurable distributed systems and applications in heterogeneous environments. The potential of mobile agents [26] has been applied in several areas of application ranging from e-commerce to network management, and from information retrieval to multimedia. Although, a host of Mobile Agent Systems (MAS) constituting a mature technological substratum which support the construction of mobile agent-based applications and systems is currently available [18], mobile agents are still under-used. Wider acceptance and exploitation of mobile agents would depend both on the secure integration of mobile agents into currently available commercial software infrastructures [15] and, notably, on the availability of methodologies and tools which fully support the mobile agent development lifecycle [28]. Recently, in the context of Agent Oriented Software Engineering (AOSE) [11], [27], several high-level methodologies, design methods, and tools have been proposed for supporting the analysis, design and implementation of applications which are based on agents. Indeed although mobility is considered an additional property of an agent according to a stronger notion of agency [35], mobile agents per se differ from agents both in nature and in purposes [25]. In fact, in almost all of the currently available MAS, the programming abstractions of mobile agents more closely resemble active objects featured by mobility rather than agents capable of migration. To date, few authors have investigated software development processes which specifically address the development of mobile agents and which seamlessly cover modelling, design and implementation.

This paper presents and exemplifies a Statecharts-based development process for mobile agents which allows for a seamless transition from the specification of mobile agent behaviour to its implementation and subsequent adaptation to existing MAS. In particular the proposed process addresses single-threaded mobile agents (‘lightweight mobile agents’) which are provided by the majority of the currently available MAS. It is formed by the following steps and related activities (see Fig. 1):

  • 1.

    modelling: the behaviour of a lightweight mobile agent is specified by using the Distilled StateCharts formalism [13], purposely derived from Statecharts [19], which rigorously specifies the dynamic behaviour of event-driven single-threaded software components;

  • 2.

    object-oriented design: the Distilled StateCharts-based behaviour of a lightweight mobile agent is translated into an object-oriented design by means of the Mobile Active Object (MAO) Framework providing the rules to obtain an object-oriented design which can be seamlessly translated into code;

  • 3.

    implementation: the implementation of a lightweight mobile agent is carried out by:

    • 3.1.

      prototyping the object oriented design into code by using a specific implementation of the MAO Framework. In particular, Java was adopted as the target language in order to exploit the multitude of currently available Java-based MAS;

    • 3.2.

      adapting the code to target Java-based MAS, which provide a well-established execution environment along with creation, coordination and migration mechanisms, by using the Mobile Agent Adaptation Framework (MAAF).

The proposed process fully supports the detailed design of a lightweight mobile agent, viewed as a component of a mobile agents-based application, along with its coding for a target platform. Thus, it can be usefully employed for driving the implementation phase of an agent-oriented software engineering methodology which also includes the following phases: enterprise modelling, domain analysis, requirement analysis, design and testing [11].

The remainder of the paper is organized as follows. Section 2 introduces the Distilled StateCharts formalism and describes how the lightweight mobile agent behaviour is specified using a reference example. Section 3 presents the object-oriented design of a lightweight mobile agent behaviour by means of the MAO Framework. Section 4 describes the Java-based implementation of lightweight mobile agents obtained using the Java-based MAO Framework and a concrete instantiation of the MAAF for the Voyager ORB system. Section 5 analyses the proposed development process by discussing the benefits and drawbacks stemming from the exploitation of the process. Section 6 discusses related work. Finally, conclusions are drawn and directions of further work elucidated.

Section snippets

Modelling the dynamic behaviour of lightweight mobile agents

Mobile agents are executing software components which can migrate within a logical network of execution environments or agent servers to fulfil a goal-oriented task. They are characterized both by reactiveness and proactiveness, i.e. they do not simply act in response to stimuli produced by their execution environment, but they are also able to exhibit goal-directed behaviour by taking the initiative [35]. The goal-directed behaviour of mobile agents is carried out through phases of

Object-oriented design

A DSC-based specification of the behaviour of a lightweight mobile agent obtained from the modelling step, can be translated into a design object called MAO Behavior, from which the final code can be seamlessly obtained. The translation is based on the MAO Behavior Pattern, a specialization of the DSC Pattern, which was purposely defined for designing the state-based behaviour of lightweight mobile agents (see Ref. [14] for an extended and pattern-like presentation of both patterns). In order

Java-based implementation

The Java implementation of a lightweight mobile agent can be obtained by performing the following steps:

  • 1.

    Prototyping the MAO Behavior obtained during the object-oriented design phase into Java code by using the Java-based MAO Framework;

  • 2.

    Adapting the MAOBehavior class to an existing mobile agent system by using the Mobile Agent Adaptation Framework (MAAF).

By following this approach, the Java implementation of the behaviour of lightweight mobile agents becomes independent of the specific mobile

An analysis of the development process

The development process for mobile agents presented in this paper is characterized by the following valuable benefits:

  • seamless transition from modelling to implementation: it is widely recognized that an increase in the number of discontinuities between successive development phases hinders the achievement of high-level specifications. As the MAO Framework reduces the gaps between modelling and implementation of the mobile agent behaviour and the MAAF allows for a transparent adaptation to

Related work

As previously discussed, well-defined processes specifically addressing the development of mobile agents have not been yet described in the literature. However, a rich set of related approaches, ranging from agent-oriented methodologies and patterns to Statecharts-based tools and state-based models for agent behaviour, are available.

With regard to methodologies, in the framework of AOSE, several agent-oriented methodologies (e.g. MaSE, Prometheus, Tropos, Gaia) [11], [36] and modelling

Conclusions

Mobile agents is an emerging technology which can find ample applications once supported by software engineering methodologies and tools which possess a formal basis, embody an appealing and well-established visual modelling language, and are able to fully support the development lifecycle of mobile agents.

This paper has presented and exemplified a software development process for lightweight mobile agents.

In particular, the Statecharts-based process reported here relies on a variant of the

References (37)

  • D Harel

    Statecharts: a visual formalism for complex systems

    Science of Computer Programming

    (1987)
  • A Tripathi et al.

    Design of the Ajanta system for mobile agent programming

    Journal of Systems and Software

    (2002)
  • The Aglets Software Development Kit, the Aglets portal, 2003. Documentation and software available from...
  • J Arlow et al.

    UML and the Unified Process: Practical Object-Oriented Analysis and Design

    (2001)
  • Y Aridor et al.

    Agent Design Patterns: elements of agent application design

    Proceedings of 2nd Int'l Conference on Autonomous Agents'98

    (1998)
  • B Bauer et al.

    Agent UML: A Formalism for Specifying Multiagent Interaction

  • F Bellifemine et al.

    Developing multi-agent systems with a FIPA-compliant agent framework

    Software—Practice And Experience

    (2001)
  • L Boloni et al.

    State Machine Agent Model, Technical Report CSD-TR-99-027

    (1999)
  • P Bresciani et al.

    TROPOS: an agent-oriented software development methodology

    Journal of Autonomous Agents and Multi-Agent Systems

    (2004)
  • F Buschmann et al.
    (1996)
  • P Busetta et al.

    JACK Intelligent Agents—Components for Intelligent Agents in Java, Technical report

    (1998)
  • J Campbell et al.

    Motion Planning in a Society of Mobile Agents

    (1998)
  • K.H Dam et al.

    Comparing Agent-Oriented Methodologies

    (2003)
  • FIPA Agent Management Support for Mobility Specification, DC00087C, 2002/05/10....
  • G Fortino et al.

    Mobile Active Objects for highly dynamic distributed computing

    (2002)
  • G Fortino et al.

    A Framework for Design and Implementation of Mobile Active Objects

    (2003)
  • S Funfrocken

    How to Integrate Mobile Agents into Web Servers

    Proceedings of the WETICE'97 Workshop on Collaborative Agents in Distributed Web Applications, Boston, MA

    (1997)
  • E Gamma et al.

    Design Patterns: Elements of Reusable Object-Oriented Software

    (1995)
  • Cited by (43)

    • Translation of statechart agents into a BDI framework for MAS engineering

      2015, Engineering Applications of Artificial Intelligence
      Citation Excerpt :

      We consider a modelling methodology and tool strongly based on a SC language and propose a framework of formal rules for the automatic translation of a so designed agent into a BDI programming language. To this purpose, we consider the Distilled StateCharts (DSC) formalism (Fortino et al., 2004) as SC-based modeling language, and PROFETA (Fichera et al., 2010a, 2010b; Messina et al., 2013; Corrado Santoro, 2013) as BDI-oriented programming language. Both tools have been proposed and developed by the authors.

    • An agent-based approach for the design and analysis of content delivery networks

      2014, Journal of Network and Computer Applications
      Citation Excerpt :

      The defined agent models of the CDN architectures are obtained according to the following integrated phases of ELDAMeth: the modeling phase, which is driven by a modeling language based on Statecharts (Fortino et al., 2004, 2010b) and supported by a CASE tool (ELDATool) which automatically translates Statecharts-based visual specifications into platform-independent code; the simulation phase, which is based on an agent-oriented and event-driven simulation framework (ELDASim) (Fortino and Russo, 2012; Fortino et al., 2005c) that executes the code produced in the modeling phase upon a simulated distributed platform of agent servers.

    • Why Did Mr. Trump Oppose Globalization? An E-CARGO Approach

      2021, IEEE Transactions on Computational Social Systems
    View all citing articles on Scopus
    View full text