Showing papers on "User interface published in 1984"

Heuristics for designing enjoyable user interfaces: lessons from computer games

Abstract: In this paper, I will discuss two questions: (1) Why are computer games so captivating? and (2) How can the features that make computer games captivating be used to make other user interfaces interesting and enjoyable to use?After briefly summarizing several studies of what makes computer games fun, I will discuss some guidelines for designing enjoyable user interfaces. Even though I will focus primarily on what makes systems enjoyable, I will suggest how some of the same features that make systems enjoyable can also make them easier to learn and to use.

The synthesizer generator

Abstract: Programs are hierarchical compositions of formulae satisfying structural and extra-structural relationships. A program editor can use knowledge of such relationships to detect and provide immediate feedback about violations of them. The Synthesizer Generator is a tool for creating such editors from language descriptions. An editor designer specifies the desired relationships and the feedback to be given when they are violated, as well as a user interface; from the specification, the Synthesizer Generator creates a full-screen editor for manipulating programs in the language.

Response time and display rate in human performance with computers

Abstract: The pace of human-computer interaction is an important issue to computer scientists and computer users alike. Experimental results have begun to shed some light on this complex, controversml, and vital subject. This paper revmws the theory and reports on experimental results concerning display rates, response time expectations and attitudes, user productivity, and variability. The decomposition of concerns and tasks helps to clarify the issues, but substanhal effort remains before a predictive model can emerge. In general, the results indicate that frequent users prefer response times of less than a second for most tasks, and that productwlty does increase as response time decreases. However, error rates increase with too short or too long a response time. Users pick up the pace of the system, but the profile of commands may change with the speed of the system

Training wheels in a user interface

Abstract: New users of high-function application systems can become frustrated and confused by the errors they make in the early stages of learning. A training interface for a commercial word processor was designed to make typical and troublesome error states “unreachable,” thus eliminating the sources of some new-user learning problems. Creating a training environment from the basic function of the system itself afforded substantially faster learning coupled with better learning achievement and better performance on a comprehension post-test. A control group spent almost a quarter of their time recovering from the error states that the training interface blocked off. We speculate on how this training strategy might be refined, and more generally, on how function should be organized in a user interface.

Building a user-derived interface

Abstract: Many human-computer interfaces are designed with the assumption that the user must adapt to the system, that users must be trained and their behavior altered to fit a given interface. The research presented here proceeds from the alternative assumption: Novice behavior is inherently sensible, and the computer system can be made to adapt to it. Specifically, a measurably easy-to-use interface was built to accommodate the actual behavior of novice users. Novices attempted an electronic mail task using a command-line interface containing no help, no menus, no documentation, and no instruction. A hidden operator intercepted commands when necessary, creating the illusion of an interactive session. The software was repeatedly revised to recognize users' new commands; in essence, the interface was derived from user behavior. This procedure was used on 67 subjects. The first version of the software could recognize only 7 percent of all the subjects' spontaneously generated commands; the final version could recognize 76 percent of these commands. This experience contradicts the idea that user input is irrelevant to the design of command languages. Through careful observation and analysis of user behavior, a mail interface unusable by novices evolved into one that let novices do useful work within minutes.

NESTOR: A Computer-Based Medical Diagnostic Aid That Integrates Causal and Probabilistic Knowledge.

Abstract: : In order to address some existing problems in computer-aided medical decision making, a computer program called NESTOR has been developed to aid physicians in determining the most likely diagnostic hypothesis to account for a set of patient findings. The domain of hypercalcemic disorders is used to test solution methods that should be applicable to other medical areas. A key design philosophy underlying NESTOR is that the physicians should have control of the computer interaction to determine what is done and when. In order to provide such controllable, interactive aid, specific technical tasks to be addressed. The unifying philosophy in addressing them is the use of knowledge-based methods within a formal probability theory framework. A user interface module gives the physician control over when and how these tasks are used to aid in diagnosing the cause of a patient's condition. This dissertation presents the problems that are addressed by each of the three tasks, and the details of the methods used to address them. In addition, the results of an evaluation of the hypothesis scoring and search techniques are presented and discussed. Additional keywords: artificial intelligence; expert systems; medical applications; computer aided diagnosis; medical computer applications.

Magic: A VLSI Layout System

Abstract: Magic is a "smart" layout system for integrated circuits. The user interface is based on a new design style called logs, which combines the efficiency of mask-level design with the flexibility of symbolic design. The system incorporates expertise about design rules and connectivity directly into the layout system in order to implement powerful new operations, including: a continuous design-rule checker that operates in background to maintain an up-to-date picture of violations; an operation called plowing that permits interactive stretching and compaction; and routing tools that can work under and around existing connections in the channels. Magic uses a new data structure called corner stitching to achieve an efficient implementation of these operations.

