Abstract
The paper discusses automation of user
interface design and proposes a user interface design method that combines the
use of formal semantic specification and rapid user interface builders. Based
on formalized design rules, a user interface design proposal can be derived
from the functionality of an application. The advantages of this method are:
Automation of parts of the design process, automatic design evaluation, and
automatic mapping to multiple user interface toolkits. The method will ease
the transition from the functional design of an application to the user
interface design by a semantically driven design of user interfaces.
Keywords
Interface Design, Automatic Generation of User Interface, Design Process.
Introduction
A number of research systems have demonstrated how to automatically generate a
user interface design from a high level specification (de Baar, 1992; Janssen,
1993; Puerta, 1994; Vanderdonckt 1993). Most systems concentrate on automatic
selection of appropriate interaction objects and layout of the selected
objects, based on some kind of data model specification. Within the
development of these systems a lot of work has been done to define the right
selection rules for selecting interaction objects and defining layout rules
for the selected objects. Each of the systems introduces its own notation or
extends existing notations for the high level user interface
specification. Many of the extensions for data models are data type
attributes, which should be part of any type declaration or should be
obtainable from the type declaration, as it is in type strong formal
specification languages and programming languages. This paper concentrates on
defining a model to be used as a basis for the translation from a functional
specification to a user interface layout specification and translation from
user interface layout specification to a template for dialog control
specification.
The design method described combines rapid prototyping of screen layouts with
structured design of the behavior of the user interface. By using a formal
specification method with a proper set of primitives, high level abstraction
is supported during the design phase, and it is possible to analyze and reason
about features like consistency, reversibility, etc. of user interfaces. This
makes it possible to incorporate control of checklists and guidelines in the
design method, to produce test systems and to test the complexity and behavior
of a user interface.
COUPLING FUNCTIONALITY AND USER INTERFACE
In this design method the user interface can be prototyped using a UI (User
Interface) builder. The result of the UI builder can be translated into a
template for the semantic specification of the user interface. The template is
used for the semantic specification of the dynamic behavior. The semantic
specification may change the layout if new functions or function parameters
are added. For this purpose the specification can be translated back into a
layout specification which can be edited in the UI builder. Source code can
be generated from the final specification of both layout and semantics.
Alternatively, a semantic specification of an application can be used to
automatically derive a prototype of the user interface design. Generation of
a user interface prototype is based on formalized style rules and
guidelines. This prototype can be edited with the UI builder, and the design
can be iterated as described above. The semantic specification provides for
the missing program structure when using UI builders.
The process consists of a stepwise transformation from functional
specification of the functional core over a semantic user interface
specification to a user interface layout specification. The semantic user
interface specification specifies the dialog control between the functional
core and the user interface, without any consideration for specific
interaction objects' presentation and layout. While the user interface layout
specification specifies the static layout without considering the dynamic
behavior.
Abstract SPECIFICATIONS
The design method relies on an architectural model, which separates an
application in a functional core, functional core adapter, dialog control,
logical interaction and physical interaction (the Arch/Slinky model (UIMS,
1992)). The dialog control and the logical interaction is specified by an
agent model derived from Abowd's agent language (Abowd, 1991). The agents are
the primitives in the dialog control specification.
Translation to Dialog Control Specification
A specification of the functional core is translated into a dialog control
specification in the following way: All functions generate a command agent,
and for each function a view agent is generated for the input parameters and
another view agent for the output parameters. Simple parameters are translated
into entity agents, and parameters of, for example, an enumeration type will
be translated into exclusive choice agents, etc.
A specification of the user interface layout is translated into a dialog
control specification by transforming all interaction objects into a hierarchy
of their corresponding dialog control agents. For example, push-buttons will
be translated into command agents, and radio-buttons into an exclusive choice
agent, etc.
Transition between views, window navigation, and update of data objects in
different views must be specified explicitly in the dialog control
specification, as it is not a part of the semantic specification of the
functional core, nor is it a part of the user interface layout specification.
Translation to User Interface Layout Specification
The design of the presentation and actions is generated using a system for
automatic selection of interaction objects, as for example in TRIDENT
(Vanderdonckt, 1993), which uses the dialog control specification to generate
the layout.
Requirements for Functional Specifications
In order to be able to generate user interface specifications, some
restrictions must be imposed on the specifications of the functional core
adapter, which is an interface between the functional core and the dialog
control. For example, functions working on the same primary data type should
be placed in the same class, and will be grouped in the same menu in the user
interface. Secondary functions, which should not be present in the user
interface, should not be present in a class specification translated into a
user interface specification. The specified functions need to describe user
tasks in order to map adequately to users' domain model.
CONCLUSION AND FUTURE WORK
This design method extends the data model approach for generation of user
interfaces. The advantages are:
- Easy transition from functional core specification to user
interface layout specification.
- More information about application functionality is used in
the user interface generation.
- Explicit definition of a dialog control layer.
- A more complete user interface can be generated, including both
static layout and dynamic behavior.
- Support for revisions and for keeping specifications consistent.
The design method suggests a further integration between the functional core
design and the user interface design in the application development than do
most existing systems of today.
Work on reasoning about user interface features for evaluation purpose are
being carried out at the moment.
References
Abowd, G. D. (1991).
Formal Aspects of Human-Computer Interaction.
Ph.D Thesis. Oxford University Computing Laboratory, Oxford.
Baar, D. J. M. J. de & Foley, J. D. & Mullet, K. E. (1992).
Coupling Application Design and User Interface Design.
In CHI'92 Conference Proceedings,
ACM Press. pp 259-266.
Janssen, C. & Weisbecker, A. & Ziegler, J. (1993).
Generating User Interfaces from Data Models and Dialogue Net Specifications.
In INTERCHI'93 Conference Proceedings,
ACM Press. pp 418-423.
Puerta, A. R. & Eriksson, H. & Gennari, J. H. &
Musen, M. A. (1994).
Beyond Data Models for Automated User Interface Generation.
In People and Computers IX, Proceedings of HCI'94,
Cambridge University Press. pp 352-366.
UIMS Tool Developers Workshop (1992).
A Metamodel for the Runtime Architecture of an Interactive System.
In SIGCHI Bulletin. 24(1). pp 32-37.
Vanderdonckt, J. M. & Bodart, F. (1993).
Encapsulating Knowledge for Intelligent Automatic Interaction Object Selection.
In INTERCHI'93 Conference Proceedings.
ACM Press. pp 424-429.
