Incubator Group Report

From Model-based User Interfaces Incubator Group Wiki
Jump to: navigation, search

Section One

Introduction [Dave,Fabio]

Setting out the challenges for developing and maintaining user interfaces for web-based applications. These include the different skills and motivations of team members, the use of distributed teams. The wide range of devices users can be expected to use. The need to adapt to personal preferences and to provide an effective user experience for a range of disabilities. The problems posed by variations in browsers and other delivery platforms as well as incomplete standards and patchy support for standards. The perils of mixing different levels of abstraction.


Model-Based UI [Jean, Fabio]

The purpose of model-based design is to identify high-level models, which allow designers to specify and analyse interactive software applications from a more semanticoriented level rather than starting immediately to address the implementation level. This allows them to concentrate on more important aspects without being immediately confused by many implementation details and then to have tools which update the implementation in order to be consistent with high-level choices. Thus, by using models which capture semantically meaningful aspects, designers can more easily manage the increasing complexity of interactive applications and analyse them both during their development and when they have to be modified [P05].

In recent years model-based approaches have evolved in parallel with the aim of coping with the different challenges raised by the design and development of user interfaces in continuously evolving technological settings. We can identify various generation of works in this area [PSS09]. The first generation of model-based approaches in which the focus was basically on deriving abstractions for graphical user interfaces (see for example UIDE [Foley et al., 1994]). At that time, user interface designers focused mainly on identifying relevant aspects for this kind of interaction modality.

Then, the approaches evolved into a second generation focusing on expressing the high-level semantics of the interaction: this was mainly supported through the use of task models and associated tools, aimed at expressing the activities that the users intend to accomplish while interacting with the application (see for example Adept [Johnson et al., 1993], GTA [van der Veer et al., 1994], ConcurTaskTrees (CTT) [Paternò, 1999]).

Then, thanks to the growing affordability of new interactive platforms, in particular mobile ones, the work of UI designers mainly focused on how to cope with the relentless appearance of new devices on the market and the need to cope with their different characteristics. As previously pointed out by Myers et al. (2000), the increasing availability of new interaction platforms raised a new interest in model-based approaches in order to allow developers to define the input and output needs of their applications, vendors to describe the input and output capabilities of their devices, and users to specify their preferences. However, such approaches should still allow designers to have good control on the final result in order to be effective. A number of approaches have addressed multi-device user interfaces by identifying relevant information to be contained in appropriate models (and languages) for addressing such issues (examples are UIML [Helms and Abrams 2008], TERESA [Mori et al., 2002], USIXML [Limbourg et al., 2004]). In this area one specific issue is how to facilitate the development of multiple versions.


Research Driven Work [Fabio,Jean, Juan, Gerrit]