The depth/breadth trade-off in the design of menu-driven user interfaces

Abstract: An experiment is reported investigating the role of depth and breadth of menus and tree structures in user interfaces for information-retrieval systems. The results suggest minimizing the depth of tree structures by providing menus of eight or nine selections each. This limit on menu breadth is consistent with known limits on human information processing capacity.

A Conversational Telephone Messaging System

Abstract: The Phone Slave is an intelligent answering machine, conversing with callers to format messages and relaying personal greetings to identified partles. Its owner can access these voice messages as well as electronic mail via speech recognition or Touch-Tones over the phone network. Access to both lncoming and outgoing messages, an on-line directory, and autodial features are also provided by a touch-sensitive color monitor.

Report on Dialogue Specification Tools

Abstract: One of the goals of User Interface Management Systems (UIMS) is the automatic (or semi-automatic) construction of user interfaces. In order to accomplish this a description of the user interface to be implemented must be available. This report addresses three questions related to user interface descriptions. These questions are: what user interface descriptions are required to automatically produce a user interface, how do these descriptions relate to the human factors of user interfaces, and how can the existing user interface description techniques be classified? In order to address these questions an abstract model of a UIMS has been developed. This model does not represent how a UIMS should be’ structured or implemented, instead it presents the logical components that must appear in a UIMS. Each of these components has a different function, and different description techniques are required for each one. The logical model of a UIMS is shown in fig. 1. This model is similar to ones proposed by Edmonds [Edmonds 1982], Green [Green 1984], and Olsen [Olsen 1984]. Each of the components of this model will now be discussed.

Stages and levels in human-machine interaction

Abstract: The interaction between a person and a computer system involves four different stages of activities--intention, selection, execution, and evaluation--each of which may occur at different levels of specification. Analysis of these stages and levels provides a useful way of looking at the issues of human-computer interaction.

User interface processor for computer network with maintenance and programmable interrupt capability

Abstract: A processor forms part of a computer network wherein the processor, designated as the User Interface Processor, operates to initialize and maintain and communicate to remote diagnostic terminals for purposes of confirming integrity of the system and also for finding the location of any faults or problems in the system. The User Interface Processor involves a microprocessor unit working in conjunction with a serial communications controller, random access memory and read only memory memories, a communications input/output (I/O) system, a multiple set of timer units and a priority interrupt controller. The User Interface Processor provides interfaces to a power control card unit, an I/O subsystem (of data link processors), and a remote terminal for diagnostic intercommunication.

A context for user interface management

Abstract: The design of the user interface management system (UIMS) is discussed within the context of the problems that it is intended to solve. The aim is not to review the various forms and strategies that have been proposed and used for UIMS development but rather to clarify the environment of a UIMS. The issues, which relate the services of a UIMS to the applications that it is intended to support, range along a continuum from the keystroke/transaction level, or micro level, to the macro level of integration across an entire application environment. Three examples are presented to illustrate the range of this continuum and the issues that arise at each level.

Ingredients of intelligent user interfaces

Abstract: In this paper, we discuss certain general features of intelligent user interfaces, such as the sources of knowledge needed by an interface to be considered intelligent, and characteristics desirable in an interface. We illustrate these ideas by examining two examples of interfacing between a user and a system: on-line HELP and tutoring. We conclude by briefly surveying some of the challenges to designers of interfaces.

Software engineering for user interfaces

Abstract: The discipline of Software Engineering can be extended in a natural way to deal with the issues raised by a systematic approach to the design of human-machine interfaces. Two main points are made: that the user should be treated as part of the system being designed, and that projects should be organized to take account of the current (small) state of a priori knowledge about how to design interfaces.Because the principles of good user-interface design are not yet well specified (and not yet known), interfaces should be developed through an iterative process. This means that it is essential to develop tools for evaluation and debugging of the interface, much the same way as tools have been developed for the evaluation and debugging of program code. We need to develop methods of detecting bugs in the interface and of diagnosing their cause. The tools for testing interfaces should include measures of interface performance, acceptance tests, and benchmarks. Developing useful measures is a non-trivial task, but a start can and should be made.

Lessons from a "living in a database" graphical query interface

Abstract: The Living In a Database system (LID) is a user-friendly interface to an entity-relationship database Its underlying ideas are similar to Cattell's PDB [Cattell 80], but its presentation is significantly different LID uses a bit-mapped graphics terminal with mouse pointer to create an attractive interaction environment. Experience from the implementation suggests that dynamic graphic displays --- those which have graphic symbols that change as the data they present change --- are an important feature in user interfaces but are difficult to implement with current technology The implementation also uncovers an important inadequacy in the PDB/LID idea the inability to operate on sets of data instances in the same way as individual data instances An extension to LID is suggested to alleviate the problem.

