Search

Usability evaluation is an essential task in web application development. There have been several attempts to integrate user-centered design with agile methods, but it is hard to synchronize their practices. User testing is very valuable to learn from feedback of actual use, but it remains expensive to find and solve usability problems. Furthermore, the high cost of usability evaluation forces small/medium-sized companies to trust the first solution applied, without actually testing the success of the solution or considering a possible regression in usability, as could be highlighted by an iterative testing method. In this article we advocate for a usability improvement cycle oriented by user feedback, and compatible with an agile development process. We propose an iterative method supported by a toolkit that allows usability experts to design user tests, run them remotely, analyze results, and assess alternative solutions to usability problems similarly to A/B testing. Each solution is created by applying client-side web refactorings, i.e., changes to the web pages in the client which are meant to improve usability. The main benefit of our approach is that it reduces the overall cost of user testing and particularly, A/B testing, by applying refactorings to create alternative solutions without modifying the application’s server code. By making it affordable for usability experts to apply the method in parallel with the development cycle, we aim to encourage them to incorporate user feedback and try different ideas to discover the best performing solution in terms of the metrics of interest., Laboratorio de Investigación y Formación en Informática Avanzada

En este trabajo de tesis se describirá una técnica de modelado centrado en mockups, introduciéndola primero con MockupDD Web. Luego de haber ejemplificado el desarrollo centrado en mockups para metodologías MDWE, se describirá un marco general para el modelado sobre mockups (lo que se referenciará como metodología MockupDD general) y una instanciación particular de esta metodología además de la ya presentada para la Web. Las principales contribuciones de la metodología MockupDD y sus especializaciones son: (1) Mejorar el workflow en cascada de las metodologías MDD tradicionales (en especial, aquellas MDWE) para permitir acortar las iteraciones y permitir a usuarios finales y clientes involucrados interactuar más rápidamente son el software generado, agilizando el proceso. (2) Mejorar la productividad en el modelado de aplicaciones a través de la técnica de modelado de aplicaciones sobre mockups reduciendo sus errores y tiempo requerido, como se mostrará luego en las secciones de validación (3) Introducir a clientes y usuarios finales en el proceso de desarrollo, utilizando artefactos de especificación de requerimientos de fácil comprensión para los mismos en lugar de conceptos de modelado comprensibles sólo para desarrolladores. En este contexto se utilizarán mockups y diferentes técnicas de anotación y especificación de requerimientos formales sobre los mismos. (4) La implementación de un lenguaje de modelado sobre mockups con diferentes vistas, satisfaciendo al mismo tiempo la necesidad de comprensión de requerimientos por parte de los usuarios finales y las capacidades técnicas requeridas por los desarrolladores. (5) Con ayuda de esta versatilidad del lenguaje y del uso de mockups (los cuales son comprensibles en su totalidad por usuarios finales), proveer un método de modelado más trazable desde el punto de vista de los requerimientos., Facultad de Informática

In modern software development, much time is devoted and much attention is paid to the activity of data modeling and the translation of data models into databases. This has motivated the proposal of different approaches and tools to support this activity, such as semiautomatic approaches that generate data models from requirements artifacts using text analysis and sets of heuristics, among other techniques. However, these approaches still suffer from important limitations, including the lack of support for requirements traceability, the poor support for detecting and solving conflicts in domain-specific requirements, and the considerable effort required for manually checking the generated models. This paper introduces DataMock, an Agile approach that enables the iterative building of data models from requirements specifications, while supporting traceability and allowing inconsistencies detection in data requirements and specifications. The paper also describes how the approach effectively allows improving traceability and reducing errors and effort to build data models in comparison with traditional, state-of-the-art, data modeling approaches., Laboratorio de Investigación y Formación en Informática Avanzada

Agile approaches, one of the key methodologies used in today’s software projects, often rely on user interface mockups for capturing the goals that the system must satisfy. Mockups, as any other requirement artifact, may suffer from ambiguity and contradiction issues when several points of view are surveyed/elicited by different analysts. This article introduces a novel approach that enhances mockups with friendly end-user annotations that helps formalizing the requirements and reducing or identifying conflicts. We present an evaluation of the approach in order to measure how the use of annotations improves requirements quality.

