User interface development and software environments : the Chiron-1 system

User interface development systems for software environments have to cope with the broad, extensible and dynamic character of such environments, must support internal and external integration, and should enable various software development strategies. The Chiron-1 system adapts and extends key ideas from current research in user interface development systems to address the particular demands of software environments. Important Chiron-1 concepts are: separation of concerns, dynamism, and open architecture. We discuss the requirements on such user interface development systems, present the Chiron-1 architecture and a scenario of its usage, detail the concepts it embodies, and report on its design and prototype implementation

OSU : a high speed software development environment

Several problems with user interface design and implementation have been identified: (1) user interfaces are difficult and time­-consuming to design and implement; (2) most user interface management systems (UIMS) are themselves difficult to use by a programmer; (3) UIMS's have not been integrated with other tools that support structured design, coding and maintenance, thus failing to maximize programmer productivity. In the Oregon Speedcode Universe (O.S.U.) project, we had taken the following approaches: (1) direct manipulation programming technique is used to address the problems with user interface design and implementation; (2) integration of UIMS with CASE tools; and (3) high-level program generation from scripts, and reusable components. This report surveys some of the existing UIMS's and describes O.S.U., a high-speed software development system. The main emphasis of this work is the design and implementation of Structure Chart Editor in O.S.U.. The Structure Chart Editor has three unique features: 1) combination of functional decomposition with object-oriented design, 2) alternate architectural views, e.g. call graph, uses graph, object graph, and graphical display of procedures, 3) merging the user interface specification with design and coding specifications. Experimental results suggest that the techniques employed by OSU can be used to develop 50-90% of an application without explicit programming yielding 2-10 fold productivity improvements

An Object-oriented methodology for modern user interface development.

