User Interface Declarative Models and Development Environments: A Survey
---
paper_title: ITS: a tool for rapidly developing interactive applications

paper_content:

The ITS architecture separates applications into four layers. The action layer implements back-end application functions. The dialog layer defines the content of the user interface, independent of its style. Content specifies the objects included in each frame of the interface, the flow of control among frames, and what actions are associated with each object. The style rule layer defines the presentation and behavior of a family of interaction techniques. Finally, the style program layer implements primitive toolkit objects that are composed by the rule layer into complete interaction techniques. This paper describes the architecture in detail, compares it with previous User Interface Management systems and toolkits, and describes how ITS is being used to implement the visitor information system for EXPO '92.
---
paper_title: User interface software tools

paper_content:

Almost as long as there have been user interfaces, there have been special software systems and tools to help design and implement the user interface software. Many of these tools have demonstrated significant productivity gains for programmers, and have become important commercial products. Others have proven less successful at supporting the kinds of user interfaces people want to build. This article discusses the different kinds of user interface software tools, and investigates why some approaches have worked and others have not. Many examples of commercial and research systems are included. Finally, current research directions and open issues in the field are discussed.
---
paper_title: Declarative interface models for user interface construction tools: the MASTERMIND approach

paper_content:

Currently, building a user interface involves creating a large procedural program. Model-based programming provides an alternative new paradigm. In the model-based paradigm, developers create a declarative model that describes the tasks that users are expected to accomplish with a system, the functional capabilities of a system, the style and requirements of the interface, the characteristics and preferences of the users, and the I/O techniques supported by the delivery platform. Based on the model, a much smaller procedural program then determines the behavior of the system.
---
paper_title: From OOA to GUI — The Janus System

paper_content:

The demand of usable, ergonomic, Graphic User Interfaces (GUI) from end users is growing rapidly today. On one hand, User Interface Management Systems (UIMS) are used to construct the user interface components. On the other hand, there is a need for representing the problem domain for the future user interface leading to a gap between user interface design and problem domain. The JANUS system addresses this problem by introducing a model using Object Oriented Analysis (ODA) from which a GUI can be almost automatically generated.
---
paper_title: Adept - A task based design environment

paper_content:

Modern user interface development environments are based on fast prototyping which as a methodology does not incorporate any theory or design principles. Adept (Advanced design environment for prototyping with tasks) incorporates a theory of modelling users and user task knowledge known as Task Knowledge Structures 1111, and extends it to a theoretical framework for modelling user, task and interface characteristics. This paper introduces the underlying framework, and discusses how this can be used to support task based user interface design.
---
paper_title: Template-based mapping of application data interactive displays

paper_content:

Abstract This paper describes a template-based method for construct-ing interactive displays with the building-blocks (widgets) provided in a user interface toolkit. Templates specify how to break down complex application objects into smaller pieces, specify the graphical components (widgets) to be used for displaying each piece, and specify their layout. Complex interfaces are constructed by recursively applying templates, thus constructing a tree of widgets to display a complex application object. The template-based method is more general than the interactive, WYSIWYG interface builders in that it can specify dynamic displays for applica-tion data that changes at run time. The template-based method also leads to more consistent, extendable and modi-ﬁable interfaces. 1.0 Introduction User interface toolkits such as the X Toolkit [10] and the Macintosh Tool-Box [5] provide abstractions that make the construction of user interfaces signiﬁcantly easier than pro-gramming using graphics primitives. Unfortunately the toolkits do not make the construction of user interfaces easy enough. The tasks of assembling the widgets to construct complex displays, and of tying the widgets to application data structures remains difﬁcult and time consuming.Interactive user interface builder systems such as Prototyper [14] provide interactive what-you-see-is-what-you-get in-terfaces to assemble tool-box widgets into more complex interfaces. These tools are excellent for a restricted class of interfaces, which typically includes only menus and dia-logue boxes. However, these tools do not help with the con-struction of the “main windows” of an application, which display application objects that typically change at run time.This paper describes a template-based method for assem-bling widgets into complex interfaces and tying them to ap-plication objects. Templates specify how to break down complex application objects into smaller pieces, specify the widgets to be used for displaying each piece, and specify their layout. Complex interfaces are constructed by recur-sively applying templates, thus constructing a tree of wid-gets to display a composite application object. The template-based method supports the construction of dynam-ic displays, and also encourages the design of consistent, extendable and modiﬁable interfaces.The paper is organized as follows. Section 2.0 presents an overview of a template-based UIMS named Humanoid, the High-level UIMS for Manufacturing Applications Needing Organized Iterative Development. Section 3.0 compares the template-based method with other methods, sections 4.0 and 5.0 describe the template-based method in detail, and ﬁ-nally section 6.0 discusses our experience with Humanoid.
---
paper_title: Bridging the Generation Gap: From Work Tasks to User Interface Designs