Mobile devices have become the most prominent channel to access Web applications. While every mobile device platform like Android or iOS has their own application ecosystem, they are also often used to access Web sites which are not property rendered in such devices. Adapting existing sites to be usable on this kind of devices (with a reduced viewport), techniques like Responsive Design and Progressive Web Applications have appeared, proposing guidelines and good practices to cope with device interface limitations. However, these techniques require a notable engineering effort and cost to adapt sites to be mobile-friendly. In this work, we present an approach and tool that allows to quickly adapt an existing Web application to be usable for mobile devices. The approach does not require to redesign its frontend and can be applied even without having control of the servers in which the application is hosted since we use a client-side approach. To assess its applicability, a controlled experiment has been carried out in which we evaluated the usability of the adapted sites.

Usability assessment of web applications continues to be an expensive and often neglected practice. While large companies are able to spare resources for studying and improving usability in their products, smaller businesses often divert theirs in other aspects. To help these cases, researches have devised automatic approaches for user interaction analysis, and there are commercial services that offer automated usability statistics at relatively low fees. However, most existing approaches still fall short in specifying the usability problems concretely enough to identify and suggest solutions. In this work we describe usability smells of user interaction, i.e., hints of usability problems on running web applications, and the process in which they can be iden tified by analyzing user interaction events. We also describe USF, the tool that implements the process in a fully automated way with minimum setup effort. USF analyses user interaction events on-the-fly, discovers usability smells and reports them together with a concrete solution in terms of a usability refactoring, providing usability advice for deployed web applications., Laboratorio de Investigación y Formación en Informática Avanzada

Model-Driven Web Engineering (MDWE) approaches aim to improve the Web applications development process by focusing on modeling instead of coding, and deriving the running application by transformations from conceptual models to code. The emergence of the Interaction Flow Modeling Language (IFML) has been an important milestone in the evolution of Web modeling languages, indicating not only the maturity of the field but also a final convergence of languages. In this paper we explain the evolution of modeling and design approaches since the early years (the 90’s) detailing the forces which drove that evolution and discussing the strengths and weaknesses of some of those approaches. A brief presentation of IFML is accompanied with a thorough analysis of the most important achievements of the MDWE community as well as the problems and obstacles that hinder the dissemination of model-driven techniques in the Web engineering field., Laboratorio de Investigación y Formación en Informática Avanzada (LIFIA)

Web Applications are accessed by millions of users with different needs, goals, concerns or preferences. Several well-known Web Applications provide personalized features, e.g. they recommend specific content to users by contemplating individual characteristics or requirements. However, since most Web Application cannot consider all users? requirements, many developers started to create their own mechanisms for adapting existing applications. One of the most popular techniques for third party applications adaptation is Web Augmentation, which is based on the alteration of its original user interface, generally by using scripts running at the client-side (e.g. the browser). In the context of Web Augmentation, two user roles have emerged: scripters who are those users able to create a new augmentation artefact, and end-users without programming skills, that just consume the artefacts that may satisfy totally or partially their needs. Scripters and end-users generally do not know each other and they have rarely a contact, beyond the fact that they use the same script repositories. When end-users cannot get their needs covered with existing artefacts, they claim for new ones by specifying their requirements (called Web Augmentation requirements) using textual descriptions, which are usually hard to interpret by scripters. Web Augmentation requirements are a very particular kind of Web requirements for which there partially exist a solution implemented by the Web site owner, but still users need to change or augment that implementation with very specific purposes that they desire to be available in such site. In this paper, we propose an approach for defining and evolving Web Augmentation requirements using rich visual prototypes and textual descriptions that can be automatically mapped onto running software artefacts. We present a tool implemented to support this approach and we show an evaluation of both the approach and the tool. Fil: Firmenich, Diego. Universidad Nacional de la Plata. Facultad de Informática. Laboratorio de Investigación y Formación en Informática Avanzada; Argentina. Universidad Nacional de la Patagonia; Argentina Fil: Firmenich, Sergio Damian. Universidad Nacional de la Plata. Facultad de Informática. Laboratorio de Investigación y Formación en Informática Avanzada; Argentina. Consejo Nacional de Investigaciones Científicas y Técnicas; Argentina Fil: Rivero, José Matías. Universidad Nacional de la Plata. Facultad de Informática. Laboratorio de Investigación y Formación en Informática Avanzada; Argentina. Consejo Nacional de Investigaciones Científicas y Técnicas; Argentina Fil: Antonelli, Leandro. Universidad Nacional de la Plata. Facultad de Informática. Laboratorio de Investigación y Formación en Informática Avanzada; Argentina Fil: Rossi, Gustavo Héctor. Universidad Nacional de la Plata. Facultad de Informática. Laboratorio de Investigación y Formación en Informática Avanzada; Argentina

