Raymond J. A. Buhr

Use case maps for the capture and validation of distributed systems requirements

Functional scenarios describing system views, uses, or services are a common way of capturing requirements of distributed systems. However, integrating individual scenarios in different ways may result in different kinds of unexpected or undesirable interactions. We present an innovative approach based on the combined use of two notations. The first one is a recent visual notation for causal scenarios called use case maps (UCMs), which is used to capture and integrate the requirements. Integrating UCMs together helps avoiding many interactions before any prototype is generated. The second notation is the formal specification language LOTOS. UCM scenarios are translated into high-level LOTOS specifications, which can be used to validate the requirements formally through numerous techniques, including functional testing based on UCMs. LOTOS possesses powerful testing concepts and tools that we use for the detection of remaining undesirable interactions. To illustrate these concepts, we use a simple connection example and results from the capture and the validation of several telephony features from the First Feature Interaction Contest.

Software CAD: a revolutionary approach

A research project is described in which an experimental software CAD environment called the Carleton embedded system design environment (CAEDE), oriented toward embedded systems and Ada, was developed to provide a demonstration of the concept and to serve as a research testbed. The major contribution of CAEDE is a demonstration of a visual paradigm which combines semantic depth and syntactic shallowness, relative to Ada, in a manner that makes it possible for the embedded-system designer to work in terms of abstract machines while still thinking Ada. A secondary contribution is the identification of Prolog as a promising approach for supporting tool development in an environment which supports the visual paradigm. Also described are experimental tools for temporal analysis, performance analysis, and the generation of skeleton Ada code. >

Starvation and critical race analyzers for Ada

Starvation and critical race analysis tools for Ada designs are described. These tools are part of a temporal analysis toolset that includes an operational specification language, a language interpreter, and a deadlock analyzer for Ada. The starvation analyzer is based on a set-theoretic model of starvation. It uses a proof tree produced by the deadlock analyzer to define the possible computation space of the design. A preprocessing phase of the starvation tool optimizes the analysis so that the resulting analysis is efficient. Unlike livelock analysis in state machines, the starvation analyzer does not require a priori specification of home states to discern liveness. The critical race analysis tool provides semiautomatic proof of critical races by identifying nondeterministic rendezvous (races) from the proof tree generated by the deadlock analyzer, and then assisting the human operator in identifying which of these constitute critical races. Several design examples are used to demonstrate the capabilities of the two analysis methods. >

Computer Based Systems Engineering Workshop

Modern computer based systems are complex multi-systems consisting of many connected individual subsystems; each one of them is typically also a multicomputer system. The subsystems in a multi-system can be either geographically distributed or locally connected systems. Typical examples of computer based systems are medical systems, process control systems, communications systems, weapon systems and large information systems.

Making behaviour a concrete architectural concept

A practical approach is presented to making behaviour a concrete, first-class architectural concept. The approach overcomes the forest-tree problem that results when the only way of understanding behaviour in relation to the organizational aspect of architecture is in terms of sequences of inter-component interactions that emerge at run time (calls, messages, etc). The approach centers around diagrams called use case maps (UCMs) that superimpose sets of continuous wiggly lines (representing signatures of causal sequences) onto arrangements of boxes (representing organizational structure). A powerful feature of the approach is its ability to express large scale dynamic situations clearly. This paper does not present UCMs for the first time, but provides new insight into their essence in relation to architectural issues, alerts workers in the field of software architecture who have not encountered them before to their possibilities, and introduces for the first time a demonstration-of-concept tool to support them.

Applying use case maps to multi-agent systems: a feature interaction example

Multi-agent systems are emerging as a potential solution to the problem of constructing flexible network-based software. A characteristic of such systems is that whole-system behaviour patterns emerge from the combination of many details in many agents, in sometimes intricate ways. Understanding the big picture by composing the details is often difficult and designing the details to achieve some desired whole-system behaviour pattern can easily become a cut-and-try exercise. To help solve these problems, the authors offer use case maps (UCMs) to provide a first-class representation of whole-system behaviour patterns, at a level above details. To illustrate the approach, they apply it to a classical distributed system problem of a kind that agent systems must be capable of solving, namely feature interaction in telephony.

UCM-ROOM modelling: from use case maps to communicating state machines

A major problem we humans have in the engineering of complex, computer-based systems is understanding and defining how the required behaviour of a whole system is to be achieved by its components, without becoming lost in component-centric details such as internal state machines and intercomponent messages. This paper proposes and illustrates a modelling methodology for overcoming such problem that proceeds, in a systematic and traceable manner, from UCM models (use case maps), to MSC models (message sequence charts), to ROOM-style communicating-state-machine models. For concreteness in a limited space, the method is illustrated by a simple example that is not representative of the complex kinds of systems we have in mind.

Formal Support for Design Techniques: A Timethreads-LOTOS Approach

A design methodology which allies the graphical expressiveness of the timethread notation with the analytical power of the LOTOS language and its associated tools is presented. The concept of timethread is at the basis of a design methodology based on scenarios. A simple telephone system is used as an example. It is shown how the main scenarios of such a system can be expressed by the timethread notation, leading to an abstract system design. Further, it is shown how the notation can be translated into LOTOS. LOTOS tools are used to validate the high-level design. Tools used include LOLA for analysis and design testing, LMC for checking temporal logic properties, and GOAL for checking reachability of actions.

Using LOTOS in a Design Environment

Implementation of reactive systems is recognized as a difficult problem in the field of computer system engineering. Much of this difficulty arises due to the interactions between many components executing concurrently and the distributed nature of many of the systems. This paper describes an approach which can be used for the design of such systems and how LOTOS was integrated into this approach. The design approach involves alternating between structural design and behavioural design with LOTOS being the language used for formally specifying behavioural design. Different styles of specification can be used for defining the behaviour of a set of interconnected components, and this paper introduces a new style, the slice style, which describes behaviour as interactions propagating through a set of components. A number of problems were encountered regarding the expressiveness of LOTOS; the problems encountered as well as the proposed solutions are presented.

TimeBench: a CAD tool for real-time system design

This paper provides an overview of TimeBench, a prototype CAD tool for designing real-time systems, as well as some experiences gained through building and using it. TimeBench aims to support a true engineering design process for real-time systems in a largely graphical working environment. The environment includes support for design synthesis, analysis, and system generation, with equal emphasis on the design of operational structure and the design of temporal behavior. Its main features include: (1) a hybrid graphical---textual design description notation (MachineCharts, Abstract Controller Machines, and MachineChart Language), (2) design experimentation through an embedded interpreter and behavior visualization tools to animate designs, (3) further design evaluation through a performance modelling tool based on fast approximate analystic methods, and (4) a code generation system than can be tailored to produce code for a desired environment.