by Lam Siu Hong.Thesis (M.Phil.)--Chinese University of Hong Kong, 1991.Includes bibliographical references.Chapter Chapter1 --- Introduction --- p.1Chapter 1.1 --- Software Development Crisis of User Interface --- p.1Chapter 1.2 --- Objectives and Scope of Interests --- p.1Chapter 1.3 --- Overview of the Thesis --- p.2Chapter Chapter2 --- Background and Problems --- p.4Chapter 2.1 --- Categories of User Interfaces --- p.4Chapter 2.2 --- Trends of User Interfaces --- p.6Chapter 2.3 --- Some other Desirable Features and Problems of UI Development --- p.7Chapter 2.3.1 --- Separating UI from Application --- p.7Chapter 2.3.1.1 --- Benefits of Separable UIs and Applications --- p.7Chapter 2.3.1.2 --- Requirements of Complete Separation --- p.10Chapter 2.3.2 --- Instant Continuous Feedback --- p.12Chapter 2.3.2.1 --- Problems of Linguistic Model on World Model Type UIs --- p.12Chapter 2.3.3 --- Undo and Recovery --- p.15Chapter 2.3.4 --- Iterative Design through Rapid Protyping --- p.16Chapter Chapter3 --- An Object-Oriented Model for Model World User Interfaces Development --- p.18Chapter 3.1 --- Features of UIs to be supported by the Model --- p.18Chapter 3.2 --- A Linkage Model for Separating UI from Application --- p.19Chapter 3.2.1 --- Communication Messages Modeled using an Object Oriented Approach --- p.20Chapter 3.2.2 --- A Sample Message --- p.22Chapter 3.2.3 --- Linkage in a Distributed Heterogenous Environment --- p.24Chapter 3.2.4 --- Comparing the Linkage Model with the Application Interface Model in Seeheim's UI Model --- p.25Chapter 3.3 --- An Object-Oriented Model for Supporting Multiple Feedbacks and Multi-thread dialogue --- p.26Chapter 3.3.1 --- An Overview of the Model --- p.27Chapter 3.3.2 --- Objects on the Lexical Layer --- p.28Chapter 3.3.3 --- Roles of Presentation Objects --- p.29Chapter 3.3.4 --- Syntactic Objects --- p.31Chapter 3.3.5 --- Interaction Objects --- p.32Chapter 3.3.6 --- Interaction between objetcs and Linkage Component --- p.33Chapter 3.3.7 --- Multiple U-tubes Ladder for Supporting Multiple Feedbacks --- p.33Chapter 3.3.8 --- Recovery through a Generic UNDO stack --- p.35Chapter 3.3.9 --- Dialogue Control in an Object --- p.37Chapter 3.3.10 --- Interactive Objects --- p.39Chapter 3.3.11 --- An Architecture for Supporting Multi-thread Dialogue --- p.40Chapter 3.4 --- Basic Object Structure --- p.42Chapter 3.4.1 --- An Event Model for Dialogue Control --- p.43Chapter 3.4.2 --- Maintain Consistency through ε-rules --- p.45Chapter 3.4.3 --- An Example of an Inner Object Specification --- p.47Chapter 3.4.4 --- Pre and Post Condition of Action --- p.49Chapter 3.4.5 --- Automatic Message Routing --- p.49Chapter 3.5 --- Systematic Approach to UI Specification --- p.50Chapter Chapter4 --- User Interface Framework Design --- p.52Chapter 4.1 --- A Framework for UI Development --- p.52Chapter 4.1.1 --- Abstract Base Class for Each Object Type --- p.54Chapter 4.1.2 --- A Kernel for Message Routing --- p.60Chapter 4.1.3 --- Interaction Knowledge Base --- p.63Chapter 4.1.4 --- A Dynamic View of UI Objects --- p.64Chapter 4.1.5 --- Switch Box Mechanism for Dialogue Switching --- p.66Chapter 4.1.6 --- Software IC Construction --- p.68Chapter 4.2 --- Summaries of Object-Object UI Model and UI Framework --- p.70Chapter 4.2.1 --- A New Approach to User Interface Development 、 --- p.70Chapter 4.2.2 --- Feautures of UI Development provided by the Object-Object UI Model and UI Framework --- p.71Chapter Chapter5 --- Implementation --- p.73Chapter 5.1 --- Implementation of Framework in Microsoft Window Environment --- p.73Chapter 5.1.1 --- Implementation of automatic message routing through dynamic binding --- p.73Chapter 5.1.2 --- A generic message structure --- p.75Chapter 5.1.3 --- A meta class for object communication --- p.76Chapter 5.1.4 --- Software component of UI framework in Microsoft Window environment --- p.76Chapter 5.2 --- A Simple Stock Market Decision Support System (SSMDSS) --- p.77Chapter 5.2.1 --- UI Specification --- p.81Chapter 5.2.2 --- UI features supported by SSMDSS --- p.87Chapter Chapter6 --- Results --- p.89Chapter 6.1 --- Facts discovered --- p.89Chapter 6.1.1 --- Asynchronous and synchronous communication among objects --- p.89Chapter 6.1.2 --- Flexibility of the C+ + language --- p.90Chapter 6.2 --- Technical Problems Encountered --- p.91Chapter 6.2.1 --- Problems from Implementation Platform --- p.91Chapter 6.2.2 --- Problems due to Object Decomposition in an Interactive Object in SSMDSS --- p.92Chapter 6.3 --- Objectives accomplished by the Object-Oriented UI Model indicated by SSMDSS --- p.93Chapter Chapter7 --- Conclusion --- p.95Chapter 7.1 --- Thesis Summary --- p.95Chapter 7.2 --- Merits and Demerit of the Object-Oriented UI Model --- p.96Chapter 7.3 --- Cost of the Object-Oriented UI Model --- p.96Chapter 7.4 --- Future work --- p.97AppendixChapter A1 --- An Alogrithm for Converting Transition Network Diagram to Event Response Language --- p.A1Chapter A2 --- An Object-Oriented Software Development --- p.A4Chapter A2.1 --- Traditional Non Object-Oriented Software Development --- p.A4Chapter A2.2 --- An Object-Oriented Software Development --- p.A6Chapter A3 --- Vienna Development Method (VDM) --- p.A8Chapter A3.1 --- An Overview of VDM --- p.A8Chapter A3.2 --- Apply VDM to Object-Oriented UI model --- p.A10Chapter A4 --- Glossaries and Terms --- p.A12Referenc