paper_content:

Abstract Task and model-based design techniques support the design of interactive systems by focusing on the use of integrated modelling notations to support design at vari-ous levels of abstraction. However, they are less concerned with examining the na-ture of the design activities that progress the design from one level of abstraction to another. This paper examines the distinctions between task and model-based approaches. Further, it discusses the role of design activities in such approaches, based on experience with one task-based technique, and the resulting implications for tool support and design guidelines. The discussion is contextualised by exam-ples drawn from a number of case studies where designers applied a task-based approach to solve one particular design problem: that of developing an airline flight query and booking system. Keywords Automatic generation, design guidelines, model-based design, task-based design, task models, Introduction Current interest in task and model-based approaches to design signifies a trend to-wards placing greater emphasis on what an interactive system should do and how people might use it rather than how the system itself works. Designers are encour-aged to conceptualise designs at a higher level of abstraction than is the case when working with standard prototyping tools; in particular, they are encouraged to fo-cus on the behaviour and structure of the user interface rather than on specific de-tails of low-level interaction objects. This interest is reflected in papers presented at the DSV-IS workshops [DSV-IS94, DSV-IS95]. Task and model-based approaches to design have many features in common. Most notably, they both focus on the use of models to represent the various sorts of in-
---
paper_title: Management of interface design in humanoid

paper_content:

Today's interface design tools either force designers to handle a tremendous number of design details, or limit their control over design decisions. Neither of these approaches taps the true strengths of either human designers or computers in the design process. This paper presents a human-computer collaborative system that uses a model-based approach for interface design to help designers on decision making, and utilizes the bookkeeping capabilities of computers for regular and tedious tasks. We describe (a) the underlying modeling technique and an execution environment that allows even incompletely-specified designs to be executed for evaluation and testing purposes, and (b) a tool that decomposes high-level design goals into the necessary implementation steps, and helps designers manage the myriad of details that arise during design.
---
paper_title: Generating user interfaces from data models and dialogue net specifications

paper_content:

A method and a set of supporting tools have been developed for an improved integration of user interface design with software engineering methods and tools. Animated user interfaces for database-oriented applications are generated from an extended data model and a new graphical technique for specifying dialogues. Based on views defined for the data model, an expert system uses explicit design rules derived from existing guidelines for producing the static layout of the user interface. A petri net based technique called dialogue nets is used for specifying the dynamic behaviour. Output is generated for an existing user interface management system. The approach supports rapid prototyping while using the advantages of standard software engineering methods.
---
paper_title: Software Life Cycle Automation for Interactive Applications: The AME Design Environment

paper_content:

The model-based design environment AME offers CASE-tool support for all life cycle activities in the development process for interactive applications. The system allows the rapid automatic construction of interactive software from objectoriented analysis models (OOA) and/or OO-modelling information specified at later design stages. AME provides functionality for UI-structure generation, interaction object selection, layout prototype generation, dynamic behaviour generation, adaptation to user-specific requirements, integration of domain-methods and target code generation. Object-oriented and knowledge-based components provide automatic transition from one refinement stage to the next. System decisions can be visualised before code generation and may be revised by the designer.
---
paper_title: The BOSS System: Coupling Visual Programming with Model Based Interface Design

paper_content:

Due to the limitations of WYSIWYG User Interface Builders and User Interface Management Systems model based user interface construction tools gain rising research interest. The paper describes the BOSS system, a model based tool which employs an encompassing specification model (HIT, Hierarchic Interaction graph Templates) for setting up all parts of the model of an interactive application (application interface, user interaction task space, presentation design rules) in a declarative, designer oriented manner. BOSS offers an integrated development environment in which specifications are elaborated in a graphical, visual-programming-like fashion. Through a refinement component a specification can be transformed according to high-level design goals. From a refined specification BOSS generates automatically user interfaces using modified techniques from compiler construction.
---
paper_title: Facilitating the exploration of interface design alternatives: the HUMANOID model of interface design

