Smalltalk-80: the language and its implementation
Smalltalk-80: the language and its implementation
SMALLTALK-80: the interactive programming environment
SMALLTALK-80: the interactive programming environment
A generalized user interface for applications programs (II)
Communications of the ACM
The Trillium user interface design environment
CHI '86 Proceedings of the SIGCHI Conference on Human Factors in Computing Systems
Design alternatives for user interface management sytems based on experience with COUSIN
CHI '85 Proceedings of the SIGCHI Conference on Human Factors in Computing Systems
Sarek: a window system interface for object-oriented concurrent programming languages
OOPSLA/ECOOP '88 Proceedings of the 1988 ACM SIGPLAN workshop on Object-based concurrent programming
Surveying current research in object-oriented design
Communications of the ACM
OOPSLA/ECOOP '90 Proceedings of the European conference on object-oriented programming on Object-oriented programming systems, languages, and applications
A framework for run-time systems and its visual programming language
Proceedings of the 11th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Hi-index | 0.02 |
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.