Surface interaction : separating direct manipulation interfaces from their applications.

To promote both quality and economy in the production of applications and their interactive interfaces, it is desirable to delay their mutual binding. The later the binding, the more separable the interface from its application. An ideally separated interface can factor tasks from a range of applications, can provide a level of independence from hardware I/O devices, and can be responsive to end-user requirements. Current interface systems base their separation on two different abstractions. In linguistic architectures, for example User Interface Management Systems in the Seeheim model, the dialogue or syntax of interaction is abstracted in a separate notation. In agent architectures like Toolkits, interactive devices, at various levels of complexity, are abstracted into a class or call hierarchy. This Thesis identifies an essential feature of the popular notion of direct manipulation: directness requires that the same object be used both for output and input. In practice this compromises the separation of both dialogue and devices. In addition, dialogue cannot usefully be abstracted from its application functionality, while device abstraction reduces the designer's expressive control by binding presentation style to application semantics. This Thesis proposes an alternative separation, based on the abstraction of the medium of interaction, together with a dedicated user agent which allows direct manipulation of the medium. This interactive medium is called the surface. The Thesis proposes two new models for the surface, the first of which has been implemented as Presenter, the second of which is an ideal design permitting document quality interfaces. The major contribution of the Thesis is a precise specification of an architecture (UMA), whereby a separated surface can preserve directness without binding in application semantics, and at the same time an application can express its semantics on the surface without needing to manage all the details of interaction. Thus UMA partitions interaction into Surface Interaction, and deep interaction. Surface Interaction factors a large portion of the task of maintaining a highly manipulable interface, and brings the roles of user and application designer closer

Incremental Attribute Evaluation for Multi-User Semantics-Based Editors

This thesis addresses two fundamental problems associated with performing incremental attribute evaluation in multi-user editors based on the attribute grammar formalism: (1) multiple asynchronous modifications of the attributed derivation tree, and (2) segmentation of the tree into separate modular units. Solutions to these problems make it possible to construct semantics-based editors for use by teams of programmers developing or maintaining large software systems. Multi-user semantics based editors improve software productivity by reducing communication costs and snafus. The objectives of an incremental attribute evaluation algorithm for multiple asynchronous changes are that (a) all attributes of the derivation tree have correct values when evaluation terminates, and (b) the cost of evaluating attributes necessary to reestablish a correctly attributed derivation tree is minimized. We present a family of algorithms that differ in how they balance the tradeoff between algorithm efficiency and expressiveness of the attribute grammar. This is important because multi-user editors seem a practical basis for many areas of computer-supported cooperative work, not just programming. Different application areas may have distinct definitions of efficiency, and may impose different requirements on the expressiveness of the attribute grammar. The characteristics of the application domain can then be used to select the most efficient strategy for each particular editor. To address the second problem, we define an extension of classical attribute grammars that allows the specification of interface consistency checking for programs composed of many modules. Classical attribute grammars can specify the static semantics of monolithic programs or modules, but not inter-module semantics; the latter was done in the past using ad hoc techniques. Extended attribute grammars support programming-in-the-large constructs found in real programming languages, including textual inclusion, multiple kinds of modular units and nested modular units. We discuss attribute evaluation in the context of programming-in-the-large, particularly the separation of concerns between the local evaluator for each modular unit and the global evaluator that propagates attribute flows across module boundaries. The result is a uniform approach to formal specification of both intra-module and inter-module static semantic properties, with the ability to use attribute evaluation algorithms to carry out a complete static semantic analysis of a multi-module program