between 5 and 10 lines apiece

  • ConcurTaskTrees (CTT) [P99] is is a notation for task model specifications which has been developed to overcome limitations of notations previously used to design interactive applications. Its main purpose is to be an easy-to-use notation that can support the design of real industrial applications through hierarchical representation of tasks, their semantic and temporal relations, objects, ...Various tools supporting it have been developed, the most widley used is the ConcurTaskTrees Environment (CTTE) [MPS02].
  • The Useware Markup Language (useML) is a notation for specifying enhanced task models in industrial environments and is part of the user-centered Useware-engineering development process [ZT08]. Originally developed in 2003 [MT08], useML was enhanced in 2009 with several aspects concerning temporal operators, conditions and optionality of tasks. UseML has shown its applicability and usefulness in several other domains e.g. automotive or medicine [MTK07]. UseML is embedded in a model-based architecture for developing multimodal and multiplatform user interfaces. This model-based architecture was developed as an instance of the Cameleon Reference Framework using different abstraction layers and different user interface description languages e.g. DISL and UIML. For editing useML the graphical useML-Editor (Udit) [MSN09] was developed. Furthermore useML was extended to work in ambient intelligence factory environments like e.g. the SmartFactoryKL [BMGMZ09] which enables the run-time generation of graphical user interfaces.
  • MARIA [PSS09] Model-based lAnguage foR Interactive Applications, is a universal, declarative, multiple abstraction level language for service-oriented applications in ubiquitous Environments. It provides a flexible dialogue and navigation model, a flexible data model, which allows the association of various types of data to the various interactors, and support for more recent techniques able to change the content of user interfaces asynchronously respect to the user interaction.
  • RIML [DWGSZ03] Renderer-Independent Markup Language) is a markup language based on W3C standards that allows document authoring in a device independent fashion. RIML is based on standards such as: XHMTL 2.0 and XFORMS. Special row and column structures are used in RIML to specify content adaptation. Their semantics is enhanced to cover pagination and layout directives in case pagination needs to be done. Due to the use of XForms, RIML is device independent and can be mapped into a XHTML specification according to the target device. RIML semantics is enhanced to cover pagination and layout directives in case pagination needs to be done, in this sense it was possible to specify how to display a sequence of elements of the UI.
  • TERESA, is a XML-based language for describing user interfaces, which has an associated authoring environment, Multimodal TERESA. It provides designers with the possibility of designing interfaces for a wide set of platforms, which support various modalities.
  • UIML [APB99] (User Interface Markup Language) was one of the first model-based languages for multi-target UIs. A UI is decomposed into structure, style, contents, and behaviour. It is however only partially compliant with the Cameleon Reference Framework (e.g., it does not have any task or context model) or with MDE-UI (no transformation approach) and it has not been applied to obtain multi-target user interfaces or to context-aware adaptation.
  • XIML [EVP00, EVP01](eXtensible Interface Markup Language) is composed of four types of components: models, elements, attributes, and relations between the elements. The presentation model is composed of several embedded elements, which correspond to the widgets of the UI, and attributes of these elements representing their characteristics (color, size…). The relations at the presentation level are mainly the links between labels and the widgets that these labels describe. XIML supports design, operation, organization, and evaluation functions; it is able to relate the abstract and concrete data elements of an interface; and it enables knowledge-based systems to exploit the captured data.
  • UsiXML [UsiXML] (USer Interface eXtensible Markup Language) is an XML-compliant markup language, which aims to describe the UI for multiple contexts of use. UsiXML adheres to MDE-UI by having a meta-model describing different aspects of the UI. There is also a transformation model that is used to define model-to-model transformations. UsiXML rely on graph transformations to support model transformations, which is rigorous from the scientific viewpoint but raises performance issues. As such, it only covers basic aspects of context-aware adaptation.

A comparative analysis of Model-Based UIDL can be found in [GGVM09].

Industry Driven work [Jose, Jaro]
  • Microsoft's XAML (Extensible Application Markup Language) serves several purposes within the .NET framework: a declarative definiton of visual user interfaces for desktop applications (via Windows Presentation Foundation) and web (RIA via Silverlight) comprising a hierarchical model of 2D, 3D objects and media, flow control, data binding, eventing, transformations and styling through a templating mechanism. It may as well describe long-running processes executed via Windows Workflow Foundation.
  • Open Laszlo is an open source platform for development and delivery of rich internet applications (RIA). These are defined in LZX and JavaScript and deployed either as static, pre-compiled binaries (DHTML, Flash) or rendered dynamically by the OpenLaszlo Server into a device-sensitive OpenLaszlo client application (DHTML, Flash). The XML dialect LZX resembles HTML, while supporting high level UI (sliders, trees, grids) and action elements (animator) an XML-based data model and declarative dependencies at view level (constraints) or data level (data pathes).
  • Adobe's Flex comprises an open source framework for creation and deployment of Flash-based applications. While leveraging ActionScript for implementation Flex offers an higher-level XML-syntax (MXML) for declarative specification of application and user interface components. This covers features like web service requests, data-binding and validation and a rich, extensible library of UI-controls, containers and animation effects. MXML files are compiled into Flash bytecode (SWF) for platform-neutral execution on client side within browsers (via Flash Player) or as standalone desktop applications (via Adobe AIR runtime).
  • XForms is a widely adopted W3C-standard (W3C Recommendation, October 2009) targeting the next generation of (web) form applications. Following the MVC-design pattern these operate on a model comprising data-oriented XML-instances enhanced e.g. by validity restrictions, node computations expressed in XPath 1.0 and a variety of data submission models. The event-based controller layer leverages XML-Events and a rich set of predefined actions eliminating the need for imperative programming (Javascript). The generic, device-independent and extensible set of user controls support advanced interactions like tabs and wizard-like page flow. For rendering purposes XForms markup is embedded into a presentation oriented host language (HTML, SVG) and additionaly formated via CSS. The XForms implementations range from stand-alone clients (XSmiles, Swiftfox), browser plug-ins (XForms for Firefox), to client-side transcoding into DHTML (XSLTForms) and server-based solutions (Chiba, Orbeon). A powerful, thoroughly XML-based architecture arose from the combination of XForms clients and native XML-database servers exposing (stored) XQuery statements through a REST-interface (XRX).
  • Mozilla's XML User Interface Language (XUL) aims at creation of platform-neutral, rich and customizable applications that are equally delivered on desktops and web. Compound documents of XUL and other presentation markup (HTML, SVG) are processed in an unified way utilizing standards like CSS, DOM, ECMAscript, XBL and RDF. Among others XUL supports for data driven UI generation (templates), augmenting and overriding of UI parts (overlays) and integration of application logic written in a variety of languages (XPCOM/XPConnect technologies).
  • IBM's Collage is a declarative programming language and runtime for cumulative building of data-centric, reactive systems out of distributed web components. Nodes of the underlying RDF data model are dynamically typed, interpreted and updated in response to occurrence of external and internal events (user input, service responses, data computations etc.) Collage's recursive MVC-approach allows for arbitrary detail of UI-specification ranging from abstract UI primitives (adopted from XForms) to concrete layout overlays.

