User-centered approach to adaptive interfaces

Both adaptive and adaptable user interfaces are intended to fit the needs of individual users and their tasks better. A problem with these interfaces is that users must have and use additional knowledge, either to understand the automatic, system-driven adaptations or to adapt the interface on their own. Beyond these two extreme approaches, an automatically self-adapting system and a user manually adapting the system, the approach introduced in this paper strives for a third option, in which users are able to tell the system how to adapt itself. Accordingly, methods include adaptive adaptation (i.e. modifying the adaptation strategies) and implicit adaptation (i.e. changing the underlying models). The applicability of these findings is illustrated in the context of an adaptive action prompting environment.     

: a toolset for creating customized interfaces for grid user communities

is a comprehensive set of tools for creating customized graphical user interfaces (GUIs). It draws from the concept of computing portals, which are here seen as interfaces to application-specific computing services for user communities. While was originally designed for the use in computational grids, it can be used in client/server environments as well.Compared to other GUI generators, is more versatile and more portable. It can be employed in many different application domains and on different target platforms. With , application experts (rather than computer scientists) are able to create their own individually tailored GUIs.     

An event‐flow model of GUI‐based applications for testing

Graphical user interfaces (GUIs) are by far the most popular means used to interact with today's software. The functional correctness of a GUI is required to ensure the safety, robustness and usability of an entire software system. GUI testing techniques used in practice are resource intensive; model‐based automated techniques are rarely employed. A key reason for the reluctance in the adoption of model‐based solutions proposed by researchers is their limited applicability; moreover, the models are expensive to create. Over the past few years, the present author has been developing different models for various aspects of GUI testing. This paper consolidates all of the models into one scalable event‐flow model and outlines algorithms to semi‐automatically reverse‐engineer the model from an implementation. Earlier work on model‐based test‐case generation, test‐oracle creation, coverage evaluation, and regression testing is recast in terms of this model by defining event‐space exploration strategies (ESESs) and creating an end‐to‐end GUI testing process. Three such ESESs are described: for checking the event‐flow model, test‐case generation, and test‐oracle creation. Two demonstrational scenarios show the application of the model and the three ESESs for experimentation and application in GUI testing. Copyright © 2007 John Wiley & Sons, Ltd.     

Adaptive dialogue management using intent clustering and fuzzy rules

Conversational systems have become an element of everyday life for billions of users who use speech‐based interfaces to services, engage with personal digital assistants on smartphones, social media chatbots, or smart speakers. One of the most complex tasks in the development of these systems is to design the dialogue model, the logic that provided a user input selects the next answer. The dialogue model must also consider mechanisms to adapt the response of the system and the interaction style according to different groups and user profiles. Rule‐based systems are difficult to adapt to phenomena that were not taken into consideration at design‐time. However, many of the systems that are commercially available are based on rules, and so are the most widespread tools for the development of chatbots and speech interfaces. In this article, we present a proposal to: (a) automatically generate the dialogue rules from a dialogue corpus through the use of evolving algorithms, (b) adapt the rules according to the detected user intention. We have evaluated our proposal with several conversational systems of different application domains, from which our approach provided an efficient way for adapting a set of dialogue rules considering user utterance clusters.     

A comprehensive solution for application‐level adaptation

Driven by the emergence of mobile and pervasive computing there is a growing demand for context‐aware software systems that can dynamically adapt to their run‐time environment. We present the results of project MADAM that has delivered a comprehensive solution for the development and operation of context‐aware, self‐adaptive applications. The main contributions of MADAM are (a) a sophisticated middleware that supports the dynamic adaptation of component‐based applications, and (b) an innovative model‐driven development methodology that is based on abstract adaptation models and corresponding model‐to‐code transformations. MADAM has demonstrated the viability of a general, integrated approach to application‐level adaptation. We discuss our experiences with two real‐world case studies that were built using the MADAM approach. Copyright © 2008 John Wiley & Sons, Ltd.     

Using meta‐modeling in design and implementation of component‐based systems: the SOFA case study

