Michael Duvigneau

An Extensible Editor and Simulation Engine for Petri Nets: Renew

Renew is a computer tool that supports the development and execution of object-oriented Petri nets, which include net instances, synchronous channels, and seamless Java integration for easy modelling. Renew is available free of charge including the Java source code. Due to the growing application area more and more requirements had to be fulfilled by the tool set. Therefore, the architecture of the tool has been refactored to gain more flexibility. Now new features allow for plug-ins on the level of concepts (net formalisms) and on the level of applications (e.g. workflow or agents).

Concurrent architecture for a multi-agent platform

A multi-agent system has a high degree of concurrency. Petri nets are a well-established means for the description of concurrent systems. Reference nets are higher level, object-oriented Petri nets. With Renew (REference NEt Workshop), there exists a tool to model and execute reference nets with seamless Java integration. So, reference nets can be used to design executable multi-agent systems while hiding the sometimes annoying details of concurrent implementations in traditional programming languages. The technique is currently used to implement a FIPA-compliant agent platform for multi-agent systems (called CAPA) focused on retaining a maximum level of concurrency in the system.

Agent Models for Concurrent Software Systems

In this work we present modeling techniques for the development of multi-agent applications within the reference architecture for multi-agent system Mulan . Our approach can be characterized as model driven development by using models in all stages and levels of abstraction regarding design, implementation and documentation. Both, standard techniques from software development as well as customized ones are used to satisfy the needs of multi-agent system development. To illustrate the techniques and models within this paper we use diagrams created during the development of an agent-based distributed Workflow Management System (WFMS).

Software Engineering with Petri Nets: A Web Service and Agent Perspective

The context of this paper is given through a software engineering approach that uses Petri nets as executable code. We apply the particular understanding that Petri nets are not only used to model systems for design purposes but also to implement system components. Following this approach, we develop complex Petri net-based software applications according to the multi-agent paradigm. Agent-internal as well as agent-spanning processes are implemented directly as (high-level) Petri nets. These nets are essential parts of the resulting software application – alongside other parts (operational and declarative ones), which are implemented using traditional ways of programming.

Requirements and tools for the debugging of multi-agent systems

Debugging of multi-agent systems (MAS) is hard due to their distributed, concurrent, adaptive, highly interactive, flexible, mobile and heterogeneous nature.We identify three dimensions (activities, scale, and coupling) that span the area of debugging and derive general requirements for a debugging toolset in the multi-agent context. An implementation of a toolset w.r.t. the requirements given for the MAS reference architecture Mulan is presented. This toolset comprises general low level debugging possibilities that are included in the virtual machine (execution engine Renew), specialized Mulan-dependent debugging facilities that enable debugging on higher (agent concepts and independent debugging aspects that rely on publicly available information - i.e. message logs - together with advanced techniques, such as visualization and mining.

Models and Tools for Mulan Applications

In this work we describe the development process of multi-agent application design and implementation with M ulan . Our approach can be characterized as model driven development by using models in all stages and levels of abstraction regarding design, implementation and documentation. Both, standard methods from software development as well as customized ones are used to satisfy the needs of multi-agent system development.

Multi-agent concepts as basis for dynamic plug-in software architectures

In this work we present the basic concepts for a dynamic plug-in-based software architecture using concepts from the Petri net-based MAS framework MULAN. By transferring the concepts of agent-orientation to a plug-in-based architecture we are able to design our application and the plug-in-based system on an abstract level. Moreover, general problems that evolve from a highly dynamic and configurable architecture have been solved by basing the conceptual design on multi-agent principles. The introduced concepts have been applied to the software architecture of the tool RENEW.

Applying multi-agent concepts to dynamic plug-in architectures

In this work we present the basic concepts for a dynamic plug-in-based software architecture using concepts from the Petri net-based MAS framework Mulan. By transferring the concepts of agent-orientation to a plug-in-based architecture we are able to design our application and the plug-in-based system on an abstract level. Moreover, general problems that evolve from a highly dynamic and configurable architecture have been solved by basing the conceptual design on multi-agent principles. In this paper we discuss the general properties of extensible systems and the benefits that can be achieved when applying the multi-agent view to their architecture. In addition to the conceptual modeling of such architectures, we provide a practical example where the concept has been successfully applied in the development of the latest release of Renew. Through the introduction of the multi-agent concepts, the new architecture is now – at runtime – dynamically extensible by registering plug-ins with the management system.

Plugin-Agents as Conceptual Basis for Flexible Software Structures

To allow for flexibility in software structures (architectures) especially plugins and agents are proposed solutions. While plugins are used to support the conceptual and practical issues within component oriented software environments, agents are used in software areas where social metaphors like (self-)adaptability, flexibility, mobility, interactivity etc. are of interest. Common to both approaches is a strong relation to a service-oriented view on exporting functionality. This contribution illustrates the idea of the integration of both concepts on the formal basis of high-level Petri nets.