scholarly journals Towards a model-driven approach for multiexperience AI-based user interfaces

2021 ◽  
Author(s):  
Elena Planas ◽  
Gwendal Daniel ◽  
Marco Brambilla ◽  
Jordi Cabot
Keyword(s):  
User Interface ◽  
Language Processing ◽  
User Interfaces ◽  
The Other ◽  
Software Systems ◽  
Model Driven ◽  
Software Applications ◽  
Domain Specific ◽  
Faster Development ◽  
Model Driven Approach

AbstractSoftware systems start to include other types of interfaces beyond the “traditional” Graphical-User Interfaces (GUIs). In particular, Conversational User Interfaces (CUIs) such as chat and voice are becoming more and more popular. These new types of interfaces embed smart natural language processing components to understand user requests and respond to them. To provide an integrated user experience all the user interfaces in the system should be aware of each other and be able to collaborate. This is what is known as a multiexperience User Interface. Despite their many benefits, multiexperience UIs are challenging to build. So far CUIs are created as standalone components using a platform-dependent set of libraries and technologies. This raises significant integration, evolution and maintenance issues. This paper explores the application of model-driven techniques to the development of software applications embedding a multiexperience User Interface. We will discuss how raising the abstraction level at which these interfaces are defined enables a faster development and a better deployment and integration of each interface with the rest of the software system and the other interfaces with whom it may need to collaborate. In particular, we propose a new Domain Specific Language (DSL) for specifying several types of CUIs and show how this DSL can be part of an integrated modeling environment able to describe the interactions between the modeled CUIs and the other models of the system (including the models of the GUI). We will use the standard Interaction Flow Modeling Language (IFML) as an example “host” language.

A Context-Aware MDA Approach for Content Personalization in User Interface Development

2014 ◽  
pp. 88-105
Author(s):  
Firas Bacha ◽  
Káthia Marçal de Oliveira ◽  
Mourad Abed
Keyword(s):  
User Interface ◽  
User Interfaces ◽  
Smart Phone ◽  
Domain Model ◽  
Context Aware ◽  
Context Model ◽  
Interface Elements ◽  
Model Driven ◽  
Software Applications ◽  
The Right

User Interface (UI) personalization aims at providing the right information, at the right time, and on the right support (tablets, smart-phone, etc.). Personalization can be performed on the interface elements’ presentation (e.g. layout, screen size, and resolution) and on the content provided (e.g., data, information, document). While many existing approaches deal with the first type of personalization, this chapter explores content personalization. To that end, the authors define a context-aware Model Driven Architecture (MDA) approach where the UI model is enriched by data from a domain model and its mapping to a context model. They conclude that this approach is better used only for domains where one envisions several developments of software applications and/or user interfaces.

scholarly journals Models and methods of designing human-machine interaction-oriented interfaces

2020 ◽  
Keyword(s):  
User Interface ◽  
User Interfaces ◽  
Code Generation ◽  
Interface Design ◽  
User Interface Design ◽  
Interactive Systems ◽  
Software Systems ◽  
Human Machine Interaction ◽  
Model Driven ◽  
Model Based

Formalization approaches of user interface design (UID) in conjunction with model driven techniques aim to improve the usability in terms of conformity to standards or style guides and to leverage code generation of interactive software systems, so that various UI platforms for web, desktop or mobile Applications are supported. Because large parts of the UI are described platform independent instead of platform dependent implementations, re-usability of the UI concept is also improved. However, UI formalization requires the usage of a formal UI description language and a higher level of abstractness compared to concrete UI code. These languages need to be learned by the UI designer. In practice, most parts of a user interface are still manually designed and coded individually for every platform. This paper describes how HCI (Human Computer Interface) patterns that are described formally can be used in conjunction with model-based user interface design in order to make it easier for the designer to use formalization techniques for the development of user interfaces. The approach uses two UML profiles: The MBUID (Model-Based User Interface Design) profile and the HCI pattern profile. With these profiles formal models of interactive systems can be created on a platform independent level. The user interface is then automatically generated by model-driven development tool chain.

Software and Culture

2011 ◽  
pp. 56-71
Author(s):  
Gregory E. Kersten ◽  
Mik A. Kersten ◽  
Wojciech M. Rakowski
Keyword(s):  
User Interface ◽  
User Interfaces ◽  
User Interaction ◽  
The Other ◽  
Application Software ◽  
Software Applications ◽  
Deep Culture ◽  
Core Functionality ◽  
Interaction Component

Software applications are designed around user interaction. One interaction component is the user interface; the other deeper components represent the applications’ logic and core functionality. Internationalization architectures recognize the need for localizing user interfaces to particular cultures. We continue the discussion on culture and software focusing on the software core rather than the user interface. This core corresponds to deep culture as opposed to the surface cultural manifestations embedded in the user interface. We argue here that deep culture can be embedded into application software in a modular way.

scholarly journals Comparison Between Internal and External DSLs via RubyTL and Gra2MoL

2012 ◽  
pp. 109-131 ◽  
Author(s):  
Jesús Sánchez Cuadrado ◽  
Javier Luis Cánovas Izquierdo ◽  
Jesús García Molina
Keyword(s):  
Empirical Studies ◽  
Lessons Learned ◽  
The Other ◽  
Model Transformations ◽  
Domain Specific Languages ◽  
Model Driven ◽  
Domain Specific ◽  
Advantages And Disadvantages

