Robert Chatley

LTSA-MSC: tool support for behaviour model elaboration using implied scenarios

We present a tool that supports the elaboration of behaviour models and scenario-based specification by providing scenario editing, behaviour model synthesis, and model checking for implied scenarios.

Predictable Dynamic Plugin Systems

To be able to build systems by composing a variety of components dynamically, adding and removing as required, is desirable. Unfortunately systems with evolving architectures are prone to behaving in a surprising manner. In this paper we show how it is possible to generate a snapshot of the structure of a running application, and how this can be combined with behavioural specifications for components to check compatability and adherence to system properties. By modelling both the structure and the behaviour, before altering an existing system, we show how dynamic compositional systems may be put together in a predictable manner.

System architecture: the context for scenario-based model synthesis

Constructing rigorous models for analysing the behaviour of concurrent and distributed systems is a complex task. Our aim is to facilitate model construction. Scenarios provide simple, intuitive, example based descriptions of the behaviour of component instances in the context of a simplified architecture instance. The specific architecture instance is generally chosen to provide sufficient context to indicate the expected behaviour of particular instances of component types to be used in the real system. Existing synthesis techniques provide mechanisms for building behaviour models for these simplified and specific architectural settings. However, the behaviour models required are those for the full generality of the system architecture, and not the simplified architecture used for scenarios. In this paper we exploit architectural information in the context of behaviour model synthesis from scenarios. Software architecture descriptions give the necessary contextual information so that component instance behaviour can be generalised to component type behaviour. Furthermore, architecture description languages can be used to describe the complex architectures in which the generalised behaviours need to be instantiated. Thus, architectural information used in conjunction with scenario-based model synthesis can support both model construction and elaboration, where the behaviour derived from simple architecture fragments can be instantiated in more complex ones.

MagicBeans: a Platform for Deploying Plugin Components

Plugins are optional components which can be used to enable the dynamic construction of flexible and complex systems, passing as much of the configuration management effort as possible to the system rather than the user, allowing graceful upgrading of systems over time without stopping and restarting. Using plugins as a mechanism for evolving applications is appealing, but current implementations have limited functionality. In this paper we present a framework that supports the construction and evolution of applications with a plugin architecture.

Goal and scenario validation: a fluent combination

Scenarios and goals are effective techniques for requirements definition. Goals are objectives that a system has to meet. They are elaborated into a structure that decomposes declarative goals into goals that can be formulated in terms of events and can be controlled or monitored by the system. Scenarios are operational examples of system usage. Validation of goals and scenarios is essential in order to ensure that they represent what stakeholders actually want. Rather than validating scenarios and goals separately, possibly driving the elaboration of one through the validation of another, this paper exploits the relationship between goals and scenarios. The aim is to provide effective graphical animations as a means of supporting such a validation. The relation between scenarios and goals is established by means of fluents that describe how events of the operational description change the state of the basic propositions from which goals are expressed. Graphical animations are specified in terms of fluents and driven by a behaviour model synthesised from the operational scenarios. In addition, goal model checking over operational scenarios is provided to guide animations through goal violation traces.

Fluent-based animation: exploiting the relation between goals and scenarios for requirements validation

Scenarios and goals are effective and popular techniques for requirements definition. Validation is essential in order to ensure that they represent what stakeholders actually want. Rather than validating scenarios and goals separately, possibly driving the elaboration of one through the validation of the other, This work focuses on exploiting the relation between goals and scenarios. The aim is to provide effective graphical animations as a means of validating both. Goals are objectives that a system is to meet. They are elaborated into a structure that decomposes declarative goals into goals that can be formulated in terms of events that can be controlled or monitored by the system. Scenarios are operational examples of system usage. The relation between scenarios and goals is established by means of fluents that describe how events of the operational description change the state of the basic propositions from which goals are expressed. Graphical animations are specified in terms of fluents and driven by a behaviour model synthesised from the operational scenarios.

Fluent-based web animation: exploring goals for requirements validation

We present a tool that provides effective graphical animations as a means of validating both goals and software designs. Goals are objectives that a system is expected to meet. They are decomposed until they can be represented as fluents. Animations are specified in terms of fluents and driven by behaviour models.

Visual methods for Web application design

The paper outlines a tool-supported approach to the design of Web applications. Behavioural models are augmented with Web-based simulations of user interfaces to permit validation and usability assessment of systems by end users in advance of implementation. The goal is to correct architectural design decisions that adversely impact usability early in the design cycle when correction is relatively inexpensive. The behavioural model of a system captures the interactions between the different users roles and the set of components that constitute the application. A visual scenario-based language is used to specify interactions and the tool LTSA-MSC is used to synthesise the required behavioural model. The tool supports a visual representation of this model that is animated in response to user-interaction with the simulated Web interface. The combination of these facilities permits agile incremental elaboration of a system design.

Software Performance Testing in Virtual Time

We show how traditional unit testing frameworks can be extended to support the simultaneous testing of behaviour and performance, by embedding performance models in mock objects. Because such models are virtual, and therefore execute in virtual time, performance tests can often be performed substantially quicker than when real resources are involved. Performance models also facilitate testing before some or all of a unit»s intended collaborators have been implemented. A key technical challenge is to overcome the impedance mismatch which arises when code that is executing in real time has to communicate with performance models that execute in virtual time. Solutions to this problem naturally facilitate virtual time scaling of both real code and performance models. We also explore potential applications of such time scaling in software performance testing and optimisation.