Government & Politics

A Lightweight Presentation Model for Database User Interfaces

Description
Abstract. The Teallach project is building a system which eases the design and implementation of user interfaces (web-based or otherwise) to object-oriented database applications. Teallach takes a model based approach and is constructing its system
Published
of 14
All materials on our website are shared by users. If you have any questions about copyright issues, please report us to resolve them. We are always happy to assist you.
Related Documents
Share
Transcript
  1Lightweight Presentation Model15 September 1998 A Lightweight Presentation Model for Database User Interfaces  Phil Gray •  , Richard Cooper •  , Jessie Kennedy •  , Peter Barclay •  and Tony Griffiths • • Department of Computing Science, University of Glasgow, 17 Lilybank Gardens,Glasgow G12 8QQ, Scotland. http://www.dcs.gla.ac.uk/ {~pdg || ~rich } • Department of Computer Studies, Napier University, Canal Court, 42 Craiglockhart Ave,Edinburgh, EH14 1LT, Scotland. http://www.dcs.napier.ac.uk/osg/  • Department of Computer Science, University of Manchester, Oxford Road,Manchester, M13 9PL, England. http://img.cs.man.ac.uk  Abstract.  The Teallach project is building a system which eases the design and implementation of user interfaces (web-based or otherwise) to object-oriented database applications. Teallach takes a modelbased approach and is constructing its system around three main models – a domain model whichdescribes the database structures with which Teallach can cope; a task model, in which the user-involvedaspects of the application can be described; and a presentation model. The presentation model isintended to support the storage of user interaction objects, so that these objects can be found, customisedand composed into user interfaces suitable for the tasks. In seeking an appropriate presentation model,we have found that previous models are either those underlying toolkits, which are overly concrete anddetailed, or are abstract models based entirely around the look of the interaction objects, but not theirintended role. We are implementing a model which describes each interaction object in terms of itspurpose, the kinds of data with which the user is allowed to interact, constraints on its use, and adescription of configurable aspects of the interface in terms of the ways in which they supportinteraction. This paper describes this model and gives examples of its use. 1Introduction 1.1 A Design Space for User Interaction Components  The user interfaces commonly found when accessing the world wide web are simple andprovide limited functionality. Built using HTML together with modest amounts of programming inscripting languages or Java, they are appropriate for the majority of the tasks for which the web hasbeen found useful. However, the web is increasingly used as an interface to massively distributeddata to which increasingly complex access is required.In particular, many of the more complex web sites exist principally to give access to a database,frequently managed using an Object-Oriented Database System [Cooper, 97]. Quite often thedatabase will need to be accessed by non-web interfaces as well, and so there needs to be coherentsupport for the development and maintenance of a mixture of interfaces. Furthermore, thedevelopment of the web interfaces might usefully re-use elements of already existing non-webinterfaces. A common observation is that the construction of all kinds of user interfaces is complexand typically poorly achieved in the database context. Hence, even if a more complex techniquefor interaction with web data were to be envisaged, it is unlikely that it would be implemented sincethe implementation process is so much more complex than most web programming.The Teallach project is building a system which offers assistance with this problem, since it willprovide support for the process of constructing user interfaces to object-oriented databases. Suchuser-interfaces will include those which are deployed over local area networks, using standard userinterface tools such as an SQL command interface, Visual Basic or other GUI toolkit, and oneswhich use the world wide web for distributed data access. The Teallach system is built in Java and  2Lightweight Presentation Model15 September 1998 produces Java applications or applets. Therefore, the examples given throughout this paper areones which use Java, but the principles discussed should not be thought of as Java specific.Construction of a user interface is taken here to include design as well as implementation.Whether construction is performed by humans, machines or some combination of the two, amongthe tasks that have to be performed are:  inventing  or  finding  techniques for representing information and for communicatinginformation across the user interface  where more than one technique is available for a given job, selecting  from thosetechniques  configuring  the technique so that it fits its context.All of these tasks require some descriptive framework (a model and/or a language) in terms of which the tasks can be formulated, communicated and reasoned about. Such a model could be saidto characterise a "design space" for these tasks, in the sense that it fixes what can be said aboutinteraction techniques. Ahlberg and Truve [Ahlberg and Truve, 1995] say of such a design spacethat it removes "irrelevant details while isolating and emphasising those properties or artifacts andsituations that are most significant to design." We designate such a design space, a presentationmodel.Teallach aims to create a system which supports these tasks, by providing declarative models of the context and the user interaction. In this case, context is taken to mean the database structure(i.e. the schema) and the application structure. The interaction aspects (i.e., the means by whichinformation is communicated to and from a user) are described using the presentation modeldescribed in this paper. 1.2The Teallach Context for the Presentation Model  The Teallach System is built around three models:The domain model  describes the structure of the database so that the data, meta-data andmeta-meta-data are available to the user interface builder – in ways which are notspecific to the database or the database system. Since Teallach is concerned exclusivelywith object-oriented databases, we take the ODMG data model [Catell,1997] as thebasis for our domain model – this being an emerging industry standard.The task model  describes the organisation of the activities which the user interface isintended to support. The task model permits a hierarchical description of tasks, inwhich compound tasks can be described as collections of sub-tasks. The temporalordering of the tasks in the collection can be indicated to be sequential, order-independent, repeatable, parallel, interleaved, user selected, optional or conditional[Griffiths et al. , 1998b].The presentation model  describes the interaction objects which may be used to permit datause and task execution.The system allows the designer to make use of as much as he or she knows about theapplication to help build the interface. It is therefore vital that the three models co-operate tosupport the design and implementation process. At one level this means that any support tools builtby Teallach will look and feel the same whichever model is being used. However, moreimportantly, the tools must reflect appropriate aspects of each other in the way in which they arepresented. As far as the presentation model is concerned, this means that the design space must beorganised to bring out the appropriateness of fit of each interaction component to the task intendedand to the data type in use. We therefore seek a model which includes this organisation.The purpose of the presentation model is to support three principal design tasks and (at astretch) some aspects of a fourth:  3Lightweight Presentation Model15 September 1998 Task 1 The interface designer 1  selects between interaction objects which are available inthe system;Task 2 The interface designer customises the interaction objects and organises them intolarger units - windows, dialogues, etc.;Task 3 New interaction objects (constructed outside of the Teallach system) are registeredfor use with the system.Task 4 New interaction objects are constructed inside the Teallach system by configuringother interaction objects, in as much as this process involves no more than activities weneed to provide to support Task 2.Thus we will support the process of putting together the user interface from pre-existingcomponents, but we will not provide a full visual programming language for the construction of those components. Section 2 will discuss possibilities for supporting the tasks, but first we willlook at the kinds of presentation model which are either in use or have been proposed. 1.3Kinds of Presentation Model  There are two principal kinds of presentation model, which are used (either explicitly orimplicitly):User Interface Toolkits – These are the kinds of tool which are commonly used in buildinguser interfaces. The “presentation model” is usually provided as a customisable andcombinable set of widgets and is usually supported by some kind of design tool.UIDEs- User Interface Development Environments provide an abstraction of an entireinteractive system, including application functionality, task or dialogue structure andpresentation components, plus tools for generating and configuring a user interface fromthis information. Model-based UIDEs represent this abstraction in the form of declarative models. Teallach's presentation model is an instance of this latter class.We find two main problems with toolkit models, both of which are concerned with the level of abstraction at which they are presented. Firstly, they inevitably discuss user interaction at tooconcrete a level. Secondly, they are either extremely complex and hard to understand or they canonly provide quite restricted interfaces. As a consequence, they do not adequately support theinterface design tasks.The principal function of a toolkit is to provide a  programmer   with the facilities to present theuser interface, and sufficient information to build programs using those facilities. A toolkit willusually be provided as a class or function library together with an application programmer’sinterface and documentation. The documentation will describe the ways in which the classes are tobe used in terms of the expected arguments and results of the methods provided.Furthermore, to use the toolkit, the programmer must understand not just the purpose andfeatures of the interaction objects, but also the ways in which they work. Thus, in a graphical userinterface, the programmer needs to understand the event model and the ways in which the eventsare handled in the program. We consequently find that the programmer either opts for a simple andrestricted set of facilities or has to invest considerable effort into mastering the complexities of theimplementation. For instance, in building a user interface in Java, the options are to use theAbstract Windowing Toolkit [Java1.1, 1997], which is moderately difficult to understand and onlyprovides the most basic kind of graphical interface object, or to use the emerging Swing toolkit[Java1.2, 1998]. The latter is a collection of around 400 classes, which provide a superior set of    1  The “interface designer” might be human, machine or some combination of the two. The use of the term heredoes not imply any particular version of designer.  4Lightweight Presentation Model15 September 1998 interaction objects, but whose use involves mastering a more complex and extensive interactionmodel.Of course, a toolkit typically comes with some kind of software development tool – for instanceVisual Basic. Such tools allow the user a graphical means to choose and place the interactionobjects and are very effective, as long as the application and its intended interface are reasonablysimple. Even in this case, though, the selection and construction process will usually be guided bythe look of the interaction rather than its role and so it is easy for a designer to make errors due tothe distance between the intended result and the interaction actually provided.In summary, the toolkit approach fails to supply the designer with the level of abstractionappropriate to the principal tasks listed above. Instead of being able to find a facility by itsintended use and appropriateness of fit, the designer is offered pictures of particular examples,component names (often obscure – e.g. the “combo box”) and the API.Abstract descriptions of the representational components of a user interface have been presentin UIDEs for over ten years. In fact, one can identify some of the core ideas in the notions of logical input device and abstract interaction technique developed in the late 70s and early 80s. Forexample, the basic interaction techniques of Foley, Wallace & Chan [1984], including position,pick, point, choice, text and valuator, are organised around the application data types on which thetechniques can operate. Olsen's MIKE and Mickey [Olsen 1986] systems capture the notion of anabstract representation of interaction elements independent of their appearance and concretebehaviour. This abstraction is built on the concepts of application data types to be represented andthe application operation to be supported. Information about the actual appearance and behaviour isheld separately and can be generated by default and subsequently modified without affecting thebasic semantics of the interaction technique. Jade [Vander Zanden & Myers, 1989] is a systemwhich automatically generates dialog boxes and menus based on an abstract description of theinteraction plus additional information in the form of generation rules and parameterised interactionobjects. Dialogue items are specified by value sets and abstract interaction techniques, includingsingle choice, multiple choice, text, single choice with text, multiple choice with text, commandand number in a range.The form of the abstraction underlying Mike and Jade is based on a differentiation of:     what the application designer needs to know about the presentational components inorder to give meaning and semantic structure to interface components; and     what the user interface designer needs to know in order to craft usable and effectiveconcrete presentations.However, these early UIDEs suffered from a concentration on specifying input-orientedinteraction techniques and did not handle the representation of application data. Furthermore, theirpresentation frameworks tended to be ad hoc and to capture only the information needed for initialuser interface generation. Other characteristics which form part of the semantics of the abstractinteraction objects are only included implicitly or left for the designer to configure by editing theparameter values of the generated interaction object. Model based systems UIDEs [Foley et al,1989; Elwert, and Schlungbaum, 1995; Luo et al. , 1993; Mitchell et al ., 1996; Szekely et al .,1996] offer a richer and more expressive description of an interactive system. They support thedesign activity much more closely, by providing declarative models from which the interface canbe generated. They typically provide a variety of models to tackle different aspects of theapplication building process. Here we concentrate on the presentation model, which [Griffiths etal., 1998b]: “allows the designer to specify the characteristics of the interface components. Thiscan apply to both the static (widgets, etc.) and dynamic (typically involving run-timeapplication-dependent data) facets of the interface.”  5Lightweight Presentation Model15 September 1998 In spite of greater expressiveness and more powerful generation and configuratrion tools, themodels found in the literature are still a long way from offering to the user interface designer thesame powerful abstractions which have been developed for some data visualisation systems[Derthick, 1997]. The presentation models surveyed in [Griffiths et al. , 1998a] suffer from anumber of problems includinglack of abstraction - features of the model include elements which reflect the actualstructure of a (family of) concrete interaction object libraries,lack of extensibility - the model is ad hoc  in the sense that it is difficult or impossible togeneralise, specialise or extend, andlack of relevant structure - features which are important for design are left out of the modeland features which have different representational potential cannot be distinguished.In particular, in many existing MB-IDEs we find no place for describing what role theinteraction object is expected to play in user interaction. Furthermore, even though theconfigurable features of the object are describable, there is no attempt to indicate the impact of configuring each feature. In particular, it is clear that some features are central to the functioningof the object – the text string in a text field, for instance. Others are less vital, being configurableonly to improve the look of the overall interface – background colour, for instance. In fact,distinguishing between the two is difficult, since, for instance, we might configure an alert box sothat error messages are coloured red, while progression messages are coloured green – in this casebackground colour has become information bearing.A further problem that we find with thedeclarative models that we have examined, is that they only allow for rather simple mappingsbetween the structure of application data and the interaction objects which represent that data.While this simplicity is acceptable for a system which generates new composite interaction objectsfrom basic primitives for each user interface instantiated, the ability to desacribe more complexrelationships is necessary if complex composite interaction objects are to be stored and retrieved bymeans of high-level descriptions. In the Teallach system, it is vital that the designer be able to findthose components which are appropriate to particular kinds of complex data. In addition, we wouldlike to be able to determine any constraints which can hold over the use of the component, both inisolation and in combination.In the Teallach presentation model, we seek to extend the describableaspects of the interaction components to encompass: the role of the component; the data that it canhandle; the temporal nature of the relationship between application data and the presentation,   thelevel of complexity of the component; the configurable features; and the constraints which may beimposed on its use. 2Requirements for the Teallach Model 2.1 The Role of the User Interface in a Database Application  Most of the model-based approaches to user interface description were not conceived in thecontext of a database system. In building an interface using Teallach, the designer can expect tohave access to a meta-model, which describes the structure of all data held by the database systemand a schema which describes the structure of the particular database, as well generically providedtools such as query processors which can retrieve data appropriately specified. Consequently,creating a model for interaction is a somewhat less general problem than that tackled by thedesigners of interfaces to other systems.The meta-model chosen for Teallach is that produced bythe Object Data Management Group consortium, since this promises to be an industry-widestandard [Catell, 1997]. This means that user interfaces designed using Teallach should runsuccessfully on any ODMG-compliant database system. The meta-model is object-oriented and
Search
Related Search
We Need Your Support
Thank you for visiting our website and your interest in our free products and services. We are nonprofit website to share and download documents. To the running of this website, we need your help to support us.

Thanks to everyone for your continued support.

No, Thanks