painless panes for smalltalk windows
Current windowing systems (i.e., Macintosh, Smalltalk) give the user flexibility in the layout of their computer display, but tend to discourage construction of new window types. Glazier is a knowledge-based tool that allows users to construct and test novel or special purpose windows for Smalltalk applications. The use of Glazier does not require understanding Smalltalk's windowing framework (Goldberg, 1984; Goldberg & Robson, 1983). As a new window is specified, Glazier automatically constructs the necessary Smalltalk class, and methods (programs). Windows are interactively specified in a Glazier window - the user specifies type and location of panes through mouse motions. Panes can contain text, bit-maps, lists, dials, gauges, or tables. The behavior of a pane is initially determined by Glazier as a function of the pane type and related defaults. These default behaviors allow the window to operate, but do not always display the application information desired. In that case, the user can fix the window's behavior by further specification. Such alterations require only knowledge of the application, not of the windowing system. Glazier allows the prototyping and development of full-fledged Smalltalk windows, and allows a flexibility that will change window usage in two ways. First, it will allow end users to construct special purpose windows for viewing data from an application in manners unanticipated by the system designers. Second, system developers will be encouraged to prototype and evaluate many window configurations before settling on a final choice. Both alternatives will result in windows that are more satisfying to the end-user. The makeup of Smalltalk or Macintosh-style windows is typically viewed as a fixed component of the computer interface. Windows are provided to the end user by the system designer and cannot be customized. Sadly, users are not allowed the flexibility of their window contents that windows allow for display contents. Thus, the user is forced to use windows that may not precisely fit the needs for his or her use of the application. Of course, the option of adding new windows is available to some users. A skilled Smalltalk user can construct a special-purpose window in an afternoon. Completion of such a task requires detailed knowledge of Smalltalk's model-view-controller (MVC) paradigm (Goldberg, 1984; Goldberg & Robson, 1983). This is perceived as an inconvenient, tedious task and is hardly something a novice Smalltalk programmer can or should attempt. This paper discusses Glazier, a tool that encapsulates knowledge about building Smalltalk windows, and assists a user in developing new Smalltalk windows. Glazier works as an assistant, relieving the user from the burden of thinking about windowing details. Instead, the user needs only to understand how to operate the data structures for the application being displayed by the window. Window development now becomes a symbiotic process, Glazier provides the knowledge on how to build the window and the user provides knowledge about how the application is used and how the window should behave. There are a numerous other systems to support interface development in a like manner. Bass (1985) describes a system for developing VT100 style interfaces on top of base-level applications. The system supports a wide range of user needs, but cannot be configured dynamically by the user. The Trillium System (Henderson, 1986) supports prototyping of copying machine interfaces and allows designers to build and test control panels. Other user interface management systems support construction of front ends for applications (Hayes, Szekely, & Lerner, 1985). None of these systems, however, has provided the user or developer with a dynamic environment for building generic windows. Glazier allows a user to build a wide range of window types, and use them as they are being built. This paper will discuss the operation of the Glazier, the method for constructing windows, and finally the implications of this new window construction technique.
smalltalk windows systems use user user flexibility layout computation types knowledge tool test applications understandability class method program locatability mouse text tables behavior functional informal case prototype developer change data design evaluation configurability component interfaces custom contention fit completeness task control novice programmer paper data structures process support user interface management system dynamic environment generic  framework  maps end-user model users