Use cases [Sebastian, Dave, Jose, Fabio]

For each use case one page with a diagram, followed by an analysis for all of the use cases for the effectiveness of model-based approaches.

A set of use cases and scenarios that illustrate how model based UI could be applied. These should include use cases focusing on accessibility, mobile and desktop devices, and the means for users to switch devices in the midst of an application.

[Jose] Assessment of implementing use cases and reporting on previous experience in various research projects.

[Dave] Also a brief look at what use cases for which model-based approaches could be applied to in the future.

Use case Migratory User Interfaces

Migratory user interfaces are interactive applications that can transfer among different devices while preserving the state and therefore giving the sense of a non-interrupted activity. The basic idea is that devices that can be involved in the migration process should be able to run a migration client, which is used to allow the migration infrastructure to find such devices and know their features. Such client is also able to send the trigger event to the migration server, when it is activated by the user. At that point the state of the source interface will be transmitted to the server in order to be adapted and associated to the new user interface automatically generated for the target device.


The Figure below shows how the abstraction layers are exploited to support migratory user interfaces, by showing the various activities that are done by the Migration Server. This solution has been developed in the EU OPEN Project. First of all the migration approach supposes that various UI models at different abstraction levels are associated to the various devices involved in a migration: such UI models are stored/manipulated centrally, in the Migration Server. The current architecture assumes that a desktop Web version of the application front-end exists and it is available in the corresponding Application Server: this seems a reasonable assumption given the wide availability of this type of applications. Then, from such final UI version for the desktop platform, the Migration Server automatically generates a logical, concrete UI description for the desktop platform through a reverse-engineering process. After having obtained such a concrete UI description for the desktop platform, the Migration server performs a semantic redesign of such CUI [Paternò et al., 2008] for creating a new, concrete, logical description of the user interface, adapted to the target device. The purpose of the semantic redesign is to preserve the semantics of the user interactions that should be available for the user but to adapt the structure of the user interface to the resources available in the target device. It may happen that some task is not supported by the target device (e.g. a long video cannot be rendered with a limited mobile phone). For all the tasks that can be supported the semantic redesign identifies concrete techniques that preserve the semantics of the interaction but supports it with techniques most suitable for the new device (for example in mobile devices it will replace interactors with others that provide the same type of input but occupying less screen space). In a similar way also page splitting is supported: when there are pages too heavy for the target device they are split taking into account their logical structure so that elements logically connected remain in the same page. Thus, the groupings and relations are identified and some of them are allocated to newly created presentations so that the corresponding page can be sustainable by the target devices.

Migratory-interfaces.jpg
The relationships among abstraction layers supporting migration


The state is extracted through specific JavaScripts, which are automatically included in the Web pages when they are accessed through the intermediate migration server. When the migration is triggered the state is transmitted to the server where there is a module (State Mapper) whose purpose is to associate the state with the concrete description for the target device, which is used for the generation of the final user interface.


Including web 2.0 style mashups involving new kinds of UI components such as Maps

Some use cases covering:

* Mashups e.g. involving maps, weather, census data, ...
* Adaptation to the context (context aware) including
  localization, different devices, different user
  preferences, etc.
* Smart home applications
* Migratory user interfaces
* Distributed authoring for people with different roles
* Maintenance and adaptation to changing requirements

Helpful to structure the groups of use cases, e.g. to explain how model-based approaches impact the intersection of users, developers and service providers.

Dimensions: domain of application, what problem(s) we are identifying, and what benefits do we expect as a result of using model-based approaches, and the contrast with using other approaches. [Jose]

[Jaroslav] which communities would benefit from model-based approaches and how.