To allow efficient and user‐friendly development of a component‐based application, component systems have to provide a rather complex development infrastructure, including a tool for component composition, component repository, and a run‐time infrastructure. In this paper, we present and evaluate benefits of using meta‐modeling during the process of defining a component system and also during creation of the development and run‐time infrastructures. Most of the presented arguments are based on a broad practical experience with designing the component systems SOFA and SOFA 2; the former designed in a classical ad hoc ‘manual’ way, whereas the latter with the help of meta‐modeling. Copyright © 2010 John Wiley & Sons, Ltd.     

A Model Transformation Approach for Automatic Composition of COTS User Interfaces in Web-Based Information Systems

Globalization of the information and the Knowledge Society requires the modernization of Web-based Information Systems (WIS) into evolutive and adaptable user interfaces. Today, WIS user interfaces are built following traditional development paradigms. This article is inspired on a Model-Driven Development (MDD) perspective to produce runtime automatic composition of user interfaces from model and metamodel representations of widgets-type COTS interface components architectures and model transformation.     

Augmented reality agents for user interface adaptation

Most augmented reality (AR) applications are primarily concerned with letting a user browse a 3D virtual world registered with the real world. More advanced AR interfaces let the user interact with the mixed environment, but the virtual part is typically rather finite and deterministic. In contrast, autonomous behavior is often desirable in ubiquitous computing (Ubicomp), which requires the computers embedded into the environment to adapt to context and situation without explicit user intervention. We present an AR framework that is enhanced by typical Ubicomp features by dynamically and proactively exploiting previously unknown applications and hardware devices, and adapting the appearance of the user interface to persistently stored and accumulated user preferences. Our framework explores proactive computing, multi‐user interface adaptation, and user interface migration. We employ mobile and autonomous agents embodied by real and virtual objects as an interface and interaction metaphor, where agent bodies are able to opportunistically migrate between multiple AR applications and computing platforms to best match the needs of the current application context. We present two pilot applications to illustrate design concepts. Copyright © 2007 John Wiley & Sons, Ltd.     

COIVA: context‐aware and ontology‐powered information visualization architecture

This paper exploits semantics to apply context in run‐time adaptation, particularly for services in a user‐centered smart environment. Context‐sensitive services are usually focused on their own information without interoperation pretensions. It is necessary to enable common context models and systems in order to make context‐aware applications interoperable. Moreover, context management systems need to implement mechanisms to support the dynamic behavior of the users and their surroundings, including techniques to adapt the model to their future needs, to maintain the context information at run‐time and to be interoperable with external context models. By adapting web semantic technologies we can enable smarter and more proactive operation of context management systems. Copyright © 2010 John Wiley & Sons, Ltd.     

A lightweight framework for dynamic GUI data verification based on scripts

Runtime verification (RV) provides essential mechanisms to enhance software robustness and prevent malfunction. However, RV often entails complex and formal processes that could be avoided in scenarios in which only invariants or simple safety properties are verified, for example, when verifying input data in Graphical User Interfaces (GUIs). This paper describes S‐DAVER, a lightweight framework aimed at supporting separate data verification in GUIs. All the verification processes are encapsulated in an independent layer and then transparently integrated into an application. The verification rules are specified in separate files and written in interpreted languages to be changed/reloaded at runtime without recompilation. Superimposed visual feedback is used to assist developers during the testing stage and to improve the experience of users during execution. S‐DAVER provides a lightweight, easy‐to‐integrate and dynamic verification framework for GUI data. It is an integral part of the development, testing and execution stages. An implementation of S‐DAVER was successfully integrated into existing open‐source applications, with promising results. Copyright © 2015 John Wiley & Sons, Ltd.     

Event‐based modelling,analysis and testing of user interactions: approach and case study

