User interface specification and modeling in an ... - Semantic Scholar

User Interface Specification and Modeling in an Object Oriented Environment for Automatic Software Development*

Computer Science Department University of Castilla-La Manchu Albacete (Spain )

Isidro Ramos Department of Inforniation Systems and Computation Polytechnic University Valencia (Spain)

lmlozano. [email protected]

[email protected]

Maria D. Lozano, Pascual Gonzalez

Abstract Nowadays, most of the research developed by industry and academy has led to several object-oriented methods highly adequate for the development of systems. But most of these methods do not include mechanisms (models)f o r identifying and specifying user needs and requirements us well us testing and vuliduting requirements with end-users before, during and after development. These considerations are specially important in interactive systems, where the user interaction is very high and the user interface is a significant part of the system. As a result of this weakness, interactive systems developed using such methods can meet all technical requirements, be very robust, and yet be unusable by the end-user. This problem explain a large purt of the frequently-observed phenomenon whereby large numbers of change requests to modify the services of an application are made afier its deployment. As a solution to this problem we propose a method for integrating a user interface model, taking into account user needs and requirements, into the software life cycle. Besides, this approach to the development process ensures the quality of the delivered applications from the point of view of the end user.

1. Introduction. Different studies have proved that the 48% of an application code is devoted to the user interface and that near 50% of the implementation time is devoted to implement the user interface []].The more easy to use is the interface, the more difficult is its development. The user interface is that part of a computer program that manages the data flow produced during the interaction process between the user and the computer. The rest of the computer program is called the application. Due to the fact that the application should bring to the users different ways of conceiving, visualizing and manipulating the complex data structures, it is very important to establish a framework that allows to face and manage such complexity in a coherent way.

* This work is partly supported by the MENHIR project from the Spanish government commission of

Science and Technology with reference TIC97-0593-C05-01

0-7695-0774-3/00 $10.000 2000 IEEE

373

374

There exists several reasons that justify the complexity of user interface design and implementation [2], but perhaps the main reason is the difficulty of understanding the tasks the user must perform with the system and the characteristics of the different kind of users managing it [3]. In this sense, it seems necessary to define new models that permit to collect user requirements and specify the different characteristics of the interface associated to a concrete application. This models should allow to define the specification of the interface independently [4], that is, the models used to specify the user interface should be different from those used to specify the application. In this paper we present IDEAS (Interface Development Environment within oASis), an object oriented and model-based approach for developing user interfaces within an automatic software production environment. This environment is supported by an object oriented model called OASIS (Open and Active Specification of Information Systems) [ 5 ] , [6] and a methodology associated to the model, called 00-Method [7], [8], which covers the software life-cycle of analysis, design and implementation within the principles of the object oriented paradigm. So, for better understand our proposal, we present first the state-of-the-art of modelbased interface development environments, and then, the ontology associated to the user interface model. After that we finally present IDEAS with an example of use.

2. Model-Based User Interface Development Environments. State of the Art In this section we briefly describe the most important features of current model-based user interface development environments. In a state of the art report, B. Myers presents a classification of user interface software tools [9]. This classification is based on the way the user interfaces developers can specify the form and dynamic behavior of a user interface. This classification is the following: Language-based Tools: These tools require the developer to program in a special purpose language. Interactive Graphical Specification Tools: These tools allow an interactive design of the user interface. Model-based Generation Tools: These tools use a high-level specification or model to generate the user interface automatically. The last classification seems to be the most adequate to tackle the user interface development. The first two support the specification of either the dynamic behavior or the layout of the user interface in an easy way, but not both parts at the same time. And the same as most current tools, they only support the last phase of the user interface life-cycle development, and the abstractions they provide do not have a direct connection with the task analysis results. On the other hand, model-based user interface development approach and its corresponding tools is an emerging technology that remedies these shortcomings. The most representative feature of the model-based approach is that all aspects of the user interface design are represented using declarative models. This paradigm offers several benefits: User-centered development life-cycle. Centralized user interface specification.

375

Design tools for an automated and interactive development. Reuse of the user interface designs. So, for a user interface tool to be considered as a Model-based user interface development environment, it must accomplish the following criteria: 1) It must include a high-level, abstract and explicitly represented (declarative) model about the system under development.