Model Driven development approaches are being adopted by the software industry due to a core set of benefits such as raising the level of abstraction and reducing coding errors. However, their underlying modelling languages tend to be quite rigid, making their evolution hard, specifically when the corresponding metamodel do not support primitives and/or functionalities required in specific business domains. In this work, we present an approach for fast evolution of the modelling language that is “self reflective”, allowing modellers to abstract new language concepts from the primitives. The main advantage of our approach is that it provides zero application downtime and automatic tool evolution. As a consequence, applications created with our approach are able to adapt quicker to the business needs than those based on traditional Web modelling languages. We compare our approach with existing modelling languages in a case study providing a proof of its ability to adapt faster than to new business needs. Ministerio de Ciencia e Innovación TIN2013-46928-C3-3-R

Context Agile software development approaches are currently becoming the industry standard for Web Application development. On the other hand, Model-Driven Web Engineering (MDWE) methodologies are known to improve productivity when building this kind of applications. However, current MDWE methodologies tend to ignore important aspects of Web Applications development supported by agile processes, such as constant customer feedback or early design of user interfaces. Objective In this paper we analyze the difficulties of supporting agile features in MDWE methodologies. Then, we propose an approach that eases the incorporation of well-known agile practices to MDWE. Method We propose using User Interface prototypes (usually known as mockups) as a way to start the modeling process in the context of a mixed agile-MDWE process. To assist this process, we defined a lightweight metamodel that allows modeling features over mockups, interacting with end-users and generating MDWE models. Then, we conducted a statistical evaluation of both approaches (traditional vs. mockup-based modeling). Results First we comment on how agile features can be added to MDWE processes using mockups. Then, we show by means of a quantitative study that the proposed approach is faster, less error-prone and still as complete as traditional MDWE processes. Conclusion The use of mockups to guide the MDWE process helps in the reduction of the development cycle as well as in the incorporation of agile practices in the model-driven workflow. Complete MDWE models can be built and generated by using lightweight modeling over User Interface mockups, and this process suggests being more efficient, in terms of errors and effort, than traditional modeling in MDWE. Fil: Rivero, José Matías. Consejo Nacional de Investigaciones Científicas y Técnicas; Argentina. Universidad Nacional de la Plata. Facultad de Informática. Laboratorio de Investigación y Formación en Informática Avanzada; Argentina Fil: Grigera, Julian. Universidad Nacional de la Plata. Facultad de Informática. Laboratorio de Investigación y Formación en Informática Avanzada; Argentina Fil: Rossi, Gustavo Héctor. Consejo Nacional de Investigaciones Científicas y Técnicas; Argentina. Universidad Nacional de la Plata. Facultad de Informática. Laboratorio de Investigación y Formación en Informática Avanzada; Argentina Fil: Robles Luna, Esteban. Universidad Nacional de la Plata. Facultad de Informática. Laboratorio de Investigación y Formación en Informática Avanzada; Argentina. Provincia de Buenos Aires. Gobernación. Comisión de Investigaciones Científicas; Argentina Fil: Montero, Francisco. LoUISE Research Group. Madrid; España Fil: Gaedke, Martin. Chemnitz University of Technology; Alemania

