Guided formal development: patterns for modelling and refinement

International Journal of Software Engineering and Knowledge Engineering, 2001

Being autonomous, proactive and adaptive, an agent-based system may demonstrate emergent behaviours, which are neither designed by the developers nor expected by the users of the system. Whether or not such emergent behaviours are advantageous, methods for the specification of agent behaviours must be developed to enable software engineers to analyse agent-based systems before they are implemented. This paper presents a formal specification language SLABS for agent-based systems. It is a model-based specification language defined based on the notion of agents as encapsulations of data, operations and behaviours. The behaviour of an agent is defined by a set of rules that describe the action/reaction of the agent in certain environment scenarios. The style and expressiveness of the language is demonstrated by examples like ants, personal assistants and speech-act style of agent communications.

Procedia Computer Science, 2011

Today, distributed systems with loose connections are increasingly developed using event-based architectures. In these architectures, systems are composed of separate components which cooperate dynamically. The communication and cooperation of components in these architectures are done through event passing mechanisms. The main challenge in these architectures is to define a framework to model and validate systems under development. In this paper, we propose a framework using ASMETA (ASM mETA language) for modelling systems through event-based architectures. Validation of the whole system is done through model checking using Bogor. We describe the process of automatically mapping ASM models to BIR -the input language of Bogor-. In the end, we present our experimental results using the proposed approach with different case studies.

Lecture Notes in Computer Science, 2006

Telecommunication systems should have a high degree of availability, i.e., high probability of correct and timely provision of requested services. To achieve this, correctness of software for such systems and system fault tolerance should be ensured. Application of formal methods helps us to gain confidence in building correct software. However, to be used in practice, formal methods should be well integrated into existing development process. In this paper we propose a formal model-driven approach to development of communicating systems. Essentially our approach formalizes and extends Lyra -a top-down service-oriented method for development of communicating systems. Lyra is based on transformation and decomposition of models expressed in UML2. We formalize Lyra in the B Method by proposing a set of formal specification and refinement patterns reflecting the essential models and transformations of the Lyra service specification, decomposition and distribution phases. Moreover, we extend Lyra to integrate reasoning about fault tolerance in the entire development flow.

2005

Telecommunicating systems should have a high degree of availability, i.e., high probability of correct and timely provision of requested services. To achieve this, correctness of software for such systems should be ensured. Application of formal methods helps us to gain confidence in building correct software. However, to be used in practice, the formal methods should be well integrated into existing development process. In this paper we propose a formal model-driven approach to development of communicating systems. Essentially our approach formalizes Lyra – a top-down service-oriented method for development of communicating systems. Lyra is based on transformation and decomposition of models expressed in UML2. We formalize Lyra in the B Method by proposing a set of formal specification and refinement patterns reflecting the essential models and transformations of Lyra. The proposed approach is illustrated by a case study.

2009

Event-B has given developers the opportunity to construct models of complex systems that are correct by construction. However, there is no systematic approach, especially in terms of reuse, which could help with the construction of these models. We introduce the notion of design patterns within the framework of Event-B to shorten this gap.

Intelligent Agent Software Engineering

Recent advances in testing and verification of software based on formal specifications of the system to be built have reached a point where the ideas can be applied in a powerful way in the design of agent-based systems. The software engineering research has highlighted a number of important issues: the importance of the type of modeling technique used; the careful design of the model to enable powerful testing techniques to be used; the automated verification of the behavioral properties of the system; and the need to provide a mechanism for translating the formal models into executable software in a simple and transparent way. This chapter presents a detailed and comprehensive account of the ways in which some modern software engineering research can be applied to the construction of effective and reliable agent-based software systems. More specifically, we intend to show how simple agents motivated from biology can be modeled as X-machines. Such modeling will facilitate verificat...

INCOSE International Symposium, 2012

Although the eFFBD formalism dates back to the 1990s (or even, in a simplified form, the 1950s), it seems that it is still not as much used by the Systems Engineering community as it could. Indeed, eFFBD is a modeling language focusing on functional paradigm i.e. allowing functional and behavioral modeling and reasoning about a system. Currently, it is often confronted or compared to other languages such as SysML for activity modeling (activity diagrams) based on object paradigm. This paper aims to demonstrate the interest and the potential advantages for systems designers, like most of the discipline-oriented designers to dispose of an enriched (conceptually and semantically) eFFBD modeling language called here xFFBD. This has to be a credible framework for modeling, communicating and reasoning about complex systems. After shortly recalling the history, the key concepts and capabilities of eFFBD, this paper compares eFFBD with other formalisms considered here as relevant for the study, Petri nets and SysML. Several leads are then identified and discussed in order to improve the eFFBD language and to provide a first draft version of xFFBD specification.