With the growing complexity of computer‐based systems, their graphical user interfaces have also become more complex. Accordingly, the test and analysis process becomes more tedious and costly. This paper introduces a holistic view of fault modelling that is carried out as a complementary step to system modelling, enabling a scalability of the test process, and providing considerable potential for automation. Event‐based notions and tools are used to generate and select test cases systematically. The elements of the approach are illustrated and validated by a case study. This paper does not claim to introduce a novel theoretic approach; rather, it makes use of graph‐theoretic results for a practical and simple, but nevertheless powerful, view of modelling, analysis and testing of graphical user interfaces. Copyright © 2005 John Wiley & Sons, Ltd.     

Framework and authoring tool for an extension of the UIML language

This paper presents a framework for the design of User Interfaces (UIs). By applying model transformations, the framework allows different UIs to be generated for different computing platforms. The tool presented in this work helps designers to build an abstract user interface which is later transformed into a concrete user interface by means of transformation techniques based on graph grammars. These techniques can be used to generate implementation code for several UI platforms including desktop applications, dynamic websites and mobile applications. The generated user interfaces are integrated with a multi-tier application by referencing external services and communicating with the application core over Web Service protocols. Our tool also allows the concrete interfaces to be enhanced before generating the final UI. The approach uses an adaptation of UIML (User Interface Markup Language). The adaptation focuses on defining a data model and a services model, and it also introduces a navigation model that allows data communication from one UI to another. The obtained UIs together with Web Services can conform complete applications instead of just being prototypes.     

基于自适应光标的图形用户界面输入效率优化

提高图形用户界面(graphical user interface)的输入效率,是人机交互中的一项重要研究内容.已有的研究包括点击增强技术和自适应界面技术,前者改变光标的控制方式或呈现方式,后者改变界面上控件的位置布局,但两种技术都存在不足.通过分析界面操作,提出了图形用户界面输入效率的评价模型;然后,在此基础上提出一种人机交互效率优化技术:自适应光标.它以自适应的方式,有选择地对界面上用户可能访问的控件通过点击增强技术支持,实现快速访问.该方法既解决了以往的自适应界面技术因频繁调整控件布局而给用户带来额外认知成本的问题,也克服了点击增强技术仅适用于稀疏控件布局的限制.为了检验其可用性,在控件较多的Visual Studio上实现了自适应光标技术.实验结果表明,使用自适应光标技术可以将获取目标的时间缩短27.7％,显著提高了图形用户界面的输入效率.     

Design and evaluation of an adaptive icon toolbar

As information systems become increasingly important in many different domains, the potential to adapt them to individual users and their needs also becomes more important. Adaptive user interfaces offer many possible ways to adjust displays and improve procedures for a user's individual patterns of work. This paper describes an attempt to design an adaptive user interface in a computer environment familiar to many users. According to one classification of adaptive user interfaces, the adaptive bar described in this paper would be classified as a user-controlled self-adaptation system.At the user's convenience, the adaptive bar offers suggestions for adding or removing command icons, based on the frequency and probability of specific commands. It also implements these changes once the user has agreed to them. Beyond the adaptive bar, the general behavior of the whole user interface does not change, thereby allowing the user to maintain a clear general model of the system. This paper describes the decision-making algorithm implemented in the bar. It also describes the bar's self-adaptive behavior of displaying the frequency of each icon's use through the icon's size. Finally, we present some encouraging preliminary results of evaluations by users.     

Neurophysiological correlates in interface design: An HCI perspective

Objective: The current study examines the changes in functional connectivity that occurs when expert users adapt to an alternate mapping. Background: Research has indicated that interfaces that are similar will result in more errors and may contribute to confusion. Methods: Six volunteers were recruited to determine the neurophysiological changes that occur when users are exposed to an alternate mapping once an internal mental model is formed. Results: The results indicated a change in synchronization after alterations to the button mappings occurred. By altering the layout or order of the task, a difference in the activation pattern was observed. New areas became synchronized while synchronized activity that was present in the developed internal model became desynchronized. Altering the complexity of the task resulted in different patterns of activation recorded on the quantitative electroencephalogram (QEEG). Conclusion: Users often form a schema when learning a device and subsequent interactions are compared to the mental model formed during the initial learning phase. If the newer interface differs significantly a new schema is formed, resulting in a different pattern of synchronization recorded on the QEEG. Application: The use of this knowledge can assist in the development of new interfaces. If the intent is to create a similar interface design, the activation pattern should remain the same indicating that the old schema can be applied. An interface that displays a different cognitive pattern will indicate that a new schema was developed.     

