An Approach to Develop User Interfaces with Plasticity1

An Approach to Develop User Interfaces with Plasticity1 Francisco Montero, Víctor López-Jaquero, José P. Molina, Pascual González Grupo de Investigación LoUISE Escuela Politécnica Superior. Universidad de Castilla-La Mancha Avda. de España s/n. 02071 – Albacete, Spain {fmontero, victor, jpmolina, pgonzalez}@info-ab.uclm.es

Abstract. This paper provides an approach to develop user interfaces where plasticity is considered by using several concepts, concretely our proposal is a pattern-based, component-oriented and model-based meta-level environment for developing user interfaces. Each one of these concepts will be used in order to develop user interfaces generated at runtime and them can be generated dynamically.

1

Intent and Motivation

We want to provide an architecture to achieve user interfaces with plasticity. Plasticity is the capacity of an user interface to withstand variations of both the system physical characteristics and the environment while preserving usability [22]. Nowadays, an important industrial challenge is developing interactive systems for a broader diversity of computing devices, involving different interaction styles and techniques, distinct input and output devices, and diverse operating.

2

Context

In this section we want to gather opinions on why is difficult to design user interfaces, and what has been used to develop these user interfaces. At this moment, user interface designers want to provide [22] adaptability, adaptivity and plasticity. Fundamentally, model-based approaches [15][25][20] and object-oriented programming [3] are used to achieve these objectives. • •

1

Universal design of user interfaces attempts to cover design issues in multiple contexts of use where multiple types of users may carry out multiple tasks, possibly on multiple domains of interests [6] There is an increasing diversity of user interfaces on an increasing diversity of computerized devices. These devices include hand-held personal digital This work is supported by two grants CICYT TIC 2000-1673-C06-06 and CICYT TIC 20001106-C02-02.

• • •

• •

assistants, cell phones, pagers, computerized pens, computerized notepads, and various kinds of desk and wall-size computers [14] There are no languages that are completely device independent and integrates all the aspects of content adaptability [11] Interfaces on these very large and very small displays cannot typically use the standard desktop model, and people will not necessarily expect these devices to act like regular computers [14] User interface produced by a model-based approach is entirely based on the predefined set of IOs supported by the model-based interface development environment (MB-IDE). This dependence induces some lack of flexibility and expendability of the produced UI [25] Most existing tools do not assists developing widget-based implementations from an abstract user interface specification [8] The problem of content adaptation flexibility and coherence remains unsolved in heterogeneous environments [11]

The main limitation, that user interface designers and developers find, is the lack of support (languages and tools) to develop user interfaces with high abstraction level in the design process. Several languages and techniques have been developed to ease the creation of user interfaces for different operating systems and devices: UIA [9], XUL [28], Java [10], VoiceXML [26], AUI [19] or UIML [24] are examples of it.

3

Structure and Solution Proposed

When we have different target platforms, the traditional approach to solve this problem consists of writing different versions for each possible type of interaction modality. This requires as many versions as modalities there are. This approach produces great problems for maintenance and coherence as the number of target devices grows. These considerations motivate the development of a more generic methodology that allows for the generation of user interfaces regardless of the available interaction modality [17]. Our solution is based on an idea similar to JavaBeans [20]. A JavaBean is a portable, platform-independent, reusable component model that conforms to specification defining how Java objects interact. JavaBeans are a reusable software component that can be manipulated visually in a builder tool too. Then, could we build a user interface at runtime by using a similar idea? In our proposal there are more elements involved, JavaBeans are only the idea, and they are our concrete interaction objects, called basewidgets. Other components, abstract interaction objects, called metawidgets provide a high abstraction level at which design decisions are made. This meta-level is formed by objects that carry out computation about a system materialized by objects at the base level. The computational domain, or system internal domain, deals with the information relative to structures and mechanisms that fit into the program execution. The base level contains interaction objects that solve a problem in a concrete platform and interaction objects that manage information about the application domain. Computational reflection, or just reflection, has been proposed as a solution to the

problem of creating applications able to maintain, use and change the representations of their own designs, and this is our purpose. This characteristic allows designers to isolate the base object behavior from the orthogonal properties such as validation, adaptability, adaptivity or auditory facilities.

4

Implementation