[Jean, Juan] a list of criteria for pros/cons of model based approaches for any computer based system.

Usually, we can say that expected benefits of Model-Driven Engineering (MDE) can be subsumed as follows:

  1. Benefits resulting from the existence of a design phase:
    1. Reducing the gap between requirements and implementation: A design phase aims to ensure in advance that the implementation really addresses the customer’s and user’s requirements.
    2. Developer coordination: Previous planning of the developed system enables the developers to coordinate their work e.g. by dividing the system into several parts and defining interfaces between them.
    3. Well-structured systems: A design phase provides explicit planning of the system architecture and the overall code structure. This facilitates implementation itself as well as maintenance.
  2. Benefits resulting from the use of visual abstract models:
    1. Planning on adequate level of abstraction: Modeling languages provide the developer concepts for planning and reasoning about the developed system on an adequate level of abstraction.
    2. Improved communication by visual models: The visual character of modeling languages can lead to increased usability (understanding, perceiving, exploring, etc.,) of design documents for both author and other developers.
    3. Validation: (Semi-)Formal modeling languages enable automatic validation of the design.
    4. Documentation: Models can be used as documentation when maintaining the system.
    5. Platform-independence: Platform-independent models can be reused or at least serve as starting point when implementing the system for a different platform. This includes development platforms like a programming language or component model, as well as deployment platforms like the operating system or target devices.
  3. Benefits resulting from code generation:
    1. Enhanced productivity: Generating code from a given model requires often only a teeny part of time compared to manual mapping into code.
    2. Expert knowledge can be put into the code generator: Expert knowledge – e.g. on code structuring, code optimizations, or platform-specific features – can once be put into the code generator and then be reused by all developers.
    3. Reduction of errors: Automatic mapping prevents from manual errors.
  4. Meta goals: Easier creation and maintenance of development support
    1. Knowledge about creation of modeling languages: MDE concepts and definitions reflect existing knowledge about modeling, modeling languages, and code generation.
    2. Frameworks and tools: Tools like Eclipse Modeling Tools provide sophisticated support for all steps in MDE like creating and processing metamodels, creating modeling editors, and defining and executing transformations.
    3. Maintenance of modeling language and transformations: Systematic and explicit definition of metamodels and transformations facilitates maintenance of modeling languages and code generators.
    4. Reuse of metamodels and transformations: MDE compliant explicit metamodels and transformations can easily be understood and reused by others.

Requirements for Model-Based UI

This will be a short section, and based upon the Cameleon reference framework. The requirements will be fully developed in subsequent work.

Section Two

Cameleon Reference Framework [Jean, Fabio]

The Cameleon Reference Framework (CRF) [CCF02] was developed in the FP5 Cameleon project and was based on the work done in the model-based community. It provides indications for distinguishimg the possible abstraction levels: task and object model, describing the logical activities necessary to achieve users’ goals; abstract interface, UI model independent of any target platform and any interaction modality; concrete interface, UI model which is dependent on the target platform and interaction modality, but independent of any implementation language, final interface, UI running or interpreted. This framework has been extented in the context of the FP6 Similar NoE on multimodal user interfaces, but with limited support for modeling and implementation.

Camelon reference framework

* Task and Domain Models
* Abstract User Interface
* Concrete User Interfaces
* Final UI Layer

Multi-Path Development

Multi-Path UI development [LVMBL04,L04]refers to a UI engineering method and tool that enables a designer to:

  • Start a development activity from any entry point of the Cameleon reference framework (simplified version shown in Figure 1 )
  • Get substantial support in the performance of transformation types and their combinations as found in the Cameleon reference framework (Figure 1).

UsiXML software tools Figure 1. Simplified User Interface Reference Framework

Several interesting development paths can be expressed on this framework since not all steps should be achieved in a sequential ordering dictated by the levels. Instead, locating what steps are performed, when, from which entry point and toward what subsequent step are important.

According to Figure 1:

  • Transcoding tools start with a FUI for a source context of use (4) and transforms it into another FUI for a target context (8).
  • Portability tools start with a CUI for a source context (3) and transforms it into another CUI for another context (7), that in turn leads to a new FUI for that context (8).
  • To overcome shortcomings identified for these tools, there is a need to raise the level of abstraction by working at the AUI level. UI Reverse Engineering abstracts any initial FUI (4) into concepts and relationships denoting a AUI (2), which can then be translated into a new AUI (6) by taking into account constraints and opportunities for the new context.
  • UI Forward Engineering then exploits this AUI (6) to regenerate a new AUI adapted to this platform, by recomposing the CUI (7) which in turn is reified in an executable FUI (8).