CIRL/PIWI: A GUI toolkit supporting retargetability

Writing applications that are easily moved to various computer platforms with different graphical user interfaces (GUIs) is a complex task. Yet this concept is important for the creator of commercial software, as it is not likely to be clear for many years whether one or two GUIs will survive and become industry ‘standards’ or whether the growth in GUIs will continue because of new developments in human-computer interfaces. Providing a user interface abstraction that maps into all toolkits seems to be an appropriate way to proceed, but is fraught with difficulty. For example, different GUIs present a different look-and-feel that often causes system-specific information to be embedded in an application. This paper surveys the problems inherent in designing a user interface abstraction, and describes the experiences gained from a specific implementation called CIRL/PIWI.

1 CIRL and PIWI are acronyms for Co-ordinate-Independent Resource Language and Presentation-Independent Windowed Interface.

The user interface abstraction contains a knowledge base that allows many components of the user interface to be defined independent of look-and-feel thereby increasing the portability of an application.     

Experiences developing architectures for realizing thin‐client diagram editing tools

Diagram‐centric applications such as software design tools, project planning tools and business process modelling tools are usually ‘thick‐client’ applications running as stand‐alone desktop applications. There are several advantages to providing such design tools as Web‐based or even PDA‐ and mobile‐phone‐based applications. These include ease of access and upgrade, provision of collaborative work support and Web‐based integration with other applications. However, building such thin‐client diagram editing tools is very challenging. We have developed several thin‐client diagram editing applications realized as a set of plug‐in extensions to a meta‐tool for visual design environment development. In this paper, we discuss key user interaction and software architecture issues, illustrate examples of interacting with our thin‐client diagram editing tools, describe our design and implementation approaches, and present the results of several different evaluations of the resultant applications. Our experiences will be useful for those interested in developing their own thin‐client diagram editing architectures and applications. Copyright © 2007 John Wiley & Sons, Ltd.     

WAMM in the framework of graphical user interfaces for metacomputing management

Current environments for metacomputing generally have tools for managing the resources of a metacomputer but often lack adequate tools for designing, writing, and executing programs. Building an application for a metacomputer typically involves writing source codes on a local node, transferring and compiling codes on every node, and starting their execution. Without such tools, the application development phases can come up against considerable difficulties. In order to alleviate these problems, some graphical user interfaces (GUIs) based on PVM, such as XPVM, Parallel Application Development Environment (PADE) and Wide Area Metacomputing Manager (WAMM) have been implemented. These GUIs integrate a programming environment which facilitates the user in performing the application development phases and the application execution.

This paper outlines the general requirements for designing GUIs for metacomputing management, and compares WAMM, a graphical user interface, with some related works.     

Command‐line interfaces can be efficiently brought to graphics: COLIMATE (the COmmand LIne MATE)

Scientific computing has traditionally been done on workstations, most of the time running on UNIX‐like operating systems. These systems are often very robust, powerful and especially suited to heavy computation tasks; however, the usual user interface is based on a command line with all the information needed for the appropriate functioning of the algorithm. These command lines are seldom user‐friendly but, on the other hand, they allow batch processes to be built. In this work, a model for command‐line‐driven packages is given, and at the same time the model includes objects that can be directly translated into a graphical user interface. A language (Colimate) implementing this model is shown to serve as a bridge between command‐line‐driven programs and more friendly user interfaces. Exploiting the specificness of the user interfaces addressed, powerful graphical interfaces can be built with a very simple syntax and small programming effort. Furthermore, the command‐line program needs not to be modified, so in this way the possibility of making batches is not lost. Copyright © 2002 John Wiley & Sons, Ltd.