James Willans

A toolset supported approach for designing and testing virtual environment interaction techniques

Usability problems associated with virtual environments are a serious obstacle to their successful development. One source of these problems is that virtual environment toolkits provide only a small number of predefined interaction techniques that are expected to be used regardless of context, hence developers are not encouraged to consider interaction. In addition, there are no generally accepted development methodologies for virtual environments. Therefore, even when developers do consider interaction, it is likely to be in an ad hoc fashion driven by technology rather than requirements. If virtual environments are to be useful in a wider context, it is important to provide developers with methods (and tools to support the methods) by which interaction techniques can be systematically designed, tested and refined.In this paper we present the Marigold toolset which supports such a development process. The process begins with a visual specification of the technique being designed. This is requirements centred because it abstracts from implementation issues. Using the toolset, this specification is refined to a prototype implementation so that the technique can be explored in the context of the other elements of the environment. In this way, the developer can verify the technique against requirements in both the specification and prototype. Additionally, because the specification is readily understandable, users can be involved at both stages of the process.

Prototyping Pre-implementation Designs of Virtual Environment Behaviour

Virtual environments lack a standardised interface between the user and application, this makes it possible for the interface to be highly customised for the demands of individual applications. However, this requires a development process where the interface can be carefully designed to meet the requirements of an application. In practice, an ad-hoc development process is used which is heavily reliant on a developers craft skills. A number of formalisms have been developed to address the problem of establishing the behavioural requirements by supporting its design prior to implementation. We have developed the Marigold toolset which provides a transition from one such formalism, Flownets, to a prototype-implementation. In this paper we demonstrate the use of the Marigold toolset for prototyping a small environment.

Beyond Annotations: A Proposal for Extensible Java (XJ)

Annotations provide a limited way of extending Java in order to tailor the language for specific tasks. This paper describes a proposal for a Java extension which generalises annotations to allow Java to be a platform for developing domain specific languages.

Verifying the behaviour of virtual environment world objects

Virtual environments are rapidly becoming more widespread and finding application outside specialised laboratories. However, there has been relatively little research developing tools and techniques to aid their development. This is particularly the case when defining the dynamics of the virtual world objects with which the user perceives and interacts. The complexity of these world objects can often mirror their real world counterparts, yet they are usually defined using program or macro application code. Consequently, there is no opportunity, beyond ad-hoc prototyping, of ensuring the world objects behave as required. Our work is focusing on the verification and refinement of abstract virtual environment behavioural specifications to an implementation. In this paper, we exemplify how the dynamics of these world objects can be specified using a hybrid formalism. We discuss and demonstrate how meaningful verification can take place on these specifications.

A Unified Superstructure for UML.

A key aspect of successfully using UML is understanding the semantics of the notations. UML 2 will increase the already substantial collection of notations supported by UML 1.x. At the same time, this will augment the difficulty users experience in understanding semantics. In this paper we propose that while the diverse notations may render concepts differently, the concepts can often be considered semantically equivalent. This gives rise to an architecture where two single abstract syntaxes (structure and behaviour) underpin UML 2’s seven concrete syntax. Because there a fewer semantically distinct concepts, this makes UML both easier to understand and substantially easier to implement.

Transformation Language Design: A Metamodelling Foundation

With the advent of the Model-Driven Architecture (MDA) [3] there is significant interest in the development and application of transformation languages. MDA recognises that systems typically consist of multiple models (possibly expressed in different modelling languages and at different levels of abstraction) that are precisely related. The relationship between these different models can be described by transformations (or mappings).