paper_content:

HUMANOID is a user interface design tool that lets designers express abstract conceptualizations of an interface in an executable form, allowing designers to experiment with scenarios and dialogues even before the application model is completely worked out. Three properties of the HUMANOID approach allow it to do so: a modularization of design issues into independent dimensions, support for multiple levels of specificity in mapping application models to user interface constructs, and mechanisms for constructing executable default user interface implementations from whatever level of specificity has been provided by the designer.
---
paper_title: Adept - A task based design environment

paper_content:

Modern user interface development environments are based on fast prototyping which as a methodology does not incorporate any theory or design principles. Adept (Advanced design environment for prototyping with tasks) incorporates a theory of modelling users and user task knowledge known as Task Knowledge Structures 1111, and extends it to a theoretical framework for modelling user, task and interface characteristics. This paper introduces the underlying framework, and discusses how this can be used to support task based user interface design.
---
paper_title: The DIANE+ Method.

paper_content:

The DIANE method has been created to solve malfunctions in the use of interactive software, leading to trouble in the information systems and difficulties in the user learning and memorisation. The DIANE method aims to integrate the user and his interaction capability into the current process of designing an interactive software. DIANE+ extends the DIANE method to make possible the automatic generation of user interface. This extension concerns the model of dialogue control, and the integration of an OPAC object data model extending the PAC model. This work is based upon a key concept: the control sharing between man and machine. Our approach complements the object methods by integrating aspects relating to tasks and work stations, and concepts such as the user's level and activity.
---
paper_title: Template-based mapping of application data interactive displays

paper_content:

Abstract This paper describes a template-based method for construct-ing interactive displays with the building-blocks (widgets) provided in a user interface toolkit. Templates specify how to break down complex application objects into smaller pieces, specify the graphical components (widgets) to be used for displaying each piece, and specify their layout. Complex interfaces are constructed by recursively applying templates, thus constructing a tree of widgets to display a complex application object. The template-based method is more general than the interactive, WYSIWYG interface builders in that it can specify dynamic displays for applica-tion data that changes at run time. The template-based method also leads to more consistent, extendable and modi-ﬁable interfaces. 1.0 Introduction User interface toolkits such as the X Toolkit [10] and the Macintosh Tool-Box [5] provide abstractions that make the construction of user interfaces signiﬁcantly easier than pro-gramming using graphics primitives. Unfortunately the toolkits do not make the construction of user interfaces easy enough. The tasks of assembling the widgets to construct complex displays, and of tying the widgets to application data structures remains difﬁcult and time consuming.Interactive user interface builder systems such as Prototyper [14] provide interactive what-you-see-is-what-you-get in-terfaces to assemble tool-box widgets into more complex interfaces. These tools are excellent for a restricted class of interfaces, which typically includes only menus and dia-logue boxes. However, these tools do not help with the con-struction of the “main windows” of an application, which display application objects that typically change at run time.This paper describes a template-based method for assem-bling widgets into complex interfaces and tying them to ap-plication objects. Templates specify how to break down complex application objects into smaller pieces, specify the widgets to be used for displaying each piece, and specify their layout. Complex interfaces are constructed by recur-sively applying templates, thus constructing a tree of wid-gets to display a composite application object. The template-based method supports the construction of dynam-ic displays, and also encourages the design of consistent, extendable and modiﬁable interfaces.The paper is organized as follows. Section 2.0 presents an overview of a template-based UIMS named Humanoid, the High-level UIMS for Manufacturing Applications Needing Organized Iterative Development. Section 3.0 compares the template-based method with other methods, sections 4.0 and 5.0 describe the template-based method in detail, and ﬁ-nally section 6.0 discusses our experience with Humanoid.
---
paper_title: Bridging the Generation Gap: From Work Tasks to User Interface Designs

paper_content:

