The Research on Dynamical Generation of User Interface Under Cloud Computing Environment

Nowadays several Computer-Aided Software Engineering environments exploit Model-Driven Engineering (MDE) techniques in order to generate a single user interface for a given computing platform or multi-platform user interfaces for several computing platforms simultaneously. Therefore, there is a need to assess the usability of those generated user interfaces, either taken in isolation or compared to each other. This paper describes an MDE approach that generates multi-platform graphical user interfaces (e.g., desktop, web) that will be subject to an exploratory controlled experiment. The usability of user interfaces generated for the two mentioned platforms and used on multiple display devices (i.e., standard size, large, and small screens) has been examined in terms of satisfaction, effectiveness and efficiency. An experiment with a factorial design for repeated measures was conducted for 31 participants, i.e., postgraduate students and professors selected by convenience sampling. The data were collected with the help of questionnaires and forms and were analyzed using parametric and non-parametric tests such as ANOVA with repeated measures and Friedman's test, respectively. Efficiency was significantly better in large screens than in small ones as well as in the desktop platform rather than in the web platform, with a confidence level of 95%. The experiment also suggests that satisfaction tends to be better in standard size screens than in small ones. The results suggest that the tested MDE approach should incorporate enhancements in its multi-device/platform user interface generation process in order to improve its generated usability.

In this paper we present a solution to compose synchronized multimodal computer human interaction with a pattern-oriented approach. The focus of this paper is how to synchronize the different modalities of interaction.In our application scenario the system consists of mobile agents and the user interface is generated from a dialog description language, which is XML-encoded. The generated User Interface is executed by one or more UI-engines, which can use one or more modalities like a text chat system, a speech-based system or a graphical, window-oriented user interface. The user interface is separated and also structured by so-called dialog moves which are suitable to be adapted to different UI-engines. The system supports more than one UI-engine at the same time which results in a possibly multimodal interaction. The interaction is synchronized by observing the events produced by the dialog moves of each UI-engine.The system is evaluated in a project called MAP1 which deals with new human computer interaction methods in future mobile work environments.

In this article we present our approach developed concerning the generation of usable User Interfaces (UI), then we show its results, starting as a basis with UML models. Indeed, we based the approach on the Model Driven Engineering and the development of specific meta models for UI from the perspective of a UML model-based design on one hand and a set of transformations on the other hand. Indeed, we defined a new meta model that is neither a use case nor an activity diagram, but our way to describe the UI in terms of the user's interactions. Thus we used the good practices of Designs Patterns when developing the meta models. The approach includes first creating a platform independent model (PIM) and transforming this PIM into platform specific model (PSM) thought transformation rules. The PIM is created first based on the UML use case and activities diagrams to extract the main functionalities offered by the system to be developed. Then we established the PSM meta model, being the target model of our transformation engine, taking into account the design patterns composite and MVC. With this methodology, the UI can easily be analyzed, designed, and generated to increase system development

A user interface description language (UIDL) consists of a specification language that describes various aspects of a user interface under development. A comparative review of some selected user interface description languages is produced in order to analyze how they support the various stages of user interface development life cycle and development goals, such as support for multi-platform, device-independence, modality independence, and content delivery. There has been a long history and tradition to attempt capturing the essence of user interfaces at various levels of abstraction for different purposes, including those of development. The recent return of this effort today gains more attraction, along with the dissemination of XML markup languages, and gives birth to many proposals for various user interface description languages. Consequently, an in-depth analysis of the salient features that make these languages different from each other is desired in order to identify when and where they are appropriate for a specific purpose. The review is conducted based on a systematic analysis grid and some user interfaces implemented with these languages.