Design features of a frontal code for solving sparse unsymmetric linear systems out-of-core

Abstract: We discuss design features of a code which solves sparse unsymmetric systems of linear equations using a frontal method. We consider in particular the user interface, the internal data structures, the pivoting strategy, and the isolation of machine dependencies. We illustrate the performance of our code on a variety of test problems on both the IBM 3033 and the CRAY-1.

The future of interactive systems and the emergence of direct manipulation

Abstract: This paper suggests three motivations for the strong interest in human factors' aspects of user interfaces and reviews five design issues: command language versus menu selection, response time and display rates, wording of system messages, on-line tutorials, explanations and help messages and hardware devices. Five methods and tools for system development are considered: participatory design, specification methods, software implementation tools, pilot studies and acceptance tests and evolutionary refinement based on user feedback. The final portion of the paper presents direct manipulation, an approach which promises to become widely used in interactive systems. Direct manipulation involves representation of the object of interest, rapid incremental reversible actions and physical action instead of complex syntax.

Pushdown automata for user interface management

Abstract: An interactive pushdown automaton is defined as a model for user interface management dialogue control. The relationships between dialogue control and device handling are defined in terms of acquiring, releasing, enabling, and disabling of devices. Input modes are defined by sets of acquired devices and input states are defined by sets of enabled devices. A specified automaton describes the dialogue. Semantic controls of parse transitions, as well as pervasive transitions for exceptional conditions, are supported in the automaton. Algorithms are given to convert a specified automaton into an executable automaton. For the executable automaton an interpretation algorithm, which incorporates the control of input modes and states, is given. Examples are given for how various features present in other user interface management systems are modeled using the IPDA.

BB1: an architecture for blackboard systems that control, explain, and learn about their own behavior

Abstract: BB1 implements a domain-independent "blackboard control architecture" for Al systems that control, explain, and learn about their own problem-solving behavior. A BB1 system comprises: a user-defined domain blackboard, a pre-defined control blackboard, user-defined domain and control knowledge sources, a few generic control knowledge sources, and a pre-defined basic control loop. The architecture''s run time user interface provides capabilities for: displaying the blackboard, knowledge sources, and pending knowledge source actions, recommending an action for execution, explaining a recommendation, accepting a user''s override, executing a designated action, and running without user intervention. BB1 supports a variety of control behavior ranging from execution of pre-defined control procedures to dynamic construction and modification of complex control plans during problem solving. It explains problem-solving actions by showing their roles in the underlying control plan. It learns new control heuristics from experience, applies them within the current problem-solving session, and uses them to construct new control plans in subsequent sessions.

The role of context and adaptation in user interfaces

Abstract: A user interface can be viewed as a means of mapping user tasks to system tools. Context and adaptation are important features of a user/system interaction that can be used to simplify the task to tooi mapping and thereby improve the interface. A system based on these features would be able to adapt its actions to be appropriate for a given context. Two systems are used as examples of the use of context and adaptation. The POISE system provides assistance to the users of an office system based on models of office tasks. The adaptive document-retrieval system chooses the most effective search strategy for retrieving relevant documents in a given context. The techniques used to implement context and adaptation in these systems are considerably different, but in both systems the user interface is made more effective.

Fifth-Generation Computer Systems: A Japanese Project

