Warwick B. Mugridge

Constructing test suites for interaction testing

Software system faults are often caused by unexpected interactions among components. Yet the size of a test suite required to test all possible combinations of interactions can be prohibitive in even a moderately sized project. Instead, we may use pairwise or t-way testing to provide a guarantee that all pairs or t-way combinations of components are tested together This concept draws on methods used in statistical testing for manufacturing and has been extended to software system testing. A covering array, CA(N; t, k, v), is an N/spl times/k array on v symbols such that every N x t sub-array contains all ordered subsets from v symbols of size t at least once. The properties of these objects, however do not necessarily satisfy real software testing needs. Instead we examine a less studied object, the mixed level covering array and propose a new object, the variable strength covering array, which provides a more robust environment for software interaction testing. Initial results are presented suggesting that heuristic search techniques are more effective than some of the known greedy methods for finding smaller sized test suites. We present a discussion of an integrated approach for finding covering arrays and discuss how application of these techniques can be used to construct variable strength arrays.

Inconsistency management for multiple-view software development environments

Developers need tool support to help manage the wide range of inconsistencies that occur during software development. Such tools need to provide developers with ways to define, detect, record, present, interact with, monitor and resolve complex inconsistencies between different views of software artifacts, different developers and different phases of software development. This paper describes our experience with building complex multiple-view software development tools that support diverse inconsistency management facilities. We describe software architectures that we have developed and user interface techniques that are used in our multiple-view development tools, and we discuss the effectiveness of our approaches compared to other architectural and HCI techniques.

A variable strength interaction testing of components

Complete interaction testing of components is too costly in all but the smallest systems. Yet component interactions are likely to cause unexpected faults. Recently, design of experiment techniques have been applied to software testing to guarantee a minimum coverage of all t-way interactions across components. However, t is always fixed. This paper examines the need to vary the size of t in an individual test suite and defines a new object, the variable strength covering array that has this property. We present some computational methods to find variable strength arrays and provide initial bounds for a group of these objects.

Multi-Methods in a Statically-Typed Programming Language

Multivariant functions in Kea are a statically-typed form of the multi-methods of CLOS (Keene, 1989) but encapsulation is retained. Multivariants permit fine typing distinctions to be made, allow despatching to be avoided in some cases, and may be used to avoid some restrictions of the contravariance rule.

A decentralized architecture for software process modeling and enactment

Many development teams, especially distributed teams, require process support to adequately coordinate their complex, distributed work practices. Process modeling and enactment tools have been developed to meet this requirement. The authors discuss the Serendipity-II process management environment which supports distributed process modeling and enactment for distributed software development projects. Serendipity-II is based on a decentralized architecture and uses Internet communication facilities.

Supporting flexible consistency management via discrete change description propagation

A new software architecture for supporting inter-object consistency management is described. Objects with interdependent data values are kept consistent by propagating descriptions of object state changes along inter-object relationships. Response to and storage of these change descriptions supports the implementation of consistency management techniques in a more homogeneous way than existing models. Such techniques include efficient attribute recalculation and constraint schemes, multiple view consistency, and undo-redo, versioning and cooperative work facilities. Applications of the new architecture to user interface, graphical editor and programming environment construction are described.

Constructing component-based software engineering environments: issues and experiences

Abstract Developing software engineering tools is a difficult task, and the environments in which these tools are deployed continually evolve as software developers’ processes, tools and tool sets evolve. To more effectively develop such evolvable environments, we have been using component-based approaches to build and integrate a range of software development tools, including CASE and workflow tools, file servers and versioning systems, and a variety of reusable software agents. We describe the rationale for a component-based approach to developing such tools, the architecture and support tools we have used some resultant tools and tool facilities we have developed, and summarise the possible future research directions in this area.

Support for collaborative, integrated software development

A new model for supporting collaborative software development with shared, multiple textual and graphical views is presented. Multiple views of software development can be synchronously, semi-synchronously and asynchronously edited by different developers. View versions can be incrementally merged, and view updates broadcast to other developers and incrementally incorporated as required in their alternative versions. The model is illustrated by its use in a software development environment for an object-oriented language.<<ETX>>

Domain-specific visual languages for specifying and generating data mapping systems

Abstract Many application domains, including enterprise systems integration, health informatics and construction IT, require complex data to be transformed from one format to another. We have developed several tools to support specification and generation of such data mappings using domain-specific visual languages. We describe motivation for this work, challenges in developing visual mapping metaphors for different target users and problem domains, and illustrate using examples from several of our developed systems. We compare cognitive dimension-based evaluations of the different approaches and summarise the lessons we have learned.

Support for constructing environments with multiple views

We describe several approaches to supporting the construction of design environments with multiple views of common information. We then outline a new approach that draws on the best of each of them.