Drug administration errors are frequent and are often associated with the misuse of IV infusion pumps. One source of these errors may be the infusion pump's user interface. We used failure modes-and-effects analyses to identify programming errors and to guide the design of a new syringe pump user interface. We designed the new user interface to clearly show the pump's operating state simultaneously in more than 1 monitoring location. We evaluated anesthesia residents in laboratory and simulated environments on programming accuracy and error detection between the new user interface and the user interface of a commercially available infusion pump. With the new user interface, we observed the number of programming errors reduced by 81%, the number of keystrokes per task reduced from 9.2 ± 5.0 to 7.5 ± 5.5 (mean ± SD), the time required per task reduced from 18.1 ± 14.1 seconds to 10.9 ± 9.5 seconds and significantly less perceived workload. Residents detected 38 of 70 (54%) of the events with the new user interface and 37 of 70 (53%) with the existing user interface, despite no experience with the new user interface and extensive experience with the existing interface. The number of programming errors and workload were reduced partly because it took less time and fewer keystrokes to program the pump when using the new user interface. Despite minimal training, residents quickly identified preexisting infusion pump problems with the new user interface. Intuitive and easy-to-program infusion pump interfaces may reduce drug administration errors and infusion pump-related adverse events.

Service-centric solutions usually require rich context to fully deliver and better reflect on the underlying applications. We present a novel use of context in the form of customized user interface services with the concept of User Interface as a Service (UIaaS). UIaaS takes user profiles as input to generate context-aware interface services. Such interface services can be used as context to augment semantic services with contextual information leading to UIaaS as a Context (UIaaSaaC). The added serendipitous benefit of the proposed concept is that the composition of a customized user interface with the requested service is performed by the service composition engine, as is the case with any other services. We use a special-purpose language (called User Interface Description Language (UIDL)) to model and realize user interfaces as services. We use a real-life e-government application, human services delivery for the citizens, as a proof-of-concept. We also present a comprehensive evaluation of the proposed approach using a functional evaluation and a nonfunctional evaluation consisting of an end user usability test and expert usability reviews.

The increasing adoption of process-aware information systems (PAISs) has resulted in a large number of implemented business processes. To react on changing needs, companies should be able to quickly adapt these process implementations if required. Current PAISs, however, only provide mechanisms to evolve the schema of a process model, but do not allow for the automated creation and adaptation of their user interfaces (UIs). The latter may have a complex logic and comprise, for example, conditional elements or database queries. Creating and evolving the UI components of a PAIS manually is a tedious and error-prone task. This technical report introduces a set of patterns for transforming fragments of a business process model, whose activities are performed by the same user role, to UI components of the PAIS. In particular, UI logic can be expressed using the same notation as for process modeling. Furthermore, a transformation method is introduced, which applies these patterns to automatically derive UI components from a process model by establishing a bidirectional mapping between process model and UI. This mapping allows propagating UI changes to the process model and vice versa. Overall, our approach enables process designers to rapidly develop and update complex UI components in PAISs.

Legacy software, particularly from the 1990s, often becomes obsolete due to aging hardware and outdated software environments. Traditionally, software modernization required extensive manual effort, involving reverse engineering, code rewriting, and re-architecting. However, advancements in large language models (LLMs) have introduced new possibilities for automating software translation and modernization. This paper explores the feasibility of using LLMs for modernizing 90s-era Windows applications, specifically migrating legacy C and C[Formula: see text] code to Python. Our methodology includes decompilation, source code analysis, automated translation using ChatGPT, and user interface reconstruction. We empirically evaluate three software projects by analyzing LLM-based translation accuracy across different code structures, including algorithmic logic, file handling, and graphical interfaces. Results indicate that while LLMs achieve high translation accuracy [Formula: see text] for structured code, challenges persist in handling decompiled code and user interface generation. The study provides insights into the effectiveness and limitations of LLMs in real-world software renovation, offering guidelines for leveraging machine learning in legacy system modernization. These findings contribute to both academic research and practical applications, suggesting a pathway for cost-effective and scalable legacy software migration.

As a technique applied with artificial neural networks, deep learning is widely used in the field of image recognition. However, a lack of available datasets leads to imperfect model learning. By analysing the data scale requirements of deep learning and aiming at the application in graphical user interface (GUI) generation, it was found that the collection of GUI datasets is a time- and labour-consuming project. This makes it difficult to meet the dataset needs of current deep learning networks. To solve this problem, we propose the user interface generative adversarial network (UIGAN), a semi-supervised deep learning model, to produce a large number of reliable GUI datasets. By combining a cyclic neural network with a generated countermeasure network, UIGAN can learn the sequence relationship and characteristics of data, make the generated countermeasure network generate reasonable data, and then expand the selected Rico dataset. Relying on the network structure, the characteristics of collected data can be well analysed, and a large number of reasonable data can be generated according to them. After data processing, a reliable dataset for model training can be formed, which alleviates the problem of dataset shortage in deep learning.KeywordsGUIDeep learningGANData augmentation

