Over the last several years, we have developed an object-oriented, knowledge-based construction kit for human-computer communication (HCC) and a large number of associated tools and intelligent support systems needed to exploit this kit effectively. Answers to the ``HCC design question'' are given by providing appropriate building blocks which suggest the way HCC's should be built. The object-oriented system architecture is highly flexible and enhances the reusability of many building blocks. In designing new HCC capabilities the designer can use either existing objects or objects with minor modifications, and can thereby rely on standard and well-tested components. Our support tools analyze HCC systems, provide assistance and guidance in building them, and create informative graphical displays of their structure. They help the designer regain control over systems that have become too complex to master without support tools. Our research efforts have given us an understanding of how the concepts and abstractions of our HCC toolkit have evolved and of what it means today to design new systems that make use of various types of graphical representations, icons, windows, and menus.

The user interface is the external representation of the capabilities of a system. The user feels the computer through the user interface, which is the software that mediates between the user and the programs that shape the computer into a tool for a specific goal, whether the goal is to compose music, design a computer game, do scientific computations, or write an article. The user interface was traditionally the last part of the development process; now it should be the first. It is more than just an additional component; it is an integral and important part of the whole system. The traditional design process, proceeding from the ``inside'' to the ``outside,'' should be reversed whenever possible. The design, development, and evaluation of new information systems — indeed of any new technology — should start with an understanding of the overall social and technical environment in which they are embedded.

The user interface is crucial for novices and professionals alike because what it presents to their senses is the computer. ``The user illusion is the simplified myth (the mental model) everyone builds to explain (and makes guesses about) the system's actions and what should be done next'' [8].

The challenge for the designers of user interface software is in meeting a large number of requirements. Designers must

The design space of modern user interfaces is enormous, and designing a complex user interface often takes years (designing the Xerox Star, for example, took more than six years). To make this task manageable, we have over the last six years designed, implemented, and enhanced a construction kit called WLisp [1,3]. WLisp is based on an object-oriented architecture and contains a large amount of knowledge about the design of user interfaces. The WLisp system has been an everyday operational environment at a number of institutions within universities and research organizations for several years. WLisp has served the designers of user interface software as well as the end-users.

Most other systems which support windows, menus, icons and mouse interaction are based on high performance personal computers. WLisp is implemented in a time sharing environment using powerful terminals (currently running on VAX systems, using FranzLisp and our object-oriented knowledge representation language ObjTalk [10]). This environment provided a necessity and a chance to implement a distributed architecture between terminals and main frame. WLisp has recently also been made available on Symbolics lisp machines.

WLisp is a good example of the class of systems that evolve to fit an environment of needs, rather than carrying out a single, well-specified task. In these systems, the main activity of programming is no longer the origination of new programs but the redesign of existing ones and the reuse of building blocks. To make this transition, the designer must thoroughly understand how these parts function. The level of understanding necessary for successful redesign and reuse is an important question: Exactly how much does the user have to understand about existing objects? Our new programming methodologies and support tools (e.g., the Browser; see Figure 1) are steps toward making it easier to modify an existing system than to create a new one. Inheritance is important for redesign and reuse, because it enables the easy creation of objects that are almost like other objects with a few incremental changes. Inheritance reduces the need to specify redundant information and simplifies updating and modification because information can be entered and changed in one place.

A construction kit with a large number of generally useful building blocks provides a good basis for redesign. WLisp consists of more than 200 ObjTalk classes. This number is both an advantage and a disadvantage for a system of this kind. The advantage is that in all probability, an existing building block or set of building blocks — which have been used and tested before — either fit the users' needs directly or come close to doing so. The disadvantage is that the user may never discover their existence.

Informal experiments [4] indicate that the following problems prevent users from successfully exploiting the potential of high-functionality systems:

Support tools are needed to augment a construction kit. They should provide guidance in building user interfaces, and they should analyze or criticize them and visualize their structure. These tools are systems that incorporate knowledge about user interfaces that goes beyond what went into the design of individual components. Figure 2 describes our vision of the architecture of an intelligent design environment. This architecture is based on the belief that the ``intelligence'' of a complex tool must contribute to its ease of use. We have built prototypical systems in many areas of the outer circle: documentation systems [7], help systems [6], critics [4], and visualization tools [2].

Currently, the use of the WLisp user-interface components requires considerable expertise, which has to be acquired through an extended learning and experimentation period. We have constructed a number of design kits [5] to support the modification and construction of new systems from sets of predefined components. In contrast to simple software construction kits, which present the designer only with the available parts and the operations to put them together and to run the resulting system, our design kits give additional support. They incorporate knowledge about which components fit together and how they do so; and they contain a critic that recognizes errors and inefficient or useless structures. They are able to deal with multiple representations of the design.

Design kits constrain the design space and leave beginners with fewer choices by providing defaults and grouping the available functions. They reduce the amount of knowledge designers have to acquire before they can do useful work. This is especially important when the design environment contains many special-purpose components, each of which is used only rarely even by a full-time designer.

No formal assessment has been made of the WLisp system, but user reaction has been largely positive, and a large number of complex systems using different user interfaces have been built with WLisp. Our system-building effort reinforced our basic assumption that in user interface design ``there are no optimal solutions, only trade-offs.'' How do we balance the effort and the large training costs necessary to learn a complex interface with the power of having extensive functionality? Should we design the user interface completely or should we develop meta-systems that enable end-users to alter interfaces according to their needs? Should systems be adaptive that is, should the system itself change its behavior based on a model of the user and the task or should systems be adaptable by the user? Will systems that give control to the user be less complicated because they do not have to anticipate all possible futures? Who has control over the system? Does the system or the user make decisions about such things as the size of a window? In our experience, these trade-offs cannot be made in the abstract, but have to be carefully balanced for specific situations.

The strengths of WLisp are substantial. It is a powerful environment for rapid prototyping of a large class of interfaces. It provides a large class of building blocks that guarantee the construction of high-quality interfaces with relatively low construction costs. It contains many associated support tools that make it easier to learn and work with a complex system. The object-oriented architecture achieves uniformity, extensibility, and incremental development.

The weaknesses of WLisp are that it is a complex system and requires considerable learning time. The rich set of classes allows a user to select and specialize, but there is insufficient knowledge to support these processes. The question is: How do we find what we do not know? The system needs more active tools or agents that have sufficient self-knowledge to offer their services to the user. And WLisp provides little support for transforming a problem model, which is the user's vague and imprecise conceptualization of the task, into the corresponding system model.

Construction and tool kits are promising steps toward our goal of replacing human-computer communication with human problem-domain communication. Human problem-domain communication is an important step forward because users operate within the semantics of their domain of expertise and the formal descriptions closely match the structures of the problem domain. Whenever the user of a system can directly manipulate the concepts of an application, programs become more understandable and the distinction between programmers and non-programmers vanishes.

We will investigate the trade-off between simple tools and intelligent tools. Both kinds of tools have problems. Simple tools require too much skill and too much time and effort from the user; for example, it is still non-trivial to construct an interesting user interface with WLisp. Most intelligent tools fail to give any indication of how they operate and what they are doing; the user feels like an observer watching while unexplained operations take place. This mode of operation results in a lack of control over events, one of the most frustrating experiences of dealing with computer systems.

Traditionally, in most programs, interaction between the human and the program has been limited to an exchange of small pieces of information. We are concerned with a new class of computer systems that support cooperative problem-solving processes by providing advice, criticism, and explanation. In these systems, the boundaries between the user interface portion and the application system become much less clear than in traditional systems. WLisp is a good first approach to dealing with new systems for cooperative problem solving.