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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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

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.

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.

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.

Abstract: : A prototype 'presentation system base' is described. It offers mechanisms, tools, and ready-made parts for building user interfaces. A general user interface model underlies the base, organized around the concept of a 'presentation': a visible text or graphic form conveying information. The base and model emphasize domain independence and style independence, to apply to the widest possible range of interfaces. The 'primitive presentation system model' treats the interface as a system of processes maintaining a semantic relation between an 'application data base' and a 'presentation data base', the symbolic screen description containing presentations. A 'presenter' continually updates the presentation data base from the application data base. The user manipulates presentations with a presentation editor. A 'recognizer' translates the user's presentation manipulation into application data base commands. The primitive presentation system can be extended to model more complex systems by attaching additional presentation systems. In order to illustrate the model's generality and descriptive capabilities, extended model structures for several existing user interfaces are discussed. The base provides support for building the application and presentation data bases, linked together into a single, uniform network, graphics to continuously display it, and editing functions. A variety of tools and mechanisms help create and control presenters and recognizers. To demonstrate the base's utility, three interfaces to an operating system were constructed, embodying different styles: icon, menu, and graphical annotation.

Abstract: Natural language processing has two primary roles to play in the storage and retrieval of large bodies of information: providing a friendly, easily-learned interface to information retrieval systems, and automatically structuring texts so that their information can be more easily processed and retrieved. This article outlines the organization of a natural language interface for data retrieval (a “question—answering system”) and some of the approaches being taken to text structuring. It closes by describing a few of the research issues in computational linguistics and a possibility for using interactive natural language processing for information acquisition.

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.

Abstract: One of the problems that often faces the user of a large software system is a lack of uniformity or consistency in the user interface. Responses that elicit the desired system behavior in one context may fail completely in another— often accompanied by an obscure error message. As a result, the user may be well aware that the user interface is a disparate collection of programs written by different programmers, each with a different view on interface design. A related problem faces developers of an application intended to fit into an existing system. All too often they have to construct “system-tailored,” low-level user interface routines, usually without the benefit of the facilities and documentation available to the original system developers. This situation almost encourages the disorder and inconsistency that so often plagues an end user. We have adopted the view that these problems arise primarily when implicit knowledge about individual tasks is encoded in the user interface. What results is an unclear separation between actual computations involved in the execution of a task and data acquisitions (often from an end user) needed to execute a task. We have therefore experimented with a system design in which the user interface has a minimal a priori knowledge of individual tasks. The interface has facilities for acquiring data using interaction mechanisms relevant to a particular task domain but has no knowledge of any particular task in that domain. To effect this separation, we have used hierarchical, symbolic descriptions of computation of the type that has been applied in automatic programming, fault diagnosis, and digital hardware design. These descriptions incorporate a modular, object-oriented encapsulation of the information necessary to execute a task, an explicit representation of control and data flow, a formal description of the function, and the facilities for viewing computation at a number of levels of abstraction. Existing formalisms, however, have not been generated with the user interface in mind. Several types of input data information are usefully added for the purpose of structuring the user interface. For example, producing extensive descriptions of input data for the user interface has a two-fold result: the descriptions function as both constraints on the input data and as guidelines to the user interface concerning appropriate interaction mechanisms. The advantages of this approach to user interface design are:

Abstract: This paper reports the findings of an experiment conducted to observe the command abbreviation behat~ior of users of an interactive decision-support system. The subjects were not given any specific instructions on how to abbreViate or any !ncentives to use abbreviations. Nevertheless, 62.5 percent of the subjects abbreviated commands consistently and over 80 percent of the subjects who abbreviated Used the truncation method exclusively. The number of abbreviation errors due to truncation was less than 2 percent of the abbreviated commands. The use of abbreviations was positively correlated with the length of commands and the frequency of use of commands.

Abstract: This thesis presents new results in the use of term rewriting systems for automatic theorem proving. The design and implementation of REVE 2, a computer program that incorporates these results, is described. In addition, an introduction to the basic theory, procedures, and algorithms of term rewriting is provided, in a manner suitable for non-specialists. A principal application of rewriting systems is reasoning about the equational and inductive theories associated with a finite set of axioms. In this context, the Knuth-Bendix completion procedure is typically used in the hope of constructing a confluent and termination rewriting system from the axioms. Knuth-Bendix in automatic proofs of equational and inductive theorems have been: 1) the need for user interaction, and 2) the lack of available state-of-the art implementations. REVE 2 reduces the need for user interaction in two ways. First, it uses automatic orderings whose implementations automatically compute all of the possible valid extensions to the ordering that allow an unorderable equation to be ordered. Second, it uses a robust, task-based, failure-resistant Knuth-Bendix design that incorporates a fine-grained scheme for automatic equation postponement. From the beginning, it has been a fundamental design goal to make REVE 2 a well-documented, highly-modular, easily-modified program, based on sound principles of software engineering. The user interface to REVE 2 has been designed for ease of use by both novice and expert.

Abstract: What is in This Chapter ? This chapter discusses developing JAVA applications that bring up windows that the user can interact with. It discusses Graphical User Interfaces and how we can develop our own to represent main windows for our JAVA applications.