Domain Specific Languages (DSL) are becoming increasingly more important with the emergence of Model-Driven paradigms. Most literature on DSLs is focused on describing particular languages, and there is still a lack of works that compare different approaches or carry out empirical studies regarding the construction or usage of DSLs. Several design choices must be made when building a DSL, but one important question is whether the DSL will be external or internal, since this affects the other aspects of the language. This chapter aims to provide developers confronting the internal-external dichotomy with guidance, through a comparison of the RubyTL and Gra2MoL model transformations languages, which have been built as an internal DSL and an external DSL, respectively. Both languages will first be introduced, and certain implementation issues will be discussed. The two languages will then be compared, and the advantages and disadvantages of each approach will be shown. Finally, some of the lessons learned will be presented.

A Global Process for Model-Driven Approaches in User Interface Design

2012 ◽  
pp. 219-234
Author(s):  
Sybille Caffiau ◽  
Patrick Girard
Keyword(s):  
User Interface ◽  
User Interfaces ◽  
Interface Design ◽  
User Interface Design ◽  
Application Development ◽  
Design Standards ◽  
Model Driven ◽  
Iterative Development ◽  
Advanced User ◽  
Interactive Application

In user interface design, model-driven approaches usually involve generative solutions, producing interface by successive transformations of a set of initial models. These approaches have obvious limitations, especially for advanced user interfaces. Moreover, top-down design approaches (as generative approaches are) are not appropriate for interactive application development in which users need to be included in the whole design process. Based on strong associations between task models and dialogue models, the authors propose a global process, which facilitates the design of interactive applications conforming to their models, including a rule-checking step. This process permits either to start from a task model or a user-defined prototype. In any case, it allows an iterative development, including iterative user modifications, in line with user-centered design standards.

Pair Modeling

2010 ◽  
pp. 1171-1178 ◽  
Author(s):  
Pankaj Kamthan
Keyword(s):  
Software Development ◽  
Software Process ◽  
Software Systems ◽  
Model Driven ◽  
Model Driven Approach

We model software for a variety of reasons: to assess the viability of or plan software systems to be built, to optimize use of (minimize, or ideally, avoid waste of) resources in response to inevitable changes in business, social, or technological environments, or simply to understand existing software systems. Indeed, as indicated by the model-driven approach to software development (Beydeda, Book, & Gruhn, 2005), models are becoming first-class members of organizations and software process environments that embrace them. The examples of collaboration in implementation of software are well-known (Nosek, 1998; Williams & Kessler, 2003). As models get large and complex, the need for creating them collaboratively in a systematic manner arises, and we propose pair modeling as an approach.

scholarly journals From Mockups to User Interface Models: An Extensible Model Driven Approach

2010 ◽  
pp. 13-24 ◽  
Author(s):  
José Matías Rivero ◽  
Gustavo Rossi ◽  
Julián Grigera ◽  
Juan Burella ◽  
Esteban Robles Luna ◽  
...  
Keyword(s):  
User Interface ◽  
Model Driven ◽  
Interface Models ◽  
Model Driven Approach

A Model Driven Approach based on Interaction Flow Modeling Language to Generate Rich Internet Applications

2016 ◽  
Vol 6 (6) ◽  
pp. 3073
Author(s):  
Sarra Roubi ◽  
Mohammed Erramdani ◽  
Samir Mbarki
Keyword(s):  
User Interfaces ◽  
Code Generation ◽  
Model Transformations ◽  
Modeling Framework ◽  
Rich Internet Application ◽  
Internet Applications ◽  
Model Driven ◽  
Rich Internet Applications ◽  
Desktop Interfaces ◽  
Model Driven Approach

<p><span lang="EN-US">A Rich Internet Applications (RIAs) combine the simplicity of the hypertext paradigm with the flexibility of desktop interfaces. These appliations were proposed as a solution to follow the rapid growth and evolution of the Graphical User Interfaces. However, RIAs are complex applications and their development requires designing and implementation which are time-consuming and the available tools are specialized in manual design. In this paper, we present a model driven approach to generat GUI for Rich Internet Application. The approach exploits the new language IFML recently adopted by the Object Management Group. We used frameworks and technologies known to Model-Driven Engineering, such as Eclipse Modeling Framework (EMF) for Meta-modeling, Query View Transformation (QVT) for model transformations and Acceleo for code generation. The approach allows to quickly and efficiently generating a RIA focusing on the graphical aspect of the application.</span></p>

An Empirical Evaluation of a Vocal User Interface for Programming by Voice

2015 ◽  
Vol 8 (2) ◽  
pp. 47-63 ◽  
Author(s):  
Amber Wagner ◽  
Jeff Gray
Keyword(s):  
User Interface ◽  
User Interfaces ◽  
Physical Disabilities ◽  
Empirical Evaluation ◽  
Graphical User Interfaces ◽  
Programming Environment ◽  
Software Applications ◽  
Legacy Application ◽  
Programming By Voice ◽  
Vocal User Interface

Although Graphical User Interfaces (GUIs) often improve usability, individuals with physical disabilities may be unable to use a mouse and keyboard to navigate through a GUI-based application. In such situations, a Vocal User Interface (VUI) may be a viable alternative. Existing vocal tools (e.g., Vocal Joystick) can be integrated into software applications; however, integrating an assistive technology into a legacy application may require tedious and manual adaptation. Furthermore, the challenges are deeper for an application whose GUI changes dynamically (e.g., based on the context of the program) and evolves with each new application release. This paper provides a discussion of challenges observed while mapping a GUI to a VUI. The context of the authors' examples and evaluation are taken from Myna, which is the VUI that is mapped to the Scratch programming environment. Initial user studies on the effectiveness of Myna are also presented in the paper.

Sign in / Sign up

Export Citation Format

Share Document