Nathalie Aquino

Model-Driven Development

The model-driven architecture (MDA) paradigm is well-known and widely used in the field of model-based software development. However, there are still some issues that are problematic and that need to be dealt with carefully. In this paper we present a metaphor that explains how MDA grows in complexity as problems faced become more difficult or “wicked”, and how a method designed to be powerful, flexible and MDA-compliant can eventually become, in effect, a “jigsaw puzzle”. This jigsaw puzzle is not merely the result of having a collection of methodological “pieces” with routes across them, but also arises as a result of the criteria underlying the MDA abstraction layers. We compare MDA to other research fields such as human-computer interaction, model management and method engineering, and we use as an example the OO-Method, a software development method based on MDA-compliant model transformations. We focus on a methodological piece that is conceived to allow the specification of interaction requirements by means of interface sketches. These sketches are supported by a task model that serves as a sound basis for formalisation and allows the application of model transformation in order to obtain subsequent models. A case study illustrates the requirements capture method together with the software development process defined by the OO-Method. The whole process presented in the case study represents one of the possible routes that can be followed when developing a software system with the OO-Method.

Usability evaluation of multi-device/platform user interfaces generated by model-driven engineering

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 Friedmans 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.

Understandability measurement in an early usability evaluation for model-driven development: an empirical study

Traditionally, usability has been evaluated taking into account the users satisfaction when interacting with the software system. However, in a Model-Driven Development (MDD) process, where conceptual models are the main resource for software system generation, the usability can potentially be evaluated at earlier stages. This work goes one step further proposing that certain usability attributes, specifically internal understandability attributes, can be measured from Conceptual Models. This work presents an empirical study carried out to evaluate the proposal. The goal of this study is to evaluate whether the value measured using our proposal is related to the understandability value perceived by the end user. From the analysis of the empirical results obtained, several weaknesses of the proposal are stated.

Conceptual Modelling of Interaction

The conceptual model of an information system cannot be considered to be complete after just specifying the structure and behaviour of the system. It is also necessary to specify how end users will interact with the system. Even though there are several proposals for modelling interaction, none of them have become widely known or widely used in academia and industry. After illustrating the state of the art in this field, this chapter briefly presents a practical approach with the aim of showing how interaction modelling can be faced. The presented approach is called OO-Method, a Model-Driven Engineering method that allows full functional systems to be generated from a conceptual model. The chapter explains how OO-Method supports the interaction modelling by means of its Presentation Model. Apart from this description, the chapter comments on some limitations of the presentation model to satisfy end user interaction requirements related to preferences and different contexts of use. This problem is faced by distinguishing an abstract and a concrete level for interaction modelling. The abstract perspective focuses on what must be presented to end users in order to allow their interaction with an information system, and the concrete perspective focuses on how those elements are presented.

Using Profiles to Support Model Transformations in the Model-Driven Development of User Interfaces

The model-driven User Interface (UI) development life cycle usually evolves from high-level models, which represent abstract UI concepts, to concrete models, which are more related to the UI implementation details, until the final UI is generated. This process is based on a set of model-to-model and model-to-code transformations. Several industrial tools have applied this approach in order to generate the UI. However, these model transformations are mainly fixed and are not always the best solution for a specific UI. In this work, the notion of Transformation Profile is introduced to better specify the model-to-model transformations. A Transformation Profile is made up of a set of predefined Model Mappings and a Transformation Template. The mappings connect initial and target UI models in a flexible way, whereas the Transformation Template gathers high-level parameters to apply to the transformation. As a consequence, a Transformation Profile enables designers to define parameterized transformations that could be reused for another UI development project.

Towards an Early Usability Evaluation for Web Applications

In the Human-Computer Interaction (HCI) community, the usual way to measure usability is through a user test. The disadvantage of this way is that the system must be implemented before performing the test. As a consequence, developers must solve the usability issues in the last stages of the development process. Currently, the model-driven software development is gaining popularity as a solution to reduce changes impact. In this paper, a usability model is proposed to evaluate early usability from the conceptual schemas that represents a Web Application. This approach allows to incorporate usability improvements before the implementation of the final web application. We evaluate the usability of artefacts modelled with OOWS, a model-driven web engineering method. In addition, two case studies are used to verify the instruments proposed to evaluate our early usability model.

Early Usability Measurement in Model-Driven Development: Definition and Empirical Evaluation

Usability is currently a key feature for developing quality systems. A system that satisfies all the functional requirements can be strongly rejected by end-users if it presents usability problems. End-users demand intuitive interfaces and an easy interaction in order to simplify their work. The first step in developing usable systems is to determine whether a system is or is not usable. To do this, there are several proposals for measuring the system usability. Most of these proposals are focused on the final system and require a large amount of resources to perform the evaluation (end-users, video cameras, questionnaires, etc.). Usability problems that are detected once the system has been developed involve a lot of reworking by the analyst since these changes can affect the analysis, design, and implementation phases. This paper proposes a method to minimize the resources needed for the evaluation and reworking of usability problems. We propose an early usability evaluation that is based on conceptual models. The analyst can measure the usability of attributes that depend on conceptual primitives. This evaluation can be automated taking as input the conceptual models that represent the system abstractly.

Adding flexibility in the model-driven engineering of user interfaces

Model-based user interface (UI) development environments are aimed at generating one or many UIs from a single model or a family of models. Model-driven engineering (MDE) of UIs is assumed to be superior to those environments since they make the UI design knowledge visible, explicit, and external, for instance as model-to-model transformations and model-to-code compilation rules. These transformations and rules are often considered inflexible, complex to express, and hard to develop by UI designers and developers who are not necessarily experts in MDE. In order to overcome these shortcomings, this work introduces the concept of transformation profile that consists of two definitions: model mappings, which connect source and target models in a flexible way, and transformation templates, which gather high-level parameters to apply to transformations. This work applies these concepts in a general-purpose method for MDE of information systems. Transformation profiles can be effectively and efficiently used in any circumstances in which transformation knowledge needs to be modified by non-experts, and flexibility, modifiability, and customization are required.

Dealing with Abstract Interaction Modeling in an MDE Development Process: A Pattern-Based Approach

Currently, in the Model-Driven Engineering (MDE) community, there is not any standard model to define the interaction between the user and the software system. However, the Human–Computer Interaction (HCI) community has been recently dealing with this issue. A widely accepted proposal is the specification of the interaction at two levels or views: an Abstract Level, in which the User Interface (UI) is defined without taking into account any technological details, and a Concrete Level, in which the previous abstract models are extended with the information related to the target technology. The purpose of this chapter is to introduce the Abstract Level into the OO-Method MDE development process. Specifically, this chapter is focused on how the abstract interaction can be modeled by means of Abstract Interaction Patterns (AIPs). These patterns define a generic solution for an interaction between a user and an Information System (IS), without considering the technological details related to the final UI. In order to illustrate the approach, two AIPs are described.

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.