The paper reports on an investigation into a behavioural model debugger for the Linda parallel programming paradigm using Milner's CCS. The Linda paradigm and the behavioural model for debugging are introduced, and an application of the model to Linda is discussed. A CCS specification of a Linda system with behavioural model debugger is presented and compared with a CCS specification of the basic Linda system. Observational equivalence is demonstrated between the two systems that ensures that, despite their internal differences, they are indistinguishable on the basis of their interactions with Linda client programs. A prototype Linda system with debugger that is based on the behavioural model approach is also described.

Some systems may be modelled as a set of communicating finite state machines with a slow environment. These machines communicate through the exchange of values. While it is possible to convert such a model into one finite state machine, from which test cases can be derived, this process may lead to an explosion in the number of states. Alternatively it is possible to utilise any independence that exists. The problem of producing a minimal test set, in the presence of certain types of independence and unique input/output sequences, can be represented as a variant of the vehicle routing problem. Possible heuristics for solving this problem are outlined and the method is applied to an example.

The authors discuss backward error recovery for complex software systems, where different subsystems may belong to essentially different application areas. Such heterogeneous subsystems are naturally built according to different design ‘models’, namely the ‘object-action’ model (where the long-term state of the computation is encapsulated in data objects, and active processes invoke operations on these objects), and the ‘process-conversation’ model (where the state is contained in the processes, communicating via messages). To allow backward error recovery in these two ‘models’ of computation, two different schemes are most appropriate: atomic transactions for the object-action model, and conversations for the process-conversation model. Assuming that each of these two kinds of subsystem already has functioning mechanisms for backward error recovery, the authors describe the additional provisions needed for co-ordination between these heterogeneous subsystems. The solution involves altering the virtual machine on which the programs run, and programming conventions which seem rather natural and can be automatically enforced. The approach is demonstrated by a simple example.

The increasing sophistication of today's information era poses certain challenges to traditional information technology (IT) systems. Agent-based software technology is rapidly evolving to meet the demands of this new information era. However, before agent-based solutions can be routinely and successfully exploited in real-world problems, certain fundamental research and software engineering issues have to be addressed. Some of the key challenges for the research and development of agent-based software systems are discussed. Our discussion is carried out from the twin viewpoints of fundamental research questions and software engineering issues.

This paper presents a high-level framework for analysing and designing intelligent agents. The framework’s key abstraction mechanism is a new computer level called the Social Level. The Social Level sits immediately above the Knowledge Level, as defined by Allen Newell, and is concerned with the inherently social aspects of multiple agent systems. To illustrate the working of this framework, an important new class of agent is identified and then specified. Socially responsible agents retain their local autonomy but still draw from, and provide resources to, the larger community. Through empirical evaluation, it is shown that such agents produce both good system-wide performance and good individual performance.

Object-oriented architectures for graphical user interfaces (GUIs) model the interface as a composition of interacting objects that each present an internal state to the user and provide operations on that state. Two such architectures are model-view-controller (MVC) and presentation-abstraction-control (PAC). Object-Z is used to describe the MVC and PAC architectures. The characteristics of the architectures are compared and the efficacy of Object-Z as a tool for modelling user-interface architectures is considered.

Two approaches to the problem of information-gathering, that may be characterised as distributed processing and distributed problem-solving, are contrasted. The former is characteristic of most existing information-gathering systems, and the latter is central to research in multi-agent systems. The features of complex information-carrying environments and the information-gathering task are examined, demonstrating both the utility of viewing information-gathering as distributed problem-solving and difficulties with viewing it as distributed processing. A new approach is proposed to information-gathering based on the distributed problem-solving paradigm and its attendant body of research in multi-agent systems and distributed artificial intelligence. This approach, called cooperative information-gathering, involves concurrent, asynchronous discovery and composition of information spread across a network of information servers. Top-level queries drive the creation of partially elaborated information-gathering plans, resulting in the employment of multiple semi-autonomous, cooperative agents for the purpose of achieving goals and subgoals within those plans. The system as a whole satisfices, trading off solution quality and search cost while respecting user-imposed deadlines. Current work on distributed and agent-based approaches to information-gathering is also surveyed.

The problem of version management for co-operative systems is addressed. The authors first describe a basic version model — a domain model capturing the idea of a version and the relationships between versions, whether electronic or physical, implicitly or explicitly stored. This is a ‘modal’ model in that it takes into account the context of use of these versions. The model is then extended to model version managers, which are both versioned entities themselves and also include their own models of versions. Finally, the authors show how V-Web, a system for versioning web pages, fits within the framework of the model.

IusWare (IUStitia SoftWARis) is a methodology designed to evaluate software products in a formal and rigorous way. The methodology is based on the multicriteria decision aid approach and encompasses activities such as comparison, assessment and selection of software artefacts. The methodology defines an evaluation process which consists of two main phases, designing an evaluation model and applying it. The design phase is made up of the following activities: first, identifying the actors relevant to the evaluation, their role, the purpose of the evaluation, the resources available and the object(s) of the evaluation; secondly, identifying the type of evaluation required: either a formal description of products or the ranking of products from the most preferred to the least preferred or a partitioning into two sets of the best and the remaining products; thirdly, defining a nonredundant hierarchy of evaluation attributes, often corresponding with the quality characteristics of quality models; fourthly, associating a measure, a criterion scale and a function to transform the measure scale into the criterion scale to each basic attribute; and finally, choosing an aggregation technique so as to aggregate values on criteria to form a recommendation for the selection. In the application phase attributes of products are measured, measures are transformed into values on criteria and aggregated to form a recommendation.