Object-Oriented Real- …, 2005

Ensuring dependability of distributed applications is a difficult problem since developers must carefully consider issues such as network and node failures, deadlocks, livelocks, starvation, distributed coordination, and synchronization. The creation of architectural patterns for dependable software systems can provide effective guidelines, similar to design patterns, to system architects. In this paper, we present an agent specification language, associated tools, and agent-based middleware for specifying, analyzing and implementing architectural patterns for dependable software systems.

NASA Monographs in Systems and Software Engineering, 2006

As has been discussed elsewhere , much agent-related work has tended to focus on either the development of practical applications, or the development of sophisticated logics for reasoning about agents. Our own view is that work on formal models of agent-based systems is valuable inasmuch as they contribute to a fundamental goal of computing to build real agent systems. This is not to trivialise or denigrate the effort of formal approaches, but to direct them towards integration in a broader research programme. In an ongoing project that has been running for several years, we have sought to do exactly that through the development of a formal framework, known as SMART, that provides a conceptual infrastructure for the analysis and modelling of agents and multi-agent systems on the one hand, and enables implemented and deployed systems to be evaluated and compared on the other. In this paper, we describe our research programme, review its achievements to date, and suggest directions for the future.

2005

2008

In this paper, we present a specification and verification technique for interaction protocols in multi-agent systems using a combination of Agent Unified Modeling Language (AUML) and the Event B method. The objective is to improve the semi-formal representation of agents, their precedence relation and protocol states as well as the formal analysis of safety and liveliness. The interaction protocol is initially modeled using the AUML protocol diagram. Then, the resulting model is translated into Event B and enriched with required interaction protocols properties to be verified using a B powerful support tool: B4free. In this paper, we focus on the translation process of AUML protocol diagrams into Event B and we illustrate our technique by an example of multi-agent systems interaction protocol.

Lecture Notes in Computer Science, 2006

Usually complex systems are controlled by an operator co-operating with a computer-based controller. The controlling software runs in continuous interaction with the operator and constantly reacts on operator's interruptions by dynamically adapting system behaviour. Simultaneously it catches the exceptions signalling about errors in the system components and performs error recovery. Since interruptions are asynchronous signals they might concurrently co-exist and conflict with exceptions. To ensure dependability of a dynamically adaptable system, we propose a formal approach for resolving conflicts and designing robust interruption and exception handlers. We present a formal specification pattern for designing components of layered control systems that contain interruption and exception handlers as an intrinsic part of the specification. We demonstrate how to develop a layered control system by recursive application of this pattern. Controller Sensors Actuators Plant

Autonomous Agents and Multi-agent Systems, 2010

Holonic multiagent systems (HMAS) offer a promising software engineering approach for developing complex open software systems. However the process of building Multi-Agent Systems (MAS) and HMAS is mostly different from the process of building more traditional software systems as it introduces new design and development challenges. This paper introduces an agent-oriented software process for engineering complex systems called ASPECS. ASPECS is based on a holonic organisational metamodel and provides a step-by-step guide from requirements to code allowing the modelling of a system at different levels of details using a set of refinement methods. This paper details the entire ASPECS development process and provides a set of methodological guidelines for each process activity. A complete case study is also used to illustrate the design process and the associated notations. ASPECS uses UML as a modelling language. Because of the specific needs of agents and holonic organisational design, the UML semantics and notation are used as reference points, but they have been extended by introducing new specific profiles. 2 M. Cossentino, N. Gaud, V. Hilaire, S. Galland, A. Koukam

2008

Formal modelling is indispensable for engineering highly dependable systems. However, a wider acceptance of formal methods is hindered by their insufficient usability and scalability. In this paper, we aim at assisting developers in rigorous modelling and design by increasing automation of development steps. We introduce a notion of refinement patterns -generic representations of typical correctness-preserving model transformations. Our definition of a refinement pattern contains a description of syntactic model transformations, as well as the pattern applicability conditions and proof obligations for verification of correctness preservation. This establishes a basis for building a tool supporting formal system development via pattern reuse and instantiation. We present a prototype of such a tool and some examples of refinement patterns for automated development in the Event B formalism.

2014

Multi-Agent Systems (MAS) are an emerging paradigm that has high potentials for developing distributed, open and concurrent complex systems. These systems often need to operate in dynamic environments and face the challenges of handling continuously changing requirements. These aspects increase the complexity of designing MAS. To handle the complexity and facilitate reasoning, software architecture is now recognized as the best way to meet these expectations. In this paper, we try to handle these issues by proposing a new approach for modeling and analyzing MAS architectures by using a formal specification of the Bigraphical Reactive System (BRS). The feasibility and the advantage of the proposed approach are shown thru a case study.