In general, UI reverse engineering is any combination of abstraction relationships starting from a FUI (4), a CUI (3) or an AUI (2). UI forward engineering is any combination of reification relationships starting from T&C, AUI or CUI. Similarly, UI Lateral Engineering is responsible for applying any translation at any level of abstraction to transform the artifacts existing at the level where we are for another context of use at the same level. For instance, when a designer has already designed a UI for, let us say a desktop, and wants to design a corresponding UI for a Pocket PC, she may need to apply Graceful Degradation techniques [FV04], which consist of a series of transformations to support the translation from the desktop to the PocketPC, while taking into account the constraints imposed by the new platform.

To provide the core technologies that will support the implementation and execution of Multi-Path UIs of interactive applications based on the UI models. A design/development/runtime environment is needed in order to come up with an open development platform that demonstrates the feasibility of the whole approach. Software tools belonging to this environment would support the services corresponding to UI development activities. As an example, we list UsiXML [UsiXML] tools which are organized as follows (Figure 2): 1. Tools for defining the semantics, the syntax, and the stylistics for UsiXML (upper part of Fig. 2) 2. Tools for managing the various models during the UI development life cycle: model editors, model validators, transformation engine, model manager, UsiXML patterns, etc. 3. UsiXML rendering engines that may take two forms: UsiXML code generators (e.g., in order to automatically generate C, C++, C#, Java UIs at design-time) and UsiXML interpreters (e.g., in order to generate a UI at run-time) 4. Tools for ensuring the quality of UsiXML-compliant UIs: for instance a guideline evaluator should be able to apply model checking techniques on the UsiXML models or guideline evaluation on the code resulting from the model-to-code transformation in order to ensure the quality of resulting UIs.


UsiXML software tools Figure 2. Overview of Software Tools, Source [UsiXML]

The building of software systems can be organized around a set of models by applying a series of transformations between models, organized into an arc-hitectural framework of layers and transformations: model-to-model transformations support any change between models while model-to-code transformation are typically associated with code production, automated or not. Each development path (for instance, forward engineering) is composed of development steps, the latter being decomposed into development sub-steps (for instance, from abstract to concrete models). A development sub-step is realized by one (and only one) transformation system and a transformation system is realized by a set of graph transformation rules. The amount of transformation rules of a rather simple system grows up to two hundred graph transformation rules. Then, usable systems are needed to encode transformations rules. Model transformation is a promising way to save cost development. But it is necessary to verify if models and their specifications are exhaustive, enough to ensure production of smart Operator Machine Interface (OMI), that preserve crew efficiency in term of work load, physical as cognitive, or intuitive OMI, easy to learn, permitting training cost reduction.


Specific Languages and their relationship to Cameleon

With a diagram indicating where each fits onto the four layers. The diagram

Cameleon Ference Framework

Including:

* CTT [Fabio]
* UsiXML [Juan]

UsiXML is more than a XML-compliant markup language that describes the UI for multiple contexts of use such as Character User Interfaces (CUIs), Graphical User Interfaces (GUIs), Auditory User Interfaces, and Multimodal User Interfaces, it also considers models to support model-based User Interface development complaiant with the cameleon reference framework. UsiXML (User Interface eXtensible Markup Language – UsiXML website) is a User Interface Description Language (UIDL), but the observations are independent of this language and could be equally applied to other UIDLs such as UIML, [www.ximl.org XIML]. One single UIDL does not fit all and that it is impossible to find out in one UIDL all the qualities required to successfully run a Model Driven Engineering (MDE) compliant approach. UsiXML is uniformly used throughout the different steps of a MDE-compliant development life cycle to store the models involved in the various processes. The MDE-compliant approach for developing UIs decomposed into four major steps that result from the Cameleon reference framework. The MDE-compliant approach for UI development based on UsiXML.

  Usixml and their relationship with cameleon
* Ideal [Jose]
* ANSI/CEA-2018 [Gottfried? tbc]
* SCXML [Jaroslav]
* XForms [Sebastian]
* XBL [Dave]
* MDML (multiple device markup language) [Juan/UCL]

The Multiple Device Markup Language (MDML) [JP03] is based on XUL. The concepts it specify are: navigation, layout and components for a generic GUI. A rule system is defined as well to map specifications to different devices considering the device: memory, display capabilities and internal representation of the data. Although a general representation can be used for all devices, this is sometimes thought to be too simplistic, thus the direction the User Interface framework produces a different rule set for different devices or perhaps produce different rule sets for the same device. MDML uses Java-based transformation engine. The use of XSLT was found to be too complicated to maintain and even more to reuse as transformation rules where case study dependent. There are four profiles: desktop, web, mobile and voice. For each profile there are different supported languages or constraints to be considered accordingly. Using this framework requires thinking about design first and code later since the code is automatically generated. Mdml and their relationship with cameleon

* OMG MDA [Jean]
* WAI-ARIA [Jaroslav]
* Open Ajax Alliance IDE metadata [Dave]

One or two paragraphs as a minimum for each + the diagram and references to publications, preferably publicly available on the Web!

Date due: end of August

Followed by an overview table that compares the coverage of different languages.

Section Three [Jose]

Challenges for deployment and the need for further work

This should build upon the previous section and identify challenges for widespread adoption of MBUI for web-based applications.

Suggested Standardization Work Items [Jose]

What aspects would benefit from standardization? Is it appropriate to launch a W3C Working Group for that? Which organizations are already interested, and which kinds of organizations should be interested (we could make a list).

Research Agenda [Fabio, Jean]

Where is further research needed? Some possibilities under consideration:

* Model-based UI design for 3D. 

Since 1996, there is an increasing number of online communities in 3D virtual spaces: millions of users are already registered in such communities, more organisations are increasing their presence on the web through these communities in order to sell their products and services [BKLP04], especially by social network applications. Consequently, 3D online contents are no longer the business restricted to videogames: non-gaming 3D applications would be prevalent in the short term. Accordingly to IBM, companies should actively venture into virtual worlds. IBM invested 11 million dollars in Second Life to host virtual meetings, such investment has been rewarded with an increment in collaboration [LL09]. 3DUIs are largely appreciated by specific categories of users and are helpful for specific tasks, but not all [S03]. In some circumstances, no significant difference exists in task performance between 2DUI and 3DUI. There is however a significant subjective preference for 3DUIs [CM01]. 3D mobile maps surpassed 2D in performance and workload measures [ONN09]. Human perceptual mechanisms to analyze the world into structures of 3D primitives are better compared to 2D representations [C03]. Indeed, only a few objects can be held in our mind at the same time, and these are swapped in or out from either long-term memory or the external environment [KM97]. Object complexity is not as important [KTG92] as object’s structure. Object’s shape is a primary element while colour and texture are secondary. A 3DUI of a UML class diagram improves the cognitive representation of the diagram with respect to a 2DUI [Iran00]. Stereo and motions cues are more effectively perceived in 3D than in 2D. Human visual bandwidth is much larger in 3DUIs than in 2DUIs [S02]. Users tend to remember better objects shapes and location in 3DUIs than in 2DUIs.3DUIs will transform customer experiences, improve business processes, drive collaboration, enrich commerce and transactions, and enable 3D modelling and simulations so businesses can better understand their markets [P07]. Thus, 3DUIs become a new option to be considered when developing Information Systems (ISs). 3DUIs are one manifestation of virtual reality scenes that may contribute to inducing, establishing, and maintaining a sense of user's presence or immersion in the scene [S99, SVKV01], although this is not always the ultimate goal of the scene. When the virtual reality scene is manipulated remotely from the user's location, the effect is called telepresence. Developing 3DUIs is an activity that would benefit from the application of a Model-Based development method structuring the development life cycle of a 3DUIs.

* Distributed user interfaces (DUI)
* Multi-user applications

Summary and Conclusions

Acknowledgements

References

  • [APB99] Abrams, M., Phanouriou, C., Batongbacal, A.L., Williams, S. & Shuster, J. (1999), UIML: An Appliance-Independent XML User Interface Language. In A. Mendelzon, editor, Proceedings of 8th International World-Wide Web Conference WWW’8 (Toronto, May 11-14, 1999), Amsterdam, 1999. Elsevier Science Publishers.
  • [BMGMZ09] Breiner, K., Maschino, O., Goerlich, D., Meixner, G., Zuehlke, D.: Run-Time Adaptation of a Universal User Interface for Ambient Intelligent Production Environments, Proc. of the 13th International Conference on Human-Computer Interaction (HCII) 2009, San Diego, USA, LNCS 5613, 663-672.
  • [BKLP04] Bowman, D.A., Kruijff, E., LaViola, J., Poupyrev, I., 3D User Interfaces: Theory and Practice, Addison Wesley, Boston, July 2004.
  • [CCB02] Calvary, G., Coutaz, J., Bouillon, L., Florins, M., Limbourg, Q., Marucci, L., Paternò, F., Santoro, C., Souchon, N., Thevenin, D., Vabderdonckt, J., 2002 The CAMELEON Reference Framework, Deliverable 1.1, CAMELEON Project,
  • [CCTLBV03] Calvary, G., Coutaz, J., Thevenin, D., Limbourg, Q., Bouillon, L., Vanderdonckt, J. A Unifying Reference Framework for Multi-Target User Interfaces. Interacting with Computer 15,3 (2003) 289–308.
  • [C03] Carrol, J., HCI models, theories, and frameworks: toward a multidisciplinary science, Morgan Kaufmann, San Francisco, 2003.
  • [CM01] Cockburn, A., McKenzie. pers/chi01DM.pdf 3D or not 3D? Evaluating the Effect of the Third Dimension in a Document Management System, Proc. of the ACM Conf. on Human factors in computing systems CHI'2001 (Seattle, 31 March-5 April 2001), ACM Press, New York, 2001, pp. 434–441.
  • [DWGSZ03] Demler, G., Wasmund, M., Grassel, G., Spriestersbach, A. & Ziegert, T. (2003), Flexible pagination and layouting for device independent authoring, WWW2003 Emerging Applications for Wireless and Mobile access Workshop.
  • [EVP00] Eisenstein J., Vanderdonckt J., Puerta A. (2000), Adapting to Mobile Contexts with User-Interface Modeling, Proceedings of 3rd IEEE Workshop on Mobile Computing Systems and Applications WMCSA’2000 (Monterey, 7-8 December 2000), IEEE Press, Los Alamitos, 2000, pp. 83-92.
  • [EVP01] Eisenstein J., Vanderdonckt J., Puerta A. (2001), Applying Model-Based Techniques to the Development of UIs for Mobile Computers, Proceedings of 5th ACM Int. Conf. on Intelligent User Interfaces IUI’2001 (Santa Fe, 14-17 January 2001), Lester, J. (Ed.), ACM Press, New York, 2001, pp. 69-76.
  • [FV04] Florins, M., Vanderdonckt, J.: Graceful Degradation of User Interfaces as a Design Method for Multiplatform Systems. In: Proc. of 8th ACM Int. Conf. on Intelligent User Interfaces IUI’2004 (Funchal, 13-16 January 2004). ACM Press, New York (2004) 140–147
  • [GGVM09] Guerrero García, J., González Calleros, J.M., Vanderdonckt, J., Muñoz Arteaga, J., A Theoretical Survey of User Interface Description Languages: Preliminary Results, Proc. of Joint 4th Latin American Conference on Human-Computer Interaction-7th Latin American Web Congress LA-Web/CLIHC'2009 (Merida, November 9-11, 2009), E. Chavez, E. Furtado, A. Moran (Eds.), IEEE Computer Society Press, Los Alamitos, 2009, pp. 36-43.
  • [JP03] Johnson, P. D. & Parekh, J. Multiple Device Markup Language a Rule Approach. SE MS Project & Thesis (SE690), DePaul University, 2003.
  • [KTG92] Kahneman, D., Triesman, A., Gibbs, B.J., The reviewing of objects files: Objects-specific integration of information, Cognition Psychology, Vol. 24, 1992, pp. 175-219.
  • [KM97] Kieras, D.E., Meyer, D.E., An overview of the EDIC architecture for cognition and performance with application to human-computer interaction, Human-Computer Interaction, Vol. 12, 1997, pp. 391-438.
  • [LL09] Laudon, K.C., Laudon, J.P., Management Information Systems: Managing the Digital Firm, Pear-son, 2009.
  • [LVMBL04] Limbourg, Q., Vanderdonckt, J., Michotte, B., Bouillon, L., Lopez, V., UsiXML: a Language Supporting Multi-Path Development of User Interfaces, Proc. of 9th IFIP Working Conference on Engineering for Human-Computer Interaction jointly with 11th Int. Workshop on Design, Specification, and Verification of Interactive Systems EHCI-DSVIS’2004 (Hamburg, July 11-13, 2004). Lecture Notes in Computer Science, Vol. 3425, Springer-Verlag, Berlin, 2005, pp. 200-220.
  • [L04] Limbourg, Q., Multi-path Development of User Interfaces. Ph.D. thesis. Université catholique

de Louvain, IAG-School of Management. Louvain-la-Neuve (Nov. 2004).

  • [MPS02] Mori G., Paternò F., Santoro C. CTTE: Support for Developing and Analyzing Task Models for Interactive System Design, IEEE Transactions on Software Engineering, August 2002, pp.797-813.
  • [MSN09] Meixner, G.; Seissler, M.; Nahler, M.: Udit – A Graphical Editor For Task Models, Proc. of the 4th International Workshop on Model-Driven Development of Advanced User Interfaces (MDDAUI), Sanibel Island, USA, CEUR Workshop Proceedings Vol-439, 2009.
  • [MTK07] Meixner, G.; Thiels, N.; Klein, U.: SmartTransplantation - Allogeneic Stem Cell Transplantation as a Model for a Medical Expert System, Usability & HCI for Medicine and Health Care (USAB), Graz, Austria, LNCS 4799, 306-317, 2007.
  • [MT08] Meixner, G., Thiels, N.: Tool Support for Task Analysis, Workshop "User Interface Description Languages for Next Generation User Interfaces", 26th Annual CHI Conference on Human Factors in Computing Systems, Florence, Italy, 2008.
  • [ONN09] Oulasvirta, A., Nurminen, A., Nivala, A.M., Embodied interaction with a 3D versus 2D mobile map, Personal and Ubiquitous Computing, Vol. 13, No. 4, May 2009, pp. 303 - 320.
  • [P07] Parris, C., Do better business in 3D, Business Week, 1 May 2007.
  • [P00] Paternò F., Model-Based Design and Evaluation of Interactive Applications, Springer Verlag, 2000.
  • [P05]Paternò F., Model-based Tools for Pervasive Usability, Interacting with Computers, Elsevier, May 2005, Vol.17, Issue 3, pp. 291-315.
  • [PSM08] Paternò F., Santoro C., Mantyjarvi J., Mori G., Sansone S. 2008. Authoring pervasive multimodal user interfaces, in Int. J. Web Engineering and Technology. 4(2), 235-261.
  • [PSS09] Paternò F., Santoro C., Spano L.D., MARIA: A Universal Language for Service-Oriented Applications in Ubiquitous Environment, ACM Transactions on Computer-Human Interaction, Vol.16, N.4, November 2009, pp.19:1-19:30.
  • [SVKV01] Schuemie, M. J., van der Straaten, P., Krijn, M., van der Mast, C.P.G., Research on Presence in VR: A Survey, Cyberpsychology and Behavior, Vol. 4, No. 2, 2001, pp. 183-202.
  • [S99] Slater, M., Measuring Presence: A Response to the Witmer and Singer Presence Questionnaire, Pres-ence: Teleoperators and Virtual Environments, Vol. 8, No.5, 1999, pp. 560-565.
  • [S02] Shneiderman, B., 3D or Not 3D: When and Why Does it Work?. Human-Computer Interaction Laboratory & Department of Computer Science University of Maryland. Talk in Web3D (Phoenix, 26 February 2002).
  • [V05] Vanderdonckt, J., A MDA-Compliant Environment for Developing User Interfaces of Information Systems, Proc. of 17th Conf. on Advanced Information Systems Engineering CAiSE'05 (Porto, 13-17 June 2005), O. Pastor & J. Falcão e Cunha (eds.), Lecture Notes in Computer Science, Vol. 3520, Springer-Verlag, Berlin, 2005, pp. 16-31.
  • [VCCS07] Vanderdonckt, J., Coutaz, J., Calvary, G., Stanciulescu, A., Multimodality for Plastic User Interfaces: Models, Methods, and Principles, Chapter 4, in “Multimodal user interfaces: signals and communication technology”, D. Tzovaras (ed.), Lecture Notes in Electrical Engineering, Springer-Verlag, Berlin, 2007, pp. 61-84.
  • [V08] Vanderdonckt, J., Model-Driven Engineering of User Interfaces: Promises, Successes, and Failures, Proc. of 5th Annual Romanian Conf. on Human-Computer Interaction ROCHI’2008 (Iasi, 18-19 September 2008), S. Buraga, I. Juvina (Eds.), Matrix ROM, Bucarest, 2008, pp. 1-10. ISSN 1843-4460.
  • [S03] Shneiderman, B., Why Not Make Interfaces Better than 3D Reality, Virtualization Viewpoints. Theresa-Marie Rhyme (Ed.), November-December, 2003.
  • [UsiXML] UsiXML Eureka-ITEA2
  • [ZT08] Zuehlke, D.; Thiels, N.: Useware engineering: a methodology for the development of user-friendly interfaces, in: Library Hi Tech, Vol. 26, No. 1, 2008.