User and device diversities are two main factors combating efficient information communication in a mobile or pervasive computing environment. Additionally, the derivatives of traditional desktop computer such as handheld and wearable devices suffer from constrained resources. Most of these devices are faced with small display sizes, small computing power and storage capability. Likewise, end users of these devices have different preferences, which must be given utmost consideration during user interface generation. This paper presents a Polymorphic Logical Description (PLD) for achieving user centric, multi-device interfaces. An authoring environment, named Custom-MADE (CoMADE) was developed based on PLD for discrete and automatic generation of user centric, multi-device interfaces. User tasks are given a polymorphic description and their relationships are represented and persisted as objects. A user interface is composed based on an explicit user model and real time user preference information. Design, load and runtime are managed by CoMADE. With these, we achieved user centric, multi-device interfaces generation with a high degree of flexibility and direct user participation.

A CMOS image sensor (CIS)-based gaze estimation processor (GEP) is proposed for the next generation user interface (UI) of the smart glasses. It integrates a functional CMOS image sensor (CIS), a RISC, and an ellipse fitting engine (EFE) on a single chip to reduce the power consumption. The functional CIS includes mixed-signal pre-processing circuits, pupil edge detection circuit (PEDC) and glint corner detection circuit (GCDC). Logarithmic processing elements (LPE) is used for EFE to reduce the power consumption further. As a result, PEDC/GCDC and LPE can reduce overall power by 55.2% and 14.1%, respectively. Implemented in 65nm CMOS technology, the 11.29mm2 chip consumes 10mW power at 30fps real-time operation, and 0.5° error is achieved in a glass-type wearable system.

We are surrounded by different smart networked embedded devices that are running software dedicated to specific tasks. Many of these devices have no displays or user interfaces. To control and configure these devices remotely over network, instead of running factory-set static settings, devices need to be able to publish their parameters to a remote user interface of the system. In modular systems, the components of the system also need to communicate with each other to ensure interoperability. In this paper we introduce eXtensible Configuration Description (XCD) that defines the characteristics of a device or system component as variables and their interrelationships in a unified format. XCD allows devices to exchange information about their configuration with other devices (machine-to-machine, M2M), or to publish the configuration to a generic remote user interface (UI) of the system. The paper describes the structure of XCD and shows two use cases where the description is used to configure an embedded system. We also show how the generic nature of XCD enables us to render the same XCD description of a device in two different user interfaces.

The goal of this paper is to introduce an approach to user interface (UI) reuse by means of concrete interaction patterns (CIPs) usage. A CIP extends the usual interaction pattern documentation describing interactions and user interface behaviour through User Interface Description Language (UIDL), allowing reuse and implementation of an abstract user interface to different platforms and technologies.

Declarative models play an important role in most software design activities, by allowing designs to be constructed that selectively abstract over complex implementation details. In the user interface setting, Model-Based User Interface Development Environments (MB-UIDEs) provide a context within which declarative models can be constructed and related, as part of the interface design process. However, such declarative models are not usually directly executable, and may be difficult to relate to existing software components. It is therefore important that MB-UIDEs both fit in well with existing software architectures and standards, and provide an effective route from declarative interface specification to running user interfaces. This paper describes how user interface software is generated from declarative descriptions in the Teallach MB-UIDE. Distinctive features of Teallach include its open architecture, which connects directly to existing applications and widget sets, and the generation of executable interface applications in Java. This paper focuses on how Java programs, organized using the model-view-controller pattern (MVC), are generated from the task, domain and presentation models of Teallach.

User interface description languages (UIDL) are high-level languages allowing to model user interfaces (UI). Their purpose is to ease the design of UIs. They are widely used, including to develop critical interactive systems. Nevertheless, the problem of verifying systems developed with UIDLs is barely addressed in the literature. The first step is to provide a formal semantics using an appropriate theory. We claim that the bigraphs theory is a good candidate theory. In this short paper, presenting a work in progress, we introduce the common features of UIDLs and show how bigraphs could be used to define UIDLs semantics and help with UI verification.KeywordsUser Interface Description LanguageGraphical user interfacesFormalisationBigraphs