Abstract Task and model-based design techniques support the design of interactive systems by focusing on the use of integrated modelling notations to support design at vari-ous levels of abstraction. However, they are less concerned with examining the na-ture of the design activities that progress the design from one level of abstraction to another. This paper examines the distinctions between task and model-based approaches. Further, it discusses the role of design activities in such approaches, based on experience with one task-based technique, and the resulting implications for tool support and design guidelines. The discussion is contextualised by exam-ples drawn from a number of case studies where designers applied a task-based approach to solve one particular design problem: that of developing an airline flight query and booking system. Keywords Automatic generation, design guidelines, model-based design, task-based design, task models, Introduction Current interest in task and model-based approaches to design signifies a trend to-wards placing greater emphasis on what an interactive system should do and how people might use it rather than how the system itself works. Designers are encour-aged to conceptualise designs at a higher level of abstraction than is the case when working with standard prototyping tools; in particular, they are encouraged to fo-cus on the behaviour and structure of the user interface rather than on specific de-tails of low-level interaction objects. This interest is reflected in papers presented at the DSV-IS workshops [DSV-IS94, DSV-IS95]. Task and model-based approaches to design have many features in common. Most notably, they both focus on the use of models to represent the various sorts of in-
---
paper_title: Declarative interface models for user interface construction tools: the MASTERMIND approach

paper_content:

Currently, building a user interface involves creating a large procedural program. Model-based programming provides an alternative new paradigm. In the model-based paradigm, developers create a declarative model that describes the tasks that users are expected to accomplish with a system, the functional capabilities of a system, the style and requirements of the interface, the characteristics and preferences of the users, and the I/O techniques supported by the delivery platform. Based on the model, a much smaller procedural program then determines the behavior of the system.
---
paper_title: Model-based User Interface Software Tools Current state of declarative models

paper_content:

The Interface Model is central to all model-based user interface software tools. This report investigates the different use of declarative models as a part of the Interface Model in modelbased interface development environments. Furthermore, we introduce definitions for the different declarative models. The report concludes with a description of an ontology of declarative models for future model-based interface development environments.
---
paper_title: A Programming Language Basis for User Interface Management

paper_content:

The Mickey UIMS maps the user interface style and techniques of the Apple Macintosh onto the declarative constructs of Pascal. The relationships between user interfaces and the programming language control the interface generation. This imposes some restrictions on the possible styles of user interfaces but greatly enhances the usability of the UIMS.
---
paper_title: Software Life Cycle Automation for Interactive Applications: The AME Design Environment

paper_content:

The model-based design environment AME offers CASE-tool support for all life cycle activities in the development process for interactive applications. The system allows the rapid automatic construction of interactive software from objectoriented analysis models (OOA) and/or OO-modelling information specified at later design stages. AME provides functionality for UI-structure generation, interaction object selection, layout prototype generation, dynamic behaviour generation, adaptation to user-specific requirements, integration of domain-methods and target code generation. Object-oriented and knowledge-based components provide automatic transition from one refinement stage to the next. System decisions can be visualised before code generation and may be revised by the designer.
---
paper_title: Exploiting Model-Based Techniques for User Interfaces to Databases

paper_content:

Model-based systems provide methods for supporting the systematic and efficient development of application interfaces. This paper examines how model-based technologies can be exploited to develop user interfaces to databases. To this end five model-based systems, namely Adept, HUMANOID, Mastermind, TADEUS and DRIVE are discussed through the use of a unifying case study which allows the examination of the approaches followed by the different systems.
---
paper_title: Teallach: a model-based user interface development environment for object databases

paper_content:

Abstract Model-based user interface development environments show promise for improving the productivity of user interface developers, and possibly for improving the quality of developed interfaces. While model-based techniques have previously been applied to the area of database interfaces, they have not been specifically targeted at the important area of object database applications. Such applications make use of models that are semantically richer than their relational counterparts in terms of both data structures and application functionality. In general, model-based techniques have not addressed how the information referenced in such applications is manifested within the described models, and is utilised within the generated interface itself. This lack of experience with such systems has led to many model-based projects providing minimal support for certain features that are essential to such data intensive applications, and has prevented object database interface developers in particular from benefiting from model-based techniques. This paper presents the Teallach model-based user interface development environment for object databases, describing the models it supports, the relationships between these models, the tool used to construct interfaces using the models and the generation of Java programs from the declarative models. Distinctive features of Teallach include comprehensive facilities for linking models, a flexible development method, an open architecture, and the generation of running applications based on the models constructed by designers.
---
paper_title: Design alternatives for user interface management sytems based on experience with COUSIN