The scalability of modern Web applications has become a key aspect for any business in order to support thousands of concurrent users while reducing its computational costs. If a Web application does not scale, a few hundred users can take the application down and as a consequence cause business problems in their companies. In addition, being able to scale a Web application is not an easy task, as it involves many technical aspects such as architecture design, performance, monitoring and availability that are completely ignored by current Model Driven Web Engineering approaches. In this paper we present a model-based approach that uses runtime transformations for overcoming scalability problems in the applications derived from them. We present our approach by “scaling up” a WebML application under a stress scenario, proving that it provides a “framework” for overcoming scalability issues.

Web augmentation has emerged as a technique for customizing Web applications beyond the personalization mechanisms natively included in them. This technique usually manipulates existing Web sites on the client-side via scripts (commonly referred as userscripts) that can change its presentation and behavior. Large communities have surfaced around this technique and two main roles have been established. On the one hand there are userscripters, users with programming skills who create new scripts and share them with the community. On the other hand, there are users who download and install in their own Web Browsers some of those scripts that satisfy their customization requirements, adding features that the applications do not support out-of-the-box. It means that Web augmentation requirements are not formally specified and they are decided according to particular userscripters needs. In this paper we propose CrowdMock, a platform for managing requirements and scripts. The platform allows users to perform two activities: (i) specify their own scripts requirements by augmenting Web sites with high-fidelity mockups and (ii) upload these requirements into an online repository. Then, the platform allows the whole community (users and userscripters) to collaborate improving the definition of the augmentation requirements and building a concrete script that implements them. Two main tools have been developed and evaluated in this context. A client-side plugin called MockPlug used for augmenting Web sites with UI prototype widgets and UserRequirements, a repository enabling sharing and managing the requirements.

The refactoring technique helps developers to improve not only source code quality, but also other aspects like usability. The problems refactoring helps to solve in the specific field of web usability are considered to be issues that make common tasks complicated for end users. Finding such problems, known in the jargon as bad smells, is often challenging for developers, especially for those who do not have experience in usability. In an attempt to leverage this task, we introduce a tool that automatically finds bad usability smells in web applications. Since bad smells are catalogued in the literature together with their suggested refactorings, it is easier for developers to find appropriate solutions.

The implementation of APIs in new applications is becoming a mandatory requirement due to the increasing use of cloud-based solutions, the necessity of integration with ubiquitous applications (like Facebook or Twitter) and the need to facilitate multi-platform support from scratch in the development. However, there is still no theoretically sound process for defining APIs (starting from end-user requirements) or their productive development and evolution, which represents a complex task. Moreover, high-level solutions intended to boost productivity of API development (usually based on Model-Driven Development methodologies) are often difficult to adapt to specific use cases and requirements. In this paper we propose a methodology that allows capturing requirements related to APIs using end-user-friendly artifacts. These artifacts allow quickly generating a first running version of the API with a specific architecture, which facilitates introducing refinements in it through direct coding, as is commonly accomplished in code-based Agile processes.

Model-Driven Web Engineering (MDWE) methodologies have proven to be a mature way of developing web applications, dramatically increasing productivity during development. However, after more than a decade of evolution, the artifacts and processes used to gather requirements have not changed substantially. At the same time, the capacity of quickly adapting to emergent domain-specific requirements (a feature that became popular with the massive adoption of agile approaches) has become hard to achieve in these methodologies. In this context, in order to implement this kind of refined requirements as fast as possible, changes are usually applied directly to the generated application, losing the abstraction and its inherent productivity provided by the Model-Driven process. Another way of implementing this kind of changes is by extending the modeling language, but this implies a high effort and, again, a consequent productivity loss. In this paper we propose a model-driven development approach called MockRE that captures requirements using User Interface prototypes (mockups) that end-users can understand completely. The process and tooling presented here allows end-users to express requirements annotating the mockups with textual descriptions, and also generating a running application in the same way that MDWE environments do. Developers may later use these initial specifications placed by end-users as valuable model concepts that can be refined through direct coding in a non-intrusive way. Through this strategy, MockRE intends to make a more extensive reuse of end-users specifications throughout the whole developing process.