This section deals with implementation details of the proposed approach. These details are provided by using design patterns [7] and suggesting using guidelines or interaction [13] [23] [27] patterns in order to achieve usability improvements. Design patterns are the mechanism of construction and reusability of components that we have selected to design the reflexive architecture and to implement the concrete interface components, as well as the relationship between them (mapping). Table 1 summarizes some of the design patterns used, and the pursued functionality. In a meta-level architecture there are two typical activities: reflection and reification. We think that many of the portability problems in user interface development are caused by the low abstraction level at which design decisions are made, resulting in a lack of overview in the design process. The abstraction level is the key. Pattern

Abstract Factory (+Factory Method) Composite State Mediator Memento Observer (+Command) Visitor

Functionality

Creation of abstract and concrete components Composes components into tree structures to represent partwhole hierarchies Allows a interface to alter its behavior when its internal state changes Promotes loose coupling between base and meta-level components Implementation of the undo/redo mechanism in the main dialog and in the validation of actions on the meta-level Implementation of the mechanism of notification from the concrete components to the meta-level Represents operations to be performed on the widgets of an object structure (dialog)

Table 1. Design patterns to implement the proposed architecture

5

Conclusions and Future Works

This paper has treated the implementation of a methodology to develop multiplatform user interfaces. This methodology consists of two levels: meta and base level. User interface ele ments of an application are located at meta-level. In base level

these meta objects are mapped into concrete or base interaction objects by considering the final platform and using basewidgets of this platform (e.g. J2SE, J2ME). Our proposal is a JavaBeans-based one.

References 1. 2.

3. 4. 5. 6. 7. 8.

9. 10. 11.

12. 13. 14.

15. 16. 17. 18. 19. 20.

Booch, G. Object-Oriented Analysis and Design with Applications (2nd edition). AddisonWesley. 1994. Furtado E., Vasco J. J., Bezerra W., William D., da Silva L., Limbourg Q. and Vanderdonckt J. An Ontology-Based Method for Universal Design of User Interfaces. Workshop on Multiple User Interfaces over the Internet. 2001. Gamma E., Helm R., Johnson R., Vlissides J. Design Patterns. Elements of Reusable Object-Oriented Software. Addison-Wesley Professional Computing Series. 1995. Hussey A., Carrington D. Using Patterns in Model-based design. Technical Report No. 99-15. University of Queensland. March, 1999. IBM Corporation. User Interface Arquitecture. http://www3.ibm.com/ibm/easy/eou_ext.nsf/Publish/1392/$File/ibm_uia.pdf. 2001. Java. The source for Java Technology. http://java.sun.com Lemlouma T., Layaïda N. Device Independent Principles for Adapted Content Delivery. INRIA Rhone Alpes. 2002. Montero, F., Lozano, M., Gonzalez, P., Ramos, I. Design Web Sites by Using Patterns. Second Latin American Conference on Pattern Languages of Programming. SugarLoafPLoP2002. Itaipava. Brasil. 2002. Myers B., Hudson S. E., Paush, R. Past, Present, and Future of User Interface Software Tools. ACM Transactions on Computer-Human Interaction. Vol. 7, No. 1. 2000. Paternò, F. Model-Based Design and Evaluation of Interactive Applications. SpringerVerland London. 2000. Plomp C. J., Mayora-Ibarra O. A Generic Widget Vocabulary for the Generation of Graphical and Speech-Driven User Interfaces. International Journal of Speech Technology Vol. 5 2002. pages 39-47. Schneider K., Cordy J. Abstract User Interfaces: A Model and Notation to Support Plasticity in Interactive Systems. The Eight Workshop on the DSV-IS. 2001. Sun Microsystems, Inc. The Choice is Clear: Write to the JavaBeans TM Component Architecture. http://java.sun.com/products/javabeans. 2002 Thévenin D., Coutz J. Adaptation and Plasticity of User Interfaces. Presented to IEEE Workshop on Adaptive Design of Interactive Multimedia Presentations for Mobile Users. 1999. Tidwell, J. UI Patterns and Techniques. http://time-tripper.com/uipatterns/ 2002. UIML. User Interface Markup Language. http://www.uiml.org Vanderdonckt J., Berquin P. Towards a Very Large Model-based Approach for User Interface Development. 1999. VoiceXML. Voice eXtensible Markup Language. http://www.voicexml.org Welie, M. Interaction Design Patterns. http://www.welie.com/patterns. 2001. XUL. XML-based User Interface Language. http://www.mozilla.org