2) It must clearly establish a technologically well supported relation between 1) and the final running user interface. Currently there exist several model-based user interface software tools, as for instance, UIDE [IO], HUMANOID [ I l l , MOBI-D [12], MASTERMIND [13], [14], TRIDENT [15], FUSE [ 161, JANUS [17] and IDEAS our proposed model explained in following sections. In the next figure we show the typical components and the development process of this model-based approach to better understand it.

Figure 1: Generic architecture of a model-based user interface development environment. The core of this architecture is the User Interface Model which includes different declarative models as for instance, the task model, domain model, presentation model, etc. This environment includes also tools for an interactive development (Modeling tools, design critics) and for an automated development. The tools for automated development are in charge of the transformation between the declarative models and the final executable user interface. The information needed by the design tools and automatic generation tools is represented in the knowledge bases. Finally, the executable user interface code generated by the automatic generation tools is linked with the application code, obtaining so the final application.

376

3. IDEAS: User Interfaces Development within an Object Oriented Software Production Environment. The aim of this research is the integration of a user interface model within an automatic and object oriented software production environment. The user interface specification process is tackled in parallel to the application development. and according to the common principles of Model-based User Interface Development Environments. as exposed in the previous section. This development proccss is depicted i n the following figure:

Figure 2: IDEAS: Interface development environment within OASIS. So, IDEAS (Interface Development Environment within OASIS) aims to be an automatic user interface development system integrated within the framework of OASlS and 00-Method, to support the automatic production of high-quality user interfaces. This is possible due to the fact that this environment is based on declarative models, with the advantages of this approach as stated in the previous section. As depicted in figure 2, the user interface model is obtained from the task analysis, which is obtained from the use cases as starting point, not only to tackle the interface development but also the whole system. The declarative models used in IDEAS are the following three: The task model, the dialog model and the presentation model. The Task Model defines the ordered set of activities and actions the user has to perform to achieve a concrete purpose or goal. The Dialog Model [ 181 ix used to describe the "conversation" user-computer. It describes when the user can invoke commands, select or specify the input data and when the computer can require data from the user or display the output data. This model includes the generation of three different kinds of diagrams representing these matters, the Diulog Srructure Diagrrtrn, the Component Specification Diagram and the Component Behavior Definitiori Tuhle [ 191. In order to illustrate this model, next we apply i t to the very simple case of a Libruq~.

377

* The Dialog Structure Diagram represents the windows and dialogs that the user needs to complete all the tasks he requires from the system, and the user selections to pass from one window to another. In the library case this diagram would be the following:

Notation:

1-1

Loan Books

:Main Window

I

Library

I-

H

[-]

:Dialog :Event

Return Books

Figure 3: Dialog structure diagram.

* The Component Specification Diagram, which models the contents of every one of the windows and dialogs represented in the previous diagram. Every window is composed of components and tools. For instance, the component specification diagram for the dialog Loan-Book would be the following: Didoafor lommaabook

-.I

/-

Dialog Contrd 7

Laan Book

S how-bmrower Show-book

Q Close

M0Ul

Borrower Selecticm

BookSelecticm

Wmdow

Figure 4: Component specification diagram

* Component Behavior Definition Table in which every one of the components and tools represented in the previous diagram is accurately described so that the user can understand the meaning of the components and tools through which he interacts and retrieves information from the system. In the following table we show the Component Behavior Definition Table for the dialog class LoanBook.

378 ~~

Control Tool

Component

Loan

Dialog Control

Select-Borrower: Allows the selection of a borrower from the library database. Select-Book: Allows the selection of a book from the library database.

Visualisation ~ool

ShowBorrower: Shows the borrower selected through the control tool. ShowBook: Shows the book selected through the control tool. Show-date: Shows the system date corresponding to the loan date.

Ok: Allows the user to introduce a new loan in the library system. Close: Close the dialog and returns the user to the main window.

Figure 5 : Component behavior definition table for the dialog class Loan-book. The Presentation Model describes the final components that can appear in the end-user screen, its design characteristics and visual dependencies between them [20]. This model is closely related to the analysis model of the system as the information to be shown in this model is the same that is described and modeled in the analysis model, i.e., the class attributes identified in the system will be accessible by the end-user by means of the presentation model. Starting form these declarative models it is possible to automatically generate the user interface code, that together with the application code generated by the parallel development process of the system will constitute the final resulting application. As an intermediate step to this, in the design phase, the user interface specification is tackled with the specification language OASIS enriched to specify the user interface aspects in the same way that is currently used for the system specification. Model-based code generation [21] produces application source code automatically from graphical models of system behavior and architecture. A formal system with precise syntax and semantics is needed for such an automation. OASIS is used as the target design language of the visual models. A translator generates OASIS code (extended with Graphical User Interface features) from the visual models. OASIS uses as formal model Dynamic Logic [22]. The operational semantics of such language is implemented as an Execution Model defining in a precise way [23] the mapping between problem domain concepts and solution domain ones. Pattern technology is used for establishing such mapping.

4. Ontological Model of IDEAS. The Interface Model ontology of Interface Development Environments is based on two ideas: the programming language design, which provides foundations for any modeling process, and the object oriented user interface toolkit technology, which provides abstractions and control mechanisms. It can be said that user interface design is a process analogous to the design of a programming language [24]. So, the interface could be seen as composed of two languages: one by means of which the end-user communicates with the computer, and the

379 other by which the computer communicates with the end-user. This way, when developing the user interface of a system, it can be seen as a simultaneous design process of these two languages. In this process we can distinguish three phases:

1 ) Semantic Design: The term "semantic" refers to the intentions of the end-user. To codify a system at this level we apply Task Analysis [25].This is the knowledge the end-user has in mind when using the system. This conceptual model is refined into a more detailed semantic model of the system by incorporating the functional requirements of the application, i.e., the interface specification will be completed by refining these models into more concrete models, which can be classified into syntactical and lexical. From them, the code generators transform the concrete models into the running application. 2) Syntactic Design: The syntactic model is defined to denote the detailed semantic model. It represents procedures that, when executed, cause the occurrence of some semantically prescribed effect. The main difference between the semantic and syntactic models is that syntactic models are specified in a procedural way, as a set of ordered steps, whereas semantic models are non-procedural, i.e., declaratives. Dialog techniques are syntactic whereas the user tasks that these dialog techniques are employed to accomplish are semantic. 3 ) Lexical Design: A lexical model, which describes low-level tokens, is defined together

with the syntactic model. For the output language, these tokens includes keystrokes, mouse motion or mouse clicks, etc. Whereas for the output language these tokens includes output characters, sounds or graphical widgets. Taking into account all this matters, the tasks organization and the functionality of the application are semantic concepts. Dialog i s a syntactic concept and Presentation and interaction are lexical concepts. These models must define accurately the input and output languages and express their interrelation. This ontology is depicted in the following figure:

Semantic Level

Task Model

Syntactic Level

Lexical Level

Domain Model

Dialog Model

v Presentation Model I

I

Figure 6: Ontology of the user interface model of IDEAS.

380

5. Conclusions. The user interface development is quite a more complex task than the mere inclusion of different widgets in a series of windows. The complexity of designing and implementing a high-quality user interface provokes the need to include new models that collect the specification of such interface. With the aim to achieve an object oriented environment for automatic software production, that not only can be used with the efficiency and simplicity that the end-user requires through a friendly but at the same time robust interface, we have presented IDEAS, a user interface development environment with the philosophy of OASIS and integrated into the development process of 00-Method. IDEAS, as is based on declarative models, provides a descriptive information of the future components of the interface at a high level of abstraction. In the early development phases It also allows the study of how the interaction between the user and the system is performed. And in the last phases it allows the automatic code generation starting from the models. To better understand the approach followed for the development of this environment, we have presented, in a state-of-the-art section, different model-based interface development environments, and the ontology associated to the interface model. And finally, remark the more and more importance that the user interface is getting, above all regarding interactive systems, as a means of interacting with a system and taking the most profit of it. This is the main motivation of this research.

6. Bibliografy. [ I ] B . A. Myers, M. B . Rosson: Survey on User Interface Programming. In Striking a Balance. Proceedings CH1’92. Monterey, May 1992, New York: ACM Press, 1992, 195.202 [21 B.A. Myers: Why are Human-Computer Interfaces Dijjicult to Design and Implenient. Tech. Report CMU-CS93.183, CMU, Jul 1993. [3] J. Gould, C. Lewis: Designing for Usability - Key Principles and What Designers Think. Commun. ACM, Vol 28, 1985, pp.300-31 I . [41 W. Swartout, R. Blamer: The Inevitable Intertwining of Specification and Implementation. Commun ACM, Vol 25, No. 7, Jul 1982, pp.438-440. [ 5 ] 0. Pastor, 1. Ramos. OASIS 2.1.1.: A Class-Definition Language to Model Information Systems Using an Object-Oriented Approach. Octubre 95 (3 ed.) [6] P. Letelier, I. Ramos, P. Sanchez, 0. Pastor. OASIS versidn 3.0: A Formal Approach f o r Object Oriented Conceptual Modelling. SPUPV-98.4011, Edited by the Technical University of Valencia, Spain, 1998. 171 0. Pastor, E. Insfran, V. Pelechano, J. Romero, J. Meseguer. 00-Method: An 00 Sofrware Producrion Environment Combining Conventional and Formal Methods. Procs. of 9Ih. International Conference, CAiSE’97. Barcelona, Catalonia, Spain, June 16-20, 1997. [SI M.D. Lozano, 1. Ramos, P. Cuenca. “Application of an Object-Oriented Methodology for Automatic Software Production: 00-Method”. Proceedings of IEEE Pacific Rim Conference on Communications, Computers and Signal Processing (PACRIM’97). Pags. 985 - 989. Victoria, CanadB. 20-22 de Agosto, 1997. [91 B. A. Myers: User Interface Software Tools. ACM Transactions on Computer-Human Interaction 2 (1995), 1, 64-103

381 [IO] 1. Foley, P. Sukaviriya: History, Results and Bibliography of the User Interface Design Environment (UIDE), an Early Model-based System for User Interface Design and Implementation. In F. Paterna (ed.): Interactive Systems: Design, Specification and Verification. Berlin: Springer, 1995, 3- 14. [l 11 P. Szekely et al: Beyond Interface Builders: Model-Based Interface Tools. In: Bridges between Worlds Proceedings InterCH1’93 ( Amsterdam, April 1993). New York: ACM Press, 1993, 383-390. [ 121 A. Puerta: The Mecano Project: Comprehensive and Integrated Support for Model-Based Interface

Development. In: Computer-Aided Design of User Interfaces. Namur: Namur University Press, 1996, 19-36.

[I31 R. Neches et al.: Knowledgeable Development Environments Using Shared Design Models. In: Proceedings of the 1993 International Workshop on Intelligent User Interfaces (Orlando, Enero 1993). New York: ACM Press, 1993, 63-70. [I41 P. Szekely, et al.: Declarative Interface Models for User Interface Construction Tools: The MASTERMIND Approach. In: Engineering for Human-Computer Interaction. Proceedings of the IFlP Conference on Engineering for Human-Computer Interaction (Yellowstone Park, Agosto 1995). London: Chapman &Hall, 1996, 120-IS0

[IS] F. Bodart et al.: Towards a Systematic Building of Software Architectures: teh TRIDENT Methodological Guide. In: Design, Specification and Verification of Interactive Systems. Wien: Springer, 1995, 262-278. [ 161 F. Lonczewski: The FUSE System: An Integrated User Interface Design Environment. In: Computer-Aided Design of User Interfaces. Namur: Namur University Press, 1996, 37-56,

[I71 H. Balzert et al.: The JANUS application Development Environment Generating More than the User Interface In: Computer-Aided Design of User Interfaces. Namur: Namur University Press, 1996, 183-205.

[I81 M. Lozano, 1. Ramos: An Object Oriented Approach for the Specification of User Interfaces. PACRIM’99, Victoria -Canad& Agosto, 1999. 1191 M. Lozano, 1. Ramos: Integration of the User Model and Human Factors in an Object Oriented Software Production Environment, ECOOP’99, Lisboa -Portugal-, Junio, 1999. [20] P.J. Molina: EspecificaciCln de Interfaz de Usuario en 00-Method. Proyecto Final de Camera, Valencia, 1998. [21 ]Pastor,O.;Can6s,J.H.; RamosJ. From CASE to CARE (Computer-Aided Requirements Engineering) Conceptual Modeling - ER’99. Lecture Notes in Computer Science ( I 728), pigs: 278-293, Springer-Verlag, 1999, ISBN: 3-540-66686.9 ; ISSN : 0302-9743, Paris.

[22] P. Sinchez, P. Letelier, I. Ramos. Animating formal specifications with Inheritance in a DL-based framework. Requirements Engineering Journal, Springer-Verlag, vo1.4 num.4, March, 2000. [23] P. Letelier, P. Sinchez, 1. Ramos. “Prototyping a requirements specification through an automatically generated concurrent logic program”. Proceedings of First International Workshop on Practical Aspects of Declarative Languages (PADL99), Gopal Gupta (Ed.), LCNS 1551, pp.31-45, ISSN 0302-9743, ISBN 3-54065527-1, Springer-Verlag, Texas, USA, Enero 1999. [24] J. Foley, A. Van Dam, S. Feiner, A. Hughes: Computer Graphics: Principles and Practice. (2ndEd. ) Reading: Addison Wesley, 1990.

[25]D. Diaper: Task Analysis for Human-Computer Interaction. Chichester: Ellis Horwood, 1989