In the last years, agile development methodologies have been widely adopted. However, they still lack support for API requirements while, at the same time, public RESTful APIs are fueling a rapid growth of web applications providing services built on other services. On the other hand, whereas Model-Driven Development techniques successfully increase the productivity in the development of data-intensive web applications, they lack the agility required when developing heterogeneous web applications with frequent requirement changes. In this paper we introduce MockAPI, an approach based on annotating user interface mockups that combines the advantages of agile approaches and Model-Driven Development. We introduce a metamodel for annotations and demonstrate how to derive running API prototypes as starting point for agile development. RESTful API best practices and API-first development are introduced into the agile process. The MockAPI approach defines a set of constraints to accelerate the development of web applications. We also show the results of a brief validation applying MockAPI to popular web sites.

Model-Driven Web Engineering methodologies provide a more productive way of building Web Applications using high-level models and generating final implementations from them. However, they follow a waterfall-like development process, forcing to specify a different set of models sequentially to obtain a first runnable prototype of the Web Application. On the other hand, agile methodologies pursue an iterative process based on the delivery of application prototypes in short periods of time using manual coding, which results less productive and more error-prone in comparison to model-based approaches. In this work we propose a hybrid agile and Model-Driven approach called MockupDD that intends to blend the best of MDWE and agile development processes.

Web applications are hard to build not only because of technical reasons but also because they involve many different kinds of stakeholders. Involving customers in the development process is a must, not only while eliciting requirements but also considering that requirements change fast and they must be validated continuously. However, while model-driven approaches represent a step forward to reduce development time and work at a higher level of abstraction, most of them practically ignore stakeholders' involvement. Agile approaches tend to solve this problem, though they generally focus on programming rather than modeling. In this paper we present an extension to an approach that combines the best of both worlds, allowing a formal and high-level design style with constant involvement of customers, mainly in the definition of navigation, interaction and interface features. We extended it by adding transformation features that allow mapping requirement models into content and navigation ones. We provide a proof of concept in the context of the WebML design method and an empiric validation of the approach's advantages.

The increasing growth of the Web field has promoted the development of a plethora of Model-Driven Web Engineering (MDWE) approaches. These methodologies share a top-down approach: they start by modeling application content, then they define a navigational schema, and finally refine the latter to obtain presentation and rich behavior specifications. Such approach makes it difficult to acquire quick feedback from customers. Conversely, agile methods follow a non-structured, implementation-centered process building software prototypes to get immediate feedback. In this work we propose an agile approach to MDWE methodologies (called Mockup-Driven Development, or MockupDD) by inverting the development process: we start from user interface mockups that facilitate the generation of software prototypes and models, then we enrich them and apply heuristics in order to obtain software specifications at different abstraction levels. As a result, we get an agile prototype-based iterative process, with advantages of a MDWE one.

The process of modeling and implementing Web applications has been successfully improved by the use of Model-Driven Web Engineering (MDWE) methodologies. However, because of their traditional process models, these methodologies delay the generation of application prototypes until all design aspects (e.g. domain and navigation) are completed. These aspects are crucial for developers but not for customers, who are interested in viewing parts of the application running as early as possible. In this paper we introduce a novel model driven approach that starts from user interface specifications, using mockups to derive concrete presentation implementations -- we call it Mockup-Driven Development or just MockupDD. Then, by using lightweight enrichments and applying heuristics over these models, we show how we obtain navigation and content specifications in the context of different MDWE methods.

Sketching web applications with mockup tools is a common practice that improves the process of elicitation and validation of requirements in web applications. However, mockups are used as a "quick and dirty" way of gathering requirements, thus discarded before development. As a consequence, concepts captured in them are usually lost in the manual transformation between mockups and the final user interface. In this paper we present a model-driven approach that overcomes this problem by importing mockups and then transforming them into a technology-dependent model. Development then begins from the imported version of the mockups.

Model-driven web engineering approaches have become an attractive research and technology solution for Web application development. However, after 20 years of development, they have attracted little attention from the Industry due to the mismatch between technical versus research requirements. In this joint work between academia and industry, the authors present the current problems of using these approaches in scale and provide guidelines to convert them into viable industry solutions. Ministerio de ciencia e Innovación TIN2016-76956-C3-2-R Ministerio de Economía y Competitividad TIN2015-71938-REDT

International audience