On the basis of some experience in the use of UML-based use casedriven methods, we believe and claim, contrary to a recent wave for allowing almost total freedom as opposed to disciplined methods, that a tighter and more precise structuring of the artifacts for the different phases of the software development process may help speed-up the process, while obviously making easier the consistency checks among the various artifacts. To support our claim we have started to investigate an approach, that, though being compliant with the UML notation and a number of UML-based methods, departs from them both in the basic philosophy, that follows the "tight and precise" imperative, and in the technical solutions for structuring the various artifacts.

In this paper we discuss how to combine a multiview use-case driven method for the requirement specification of a system with an agent-oriented method for developing a working prototype. The rationale behind this combination is to cover the complete software development cycle, while the two methods it originates from only cover a part of it. The prototype execution allows to obtain useful feedbacks on the coherence of the UML artifacts produced during the requirement specification phase.

Abstract. This paper discusses the integration of a Prolog implementation, tuProlog, into the DCaseLP environment for building prototypes of multi-agent systems (MASs). DCaseLP aims at providing the MAS developer with a plethora of specification and implementation languages in order to allow him/her to adopt the best language for each view of the system under specification/implementation. The integration of tuProlog into DCaseLP represents a step forward in this direction and allows the re-use of tools and mechanisms previously developed for the DCaseLP predecessor, CaseLP. 1

Abstract. Engineering systems of heterogeneous agents is a difficult task; one of the ways for achieving the successful industrial deployment of agent technology is the development of engineering tools that support the developer in all the steps of design and implementation. In this work we focus on the problem of supporting the design of agent interaction protocols by carrying out a methodological integration of the MAS prototyping environment DCaseLP with the agent programming language DyLOG for reasoning about action and change. 1

We look at the main issue of the Colloquium "Formal Methods at the Crossroads from Panacea to Foundational Support" reflecting on our rather long experience of active engagement in the development and use of formal techniques. In the years, we have become convinced of the necessity of an approach more concerned with the real needs of the software development practice. Consequently, we have shifted our work to include methodological aspects, learning a lot from the software engineering practices and principles.

This paper presents an attempt, perhaps unorthodox, at bridging the gap between the use of formal techniques and the current software engineering practices. After years of full immersion in the development and use of formal techniques, we have been led to suggest a Virtuous Cycle philosophy, better marrying the rigour of formalities to the needs and, why not, the wisdom of current practices. What we have called Well-Founded Software Development Methods is a strategy compliant with that philosophy, that essentially aims at proposing methods where the formalities provide the foundational rigour, and perhaps may inspire new techniques, but are kept hidden from the user.

One of the goals of software engineering is to provide what is necessary to write relevant, legible, useful descriptions of the systems to be developed, which will be the basis of successful developments. This goal was addressed both from informal approaches (providing in particular visual notations) and formal ones (providing a formal sound semantic basis). Informal approaches are often driven by a software development method, and, while formal approaches sometimes provide a user method, it is usually aimed at helping to use the proposed formalism when writing a specification. Our goal here is to provide a companion method that helps the user to understand the system to be developed, and to write the corresponding formal specifications. We also aim at supporting visual presentations of formal specifications, so as to “make the best of both formal and informal worlds”. We developed this method for the (logical-algebraic) specification languages Casl (Common Algebraic Specification Language, developed within the joint initiative CoFI) and for an extension for dynamic systems Casl-Ltl, and we believe it is general enough to be adapted to other paradigms. Another challenge is that a method that is too general does not encompass the different kinds of systems to be studied, while too many different specialized methods result in partial views that may be difficult to integrate in a single global one. We deal with this issue by providing a limited number of instances of our method, fitted for three different kinds of software items, while keeping a common “meta”structure and way of thinking. More precisely, we consider here that a software item may be a simple dynamic system, a structured dynamic system, or a data structure, and we show here how to support property-oriented (axiomatic) specifications. We are thus providing support for the “building-bricks ” tasks of specifying software artifacts that in our experience are needed for the development process. Our approach is illustrated with a lift case study.

One of the goals of software engineering is to provide what is necessary to write relevant, legible, useful descriptions of the systems to be developed, which will be the basis of successful developments. This goal was addressed both from informal approaches (providing in particular visual languages) and formal ones (providing a formal sound semantic basis). Informal approaches are often driven by a software development method, and while formal approaches sometimes provide a user method, it is usually aimed at helping to use the proposed formalism/language when writing a speci cation. Our goal here is to provide a companion method that helps the user to understand the system to be developed, and to write the corresponding formal speci cations. We also aim at supporting visual presentations of formal speci cations, so as to \make the best of both formal and informal worlds". We developed this method for the (logical-algebraic) speci cation languages Casl (Common Algebraic Speci cation Language, developed within the joint initiative CoFI) and for an extension for dynamic systems Casl-Ltl, and we believe it is general enough to be adapted to other paradigms.

Dagstuhl, Open and heterogeneous multi-agent systems (See yesterday’s talk by Marco Gavanelli for an introduction to open MASs). MASs involve heterogeneous components which have different ways of representing their knowledge about the world, about themselves, and about other agents, and which adopt different mechanisms for reasoning about it. Despite their heterogeneity, agents need to interact and exchange information in order to cooperate or compete for the control of shared resources; this interaction may follow sophisticated communication protocols. How can we correctly and efficiently engineer a system of heterogeneous agents? A prototyping approach Advantages of building a working MAS prototype: – The time and cost required are limited. – The prototyping iterative process allows to revise requirements or critical choices. – A prototype can be realized using (eventually unefficient) formal methods and tools. – If the prototype can integrate external legacy software and/or third-party agents it becomes closer to the final application. Are there prototyping environment for multiagent systems able to cope with the heterogeneity of both the agents and the different views of the system itself? A flashback to Dagstuhl Seminar 02481 CaseLP (“Complex Applications Specification Environment based on Logic Programming”) is a logic-based prototyping environment that: – provides a set of heterogeneous high-level specification languages, each suitable for specifying some aspect of the MAS structure and dynamics; – allows to directly execute or compile into an exacutable language specifications written in these languages; – integrates some external languages and packages. A flashback to Dagstuhl Seminar 02481 (cont.) Future work on CaseLP To furtherly improve CaseLP we are concentrating our research on: 1. Integration of new languages for implementing agents and integration of external packages. 2. Full integration of UML. 3. Physical distribution and real concurrency of agents. This talk is about...