Abstract: in recent years, there has been a great deal of discussioI onl the growing need for a new generation of computers. In 1982, a research project known as the fifth(generation computer systems, or FGCS, project, was started in Japan to further the research and development ot the next eeneration of computers. A.s observers ot thi.s project, we conjecture that the comiiputers of the next decade will be used increasingly for nonnumeric data processing such as symbol manipulation and applied artificial intelligence. Moreover, it appears that conventional svstems applications such as 'cientific calculations will be performed by the evolving supercomputers and that current database and mainfianme svstems will be improved for use in national and

The user interface for Sapphire

Abstract: Sapphire (the Screen Allocation Package Providing Helpful Icons and Rectangular Environments) is a powerful window manager running on the PERQ personal workstation. Following some background material, the author provides a tutorial on Sapphire's screen allocation package, focusing on its icons and user commands. The icons in Sapphire are intended to enhance the user's productivity when executing multiple tasks concurrently. Therefore, they present six pieces of information about the process being run, as well as two pieces of information about the status of the window. Thus, the user can easily tell whether the process running in the window has an error or wants attention and what percentage of the task has been completed. The user interface provides full functionality from both the pointing device and the keyboard and is easy for the novice while providing simple and powerful operations for experts. All commands are available from pop-up menus, but accelerators allow the most common commands to be executed with a single button press. The picture in the tracking symbol changes to show the operation that will be performed. This user interface promotes experimentation, since there is always appropriate feedback, and it is always possible to abort an operation once it has been started.

Executable interface definitions using form-based interface abstractions

Abstract: The integral bit-map displays and considerable computational power of the new generation of personal workstations offer the possibility of excellent user interfaces. Yet this potential is often unfulfilled because of the cost and complexity of building user interfaces that fully exploit the available resources. A solution to this problem is to define user interfaces through a language embodying appropriate interface abstractions. Such interface definitions can be interpreted by a central interface system to realize an interface that a user can interact with. If the interface abstractions employed are at a suitably high level, the task of constructing individual interfaces is much simplified, with the complexities of exploiting sophisticated interface hardware limited to the construction of the central interface system. A specific set of interface abstractions is presented. The abstractions are oriented around a formfilling metaphor of communication between user and application program. They are suitable for defining command interfaces for many, but not all, applications. An attempt is made to delimit their range of applicability. An interface system that runs on a Perq, a powerful personal workstation, is described. This interface system can interpret interface definitions expressed in a language embodying the interface abstractions just mentioned. The result of this interpretation is a graphical interface with many user-friendly features. An example of an interface definition and the interface that results from it is given. To Appear in: /Advances in Human-Computer Interaction, H. R. Hartson, Ed., Ablex, 1984. Th is research was sponsored by the Defense A d v a n c e d Research Pro jects A g e n c y ( D O D ) , A R P A O r d e r No. '3597, monitored by the Air F o r c e Avionics Laboratory Under Cont ract F33615-81-K-1539. T h e v iews and conc lus ions conta ined in this document are those of the author and should not be interpreted as representing the official pol icies, either e x p r e s s e d or implied, of the Defense A d v a n c e d Research Projects A g e n c y or the U S Government . Table of

Playback: a method for evaluating the usability of software and its documentation

Abstract: Human factors evaluations of software products and accompanying user publications must be conducted so that developers can be certain that the target user population can learn to use the product with a minimum of difficulty and be able to perform the intended tasks efficiently. A methodology is described for obtaining objective measures of product usability by collecting performance data on the user interface without affecting the user or the system being evaluated. The log of stored activity is later played back through the host system for analysis.

Distributed query processing strategies in Mermaid, a frontend to data management systems

Abstract: The Mermaid testbed system has been developed as part of an ongoing research program at SDC to explore issues in distributed data management. The Mermaid testbed provides a uniform front end that makes the complexity of manipulating data in distributed heterogeneous databases under various data management systems (DBMSs) transparent to the user. It is being used to test query optimization algorithms as well as user interface methodology.

Corporate identity for iconic interface design: The graphic design perspective

Abstract: The term corporate identity program is well-known in the graphic design field, which has applied the approach to the traditional areas of stationery, vehicle identification, signage, and other forms of complex communication. It is argued that this approach should be extended to the design of screens, especially for high-resolution, iconic, multiwindow interfaces. Typography, symbolism, and color are discussed from this perspective, and three case studies, namely, the Xerox Star, the Apple Lisa, and the Intran Metaform system, are examined.

Knowledge-based communication processes in software engineering

Abstract: A large number of problems to be solved with the help of computer systems are ill-structured. Their solution requires incremental design processes, because complete and stable specifications are net available.For tasks of this sort, life cycle models are inadequate. Our design methodology is based on a rapid prototyping approach which supports the coevolution of specification and implementation. Communication between customers, designers and implementors and communication between the humans and the knowledge base in which the emerging product is embedded are of crucial importance. Our work is centered around knowledge-based systems which enhance and support the communication needs in connection with software systems.Program documentation systems are used as an example to illustrate the relevance of knowledge-based human-computer communication in software engineering.

Seeing what your programs are doing

Abstract: The advent of personal computers with high resolution displays and pointing devices will permit a drastic improvement in the quality of user interfaces for programming environments. Programming environments already are beginning to make use of interac-tive graphics as a tooi for helping us visualize the operation of programs we write. Watching a program work step-by-step, where each step is reflected in visible changes to the display screen, greatly facilitates understanding of the internal workings of a program. But the power of interactive graphics for program visualization has yet to be exploited in a programming environment as a tooi for creating programs, as opposed to merely observing already-written programs. Tinker is a programming environment for Lisp in which a program is constructed by demonstrating its steps on representative examples, and the system displays graphically the result of each step as it is performed. The programmer can “see what the program is doing” while the program is being constructed. The processes of writing a program and debugging it on test cases are combined into a single interactive activity, rather than separated as they are in conventional programming environments. To help the reader visualize the operation of Tinker itself, an example is presented of how Tinker may be used to construct an alpha-beta tree search program.