paper_content:

User interface management systems (UIMSs) provide user interfaces to application systems based on an abstract definition of the interface required. This approach can provide higher-quality interfaces at a lower construction cost. In this paper we consider three design choices for UIMSs which critically affect the quality of the user interfaces built with a UIMS, and the cost of constructing the interfaces. The choices are examined in terms of a general model of a UIMS. They concern the sharing of control between the UIMS and the applications it provides interfaces to, the level of abstraction in the definition of the information exchanged between user and application, and the level of abstraction in the definition of the sequencing of the dialogue. For each choice, we argue for a specific alternative. We go on to present COUSIN, a UIMS that provides graphical interfaces for a variety of applications based on highly abstracted interface definitions. COUSIN'S design corresponds to the alternatives we argued for in two out of three cases, and partially satisfies the third. An interface developed through, and run by COUSIN is described in some detail.
---
paper_title: A high-level user interface management system

paper_content:

A high-level UIMS which automatically generates the lexical and syntactic design of graphical user interfaces is presented. The interfaces generated by the UIMS can easily and rapidly be refined by the designer by using highly interactive and graphical facilities. The UIMS accepts a high-level description of the semantic commands supported by the application, a description of the implementation device, and optionally, the end user's preferences. Based on these inputs the UIMS generates graphical user interfaces in which the commands are selected from menus and command arguments are provided through interaction with graphical interaction techniques.
---
paper_title: Modelling and Generation of Graphical User Interfaces in the TADEUS Approach

paper_content:

The goal of the TADEUS-approach (TAsk-based DEvelopment of USer interface software) is the task-oriented and user-centred development of graphical user interfaces (GUI). For this reason TADEUS is a methodology as well as a supporting environment for GUI development. An overview about the TADEUS approach is given in this paper. The TADEUS Dialogue graph, a new specification technique for GUI, and the generation of GUI based on Dialogue graphs are described.
---
paper_title: Human computer interaction: Psychology, task analysis, and software engineering

paper_content:

Introducing Human Computer Interaction. An introduction to Human Memory. Memory Structures. Knowledge and Representation. Expertise. Skill and Skill Acquisition. Organisation and early Attempts at Modelling Human-Computer Interaction. Interaction and User Modelling in HCI. Task Analysis and Task Modelling. Developing Interface Designs. Evaluations of Interactive systems. User Interface Design. Environments. Management System and Toolkits. Task Analysis. Knowledge Analysis of Tasks. Design. Applied to Interactive Informal and Formal Specifications of User Interaction Task Scenarios. Appendix.
---
paper_title: Bridging the Generation Gap: From Work Tasks to User Interface Designs

paper_content:

Abstract Task and model-based design techniques support the design of interactive systems by focusing on the use of integrated modelling notations to support design at vari-ous levels of abstraction. However, they are less concerned with examining the na-ture of the design activities that progress the design from one level of abstraction to another. This paper examines the distinctions between task and model-based approaches. Further, it discusses the role of design activities in such approaches, based on experience with one task-based technique, and the resulting implications for tool support and design guidelines. The discussion is contextualised by exam-ples drawn from a number of case studies where designers applied a task-based approach to solve one particular design problem: that of developing an airline flight query and booking system. Keywords Automatic generation, design guidelines, model-based design, task-based design, task models, Introduction Current interest in task and model-based approaches to design signifies a trend to-wards placing greater emphasis on what an interactive system should do and how people might use it rather than how the system itself works. Designers are encour-aged to conceptualise designs at a higher level of abstraction than is the case when working with standard prototyping tools; in particular, they are encouraged to fo-cus on the behaviour and structure of the user interface rather than on specific de-tails of low-level interaction objects. This interest is reflected in papers presented at the DSV-IS workshops [DSV-IS94, DSV-IS95]. Task and model-based approaches to design have many features in common. Most notably, they both focus on the use of models to represent the various sorts of in-
---
paper_title: Declarative interface models for user interface construction tools: the MASTERMIND approach

paper_content:

Currently, building a user interface involves creating a large procedural program. Model-based programming provides an alternative new paradigm. In the model-based paradigm, developers create a declarative model that describes the tasks that users are expected to accomplish with a system, the functional capabilities of a system, the style and requirements of the interface, the characteristics and preferences of the users, and the I/O techniques supported by the delivery platform. Based on the model, a much smaller procedural program then determines the behavior of the system.
---
paper_title: The Amulet Environment: New Models for Effective User Interface Software Development

paper_content:

The Amulet user interface development environment makes it easier for programmers to create highly interactive, graphical user interface software for Unix, Windows and the Macintosh. Amulet uses new models for objects, constraints, animation, input, output, commands, and undo. The object system is a prototype instance model in which there is no distinction between classes and instances or between methods and data. The constraint system allows any value of any object to be computed by arbitrary code and supports multiple constraint solvers. Animations can be attached to existing objects with a single line of code. Input from the user is handled by "interactor" objects which support reuse of behavior objects. The output model provides a declarative definition of the graphics and supports automatic refresh. Command objects encapsulate all of the information needed about operations, including support for various ways to undo them. A key feature of the Amulet design is that all graphical objects and behaviors of those objects are explicitly represented at run time, so the system can provide a number of high level built-in functions, including automatic display and editing of objects, and external analysis and control of interfaces. Amulet integrates these capabilities in a flexible and effective manner.
---
paper_title: ITS: a tool for rapidly developing interactive applications

paper_content:

The ITS architecture separates applications into four layers. The action layer implements back-end application functions. The dialog layer defines the content of the user interface, independent of its style. Content specifies the objects included in each frame of the interface, the flow of control among frames, and what actions are associated with each object. The style rule layer defines the presentation and behavior of a family of interaction techniques. Finally, the style program layer implements primitive toolkit objects that are composed by the rule layer into complete interaction techniques. This paper describes the architecture in detail, compares it with previous User Interface Management systems and toolkits, and describes how ITS is being used to implement the visitor information system for EXPO '92.
---
paper_title: CORBA fundamentals and programming

paper_content:

Introducing CORBA and the OMA. Technical Overview. Introducing OMG IDL. Understanding the ORB, Part 1: Client Side. Understanding the ORB, Part 2: Object Implementation (Server) Side, Including the CORBA Component Model. Architecting and Programming for CORBA Interoperability. Language Mappings, Part 1: C++. Language Mappings, Part 2: Java. Language Mappings, Part 3: COBOL Designing with CORBAservices and CORBAfacilities. CORBAservices, Part 1: Naming and Trader Services. CORBAservices, Part 2: Event and Notification Services. CORBAservices, Part 3: Transaction and Concurrency Services. CORBRservices, Part 4: Security and Licensing Services. CORBAservices, Part 5: Introduction to the Other CORBAservices and the COBRAfacilities. CORBAservices, Part 6: LifeCycle and Relationship Services. CORBAservices, Part 7: Persistent State and Externalization Services. CORBAservices, Part 8: Property and Query Services. Introducing the CORBA Domains. Some CORBAdomain Specifications. Modeling CORBA Applications with UML. Implementing Metamodels and Repositories Using the MOF. The Tutorial Example: Overview and Scenario. The Tutorial Example: Analysis and Design. ORB Product Descriptions. Coding and Compiling the IDL. The Depot. Depot Implementation in Java. Depot: Overview and COBOL Language Coding. The Store. Coding the Store in Java. Store: COBOL Coding. Programming the POSTerminal in C++. Coding the POS in Java. POS: COBOL Coding. Running the Example. Appendices. About the Web Site. What's on the CD-ROM? Index.
---
paper_title: Communicating sequential processes

paper_content:

This paper suggests that input and output are basic primitives of programming and that parallel composition of communicating sequential processes is a fundamental program structuring method. When combined with a development of Dijkstra's guarded command, these concepts are surprisingly versatile. Their use is illustrated by sample solutions of a variety of familiar programming exercises.
---
paper_title: A Specification Language for Direct-Manipulation User Interfaces

paper_content:

A direct-manipulation user interface presents a set of visual representations on a display and a repertoire of manipulations that can be performed on any of them. Such representations might include screen buttons, scroll bars, spreadsheet cells, or flowchart boxes. Interaction techniques of this kind were first seen in interactive graphics systems; they are now proving effective in user interfaces for applications that are not inherently graphical. Although they are often easy to learn and use, these interfaces are also typically difficult to specify and program clearly. Examination of direct-manipulation interfaces reveals that they have a coroutine-like structure and, despite their surface appearance, a peculiar, highly moded dialogue. This paper introduces a specification technique for direct-manipulation interfaces based on these observations. In it, each locus of dialogue is described as a separate object with a single-thread state diagram, which can be suspended and resumed, but retains state. The objects are then combined to define the overall user interface as a set of coroutines, rather than inappropriately as a single highly regular state transition diagram. An inheritance mechanism for the interaction objects is provided to avoid repetitiveness in the specifications. A prototype implementation of a user-interface management system based on this approach is described, and example specifications are given.
---
paper_title: Towards a general computational framework for model-based interface development systems

paper_content:

Model-based interface development systems have not been able to progress beyond producing narrowly focused interface designs of restricted applicability. We identify a level-of-abstraction mismatch in interface models, which we call the mapping problem, as the cause of the limitations in the usefulness of model-based systems. We propose a general computational framework for solving the mapping problem in model-based systems. We show an implementation of the framework within the MOBI-D (Model-Based Interface Designer) interface development environment. The MOBI-D approach to solving the mapping problem enables for the first time with modelbased technology the design of a wide variety of types of user interfaces.
---
paper_title: ITS: a tool for rapidly developing interactive applications

paper_content:

The ITS architecture separates applications into four layers. The action layer implements back-end application functions. The dialog layer defines the content of the user interface, independent of its style. Content specifies the objects included in each frame of the interface, the flow of control among frames, and what actions are associated with each object. The style rule layer defines the presentation and behavior of a family of interaction techniques. Finally, the style program layer implements primitive toolkit objects that are composed by the rule layer into complete interaction techniques. This paper describes the architecture in detail, compares it with previous User Interface Management systems and toolkits, and describes how ITS is being used to implement the visitor information system for EXPO '92.
---
paper_title: User interface software tools

paper_content:

Almost as long as there have been user interfaces, there have been special software systems and tools to help design and implement the user interface software. Many of these tools have demonstrated significant productivity gains for programmers, and have become important commercial products. Others have proven less successful at supporting the kinds of user interfaces people want to build. This article discusses the different kinds of user interface software tools, and investigates why some approaches have worked and others have not. Many examples of commercial and research systems are included. Finally, current research directions and open issues in the field are discussed.
---

Title: User Interface Declarative Models and Development Environments: A Survey

Section 1: Introduction
Description 1: Introduce the motivations, goals, and advantages of model-based user interface development technology using declarative models, and outline the challenges faced by MB-UIDEs.

Section 2: MB-UIDE
Description 2: Introduce the various MB-UIDEs referenced in the paper, their origins, and their unique contributions.

Section 3: Background
Description 3: Provide an overview of the evolution of MB-UIDEs, from first-generation systems to more modern iterations, and highlight key papers and contributions in the field.

Section 4: User Interface Model Framework
Description 4: Describe the framework used for comparing and analyzing the architectural components of user interface models (UIMs).

Section 5: User Interface Development in a MB-UIDE
Description 5: Explain the UI development process in a MB-UIDE, including design and implementation steps.

Section 6: User Interface Design Process
Description 6: Detail the processes involved in UI design within a MB-UIDE, including tools for editing models and design assistants.

Section 7: Automated Tasks in User Interface Design Process
Description 7: Discuss how automated tasks support the UI design process and present different approaches to generating and executing user interfaces.

Section 8: User Interface Implementation Process
Description 8: Describe the various tools and methods used for implementing UIs within a MB-UIDE framework.

Section 9: Declarative Models
Description 9: Detail the composition and notation of declarative models, identifying the key models and constructors used in MB-UIDEs.

Section 10: Model Integration
Description 10: Analyze how different user interface models are integrated within MB-UIDEs and discuss the relationships between model components.

Section 11: Environments
Description 11: Compare the design and implementation environments provided by different MB-UIDEs and their respective tools.

Section 12: Design Environment
Description 12: Provide a classification of tools used in the design environment of MB-UIDEs and their functionalities.

Section 13: Implementation Environment
Description 13: Summarize the tools and methods used in the implementation environment of MB-UIDEs, including code generation and runtime systems.

Section 14: Conclusions
Description 14: Summarize the key findings of the survey, highlight current challenges, and suggest future directions for MB-UIDE technology.