This paper discusses the main concepts and relationships for the Non-Functional Requirements (NFRs) domain ontology, which is placed at the top-domain level in the framework of a five-level ontological architecture. In this (ontological) context, the term Non-Functional Requirement (NFR) does not model a particular thing (concrete entity), but rather a quality-, constraint-related assertion of a certain aspect of the thing to be evaluated. Also, an NFR as a human assertion can deal with a thing category as a universal abstraction. Thus, the quality aspect attributed, for example, to a particular thing (as a class or its individuals) can refer to its parts, such as the properties and/or capabilities of the entity, or the entity as a whole. To better understand the concepts and relationships of NFRs, a basic background in the semantics of the foundational concepts such as Thing, Thing Category, and Assertion is needed. Furthermore, to validate the applicability of the ontological conceptualization of NFRs, a set of typical cases for different practical situations is showcased.

Virtual assistants allow users to interact with apps using a conversational mode. A particular kind of device supporting virtual assistants is the smart speaker, which allows end users to access contents and services, perform searches and command smart environments via voice interaction. These devices are gaining relevance among users, and the number of apps available for giving them more conversational capabilities grows constantly. However, there is a gap between what can be achieved using these devices and the information available on the web, i.e. most web apps don't have one smart speaker app counterpart. In this work, we present a two-step approach to defining conversational interfaces for virtual assistants based on existing web sites. During the first step, the user creates web content blocks, which describe target contents and the strategy for retrieving them. In the second step, the user uses web content blocks to specify the conversational interface. Although the approach could be considered generic enough for any kind of conversational interface, we focus our research on voice user interfaces, considering smart speaker apps as a major target. With our approach, apps based on voice user interfaces for smart speakers may be developed in a no-code manner. We describe and illustrate the approach by presenting usage examples and an evaluation using the Alexa service and an Amazon Echo device. The evaluation shows promising results for two case studies where there is no significant difference between the user experience when comparing solutions developed using the Alexa SDK versus apps using our approach.

Nowadays, Web browser extensions are the more convenient way to modify existing Web applications and the browser itself to satisfy non-contemplated requirements. Extensions play an important role because of the relevance that the Web and the Web browser have in our daily life. The functionality offered by Web extensions varies. Many Web extensions are tools that improve the interaction with existing Web sites based on techniques such as mashups and Web augmentation. Accessing and manipulating Web sites’ content is a challenge for the development and maintenance of extensions. In this paper, we present a data service layer that allows extension developers to create APIs based on Web annotations to access existing Web content. The data service layer simplifies the retrieval of structured information from Web pages, without the need of DOM manipulation in the extension code. We provide visual programming tools to create these APIs so there is no need for advanced programming skills, making extension development and maintenance easier.

There is a lack of automatic evaluation models to measure the user experience (UX) of online systems, especially in relation to the user interaction. In this paper we propose the interaction effort score as a factor that contributes to the measure of the UX of a web page. The interaction effort is automatically computed as an aggregation of the effort on each interactive widget of a page, and for all users that have interacted with them.\nIn turn, the effort on each widget is predicted from different micro-measures computed on the user interaction, by learning from manual UX expert ratings. This paper describes the evaluation of the interaction effort of different web forms, and how it compares to other metrics of usability and user interaction. It also shows possible applications of the interaction effort score in the automatic evaluation of web pages.

Continuous Delivery is a practice where high-quality software is built in a way that it can be released into production at any time. However, systematic literature reviews and surveys performed as part of this Doctoral Research report that both the literature and the industry are still facing problems related to testing using practices like Continuous Delivery or Continuous Deployment. Thus, we propose Continuous Testing Improvement Model (CTIM) as a solution to the testing problems in continuous software development environments. It brings together proposals and approaches from different authors which are presented as good practices grouped by type of tests and divided into four levels. These levels indicate an improvement hierarchy and an evolutionary path in the implementation of Continuous Testing. Also, an application called EvalCTIM was developed to support the appraisal of a testing process using the proposed model. Finally, to validate the model, an action-research methodology was employed through an interpretive theoretical evaluation followed by case studies conducted in real software development projects. After several improvements made as part of the validation outcomes, the results demonstrate that the model can be used as a solution for implementing Continuous Testing gradually at companies using Continuous Deployment or Continuous Delivery and measuring its progress.

Abstract In the past decades recommender systems have become a powerful tool to improve personalization on the Web. Yet, many popular websites lack such functionality, its implementation usually requires certain technical skills, and, above all, its introduction is beyond the scope and control of end-users. To alleviate these problems, this paper presents a novel tool to empower end-users without programming skills, without any involvement of website providers, to embed personalized recommendations of items into arbitrary websites on client-side. For this we have developed a generic meta-model to capture recommender system configuration parameters in general as well as in a web augmentation context. Thereupon, we have implemented a wizard in the form of an easy-to-use browser plug-in, allowing the generation of so-called user scripts, which are executed in the browser to engage collaborative filtering functionality from a provided external rest service. We discuss functionality and limitations of the approach, and in a study with end-users we assess the usability and show its suitability for combining recommender systems with web augmentation techniques, aiming to empower end-users to implement controllable recommender applications for a more personalized browsing experience.

Usability and user interaction improvement is a central task in web development to guarantee the success of a web application. However, designers are barely able to keep up with the current development cycle because their practices are too costly, while interaction issues accumulate in applications that end-users keep suffering. In this work, we propose a method for designers to rapidly explore solutions through visual programming to the interaction problems of an application under development, even when it has been already deployed. The method is realized by a tool called UX-Painter, an exploratory tool for designers to apply quick fixes to interaction issues at the client-side of a web application without the need of any script programming knowledge. The palette of available fixes in UX-Painter are client-side web refactorings, i.e., changes to web page elements that solve specific user interaction problems without changing the underlying functionality. UX-Painter allows designers to quickly set up new versions of a web application by combining refactorings to create alternative designs for user testing or an inspection review. UX-Painter also provides the means to communicate design improvements, as a sequence of refactorings with clear semantics. We show the feedback provided by interviews with designers about UX-Painter's functionality and the results of a user test about its usability.

The emergence of Web personalization allowed introducing improvements to an application that runs as a black box just considering those perceivable behaviors by the end-user. In spite of which mechanisms (personalization, customization, etc.) that a particular application supports; it is not realistic to state that any application, being idealized by few people (e.g., its owners), covers every single user´s needs. In this sense, users may have unsatisfied requirements. Nowadays available Web augmentations are making full use of server-side capabilities for meeting requirements. We present a Web Augmentation modeling approach contemplating a client-server application that hides the back-end complexity to users. In this work we present a Web CASE tool to model server-side behavior for Web augmentation. This tool provides a full web-based experience for designing and running Web augmentations that requires client and server-side components.

Client-Side Web Refactorings (CSWRs) allow improving interaction aspects of web applications by applying changes to the user interface without altering the code base, even in production settings. However, developers are not always willing, or even allowed to apply external adaptations to their applications’ user interface. Besides, CSWRs do not guarantee improvements in all contexts, so it may be unwise to install them in a production version. We propose a tool that allows creating private versions of a running web application almost automatically. Using this tool, developers or usability experts can easily combine CSWRs to create alternative versions of web applications, without the need of creating a cloned sandbox environment for each version. This yields many uses, such as quickly setting up user tests, showing live alternatives to Product Owners, and even performing A/B testing. The tool is built on top of Kobold, a service that allows applying CSWRs to fix usability smells. Kobold with versioning is available at: https://autorefactoring.lifia.info.unlp.edu.ar. A screencast of the tool is available at https://youtu.be/LVc3BOtVP3I.

The identification and specification of the requirements of a software system is a difficult task that has the goal of obtaining requirements as correct and complete as possible.It is extremely important that Requirements Engineers understand a domain language in order to write high-quality requirements.Moreover, they must describe (and discuss) the language in a collaborative way in order to consider the different points of view of all stakeholders to assure that the resulting requirements will have more chances to meet their needs.However, collaborative construction implies the occurrence of conflicts that are unavoidable because of ambiguity, overlapping and misunderstanding natural language descriptions.This article relies on the Language Extended Lexicon in order to describe the application domain.Although it is a semi-structured glossary and this characteristic helps to reduce the conflicts, our experience shows that conflicts arise anyway.Thus, in order to mitigate this problem, this article presents a catalogue with a set of conflicts that could appear during a collaborative construction of the Language Extended Lexicon and proposes alternatives for their resolution.

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

Summary Web applications must quickly adapt to new business demands to keep clients onboard. When unexpected and unforeseen requirements appear, the changes pose challenges to software engineers as they were not considered in the application design and such new functionality can be only valid only for a period in certain situations. This work presents a comparison of maintenance consequences in the software quality when using a Model‐Driven approach against a Code‐Based one where changes are managed in an ad hoc way. We used the removal of volatile functionality as case of study due to the fact that its characteristics stress the development process. We considered both external and internal quality of deliverables. For assessing the quality of deliverables, we evaluated the production of more than 35 students using both approaches considering their perception gathered through questionnaires and their deliverables. We present the preliminary evidence that there is no significant difference between approaches. Model‐Driven performed slightly better than Code‐Based, but both responded negatively in terms of deliverables' quality. Results show that maintenance tasks are detrimental to software quality where Model‐Driven approach does not excel over Code‐Based approach. The Model‐Driven approach only highlighted on productivity.

Volunteering is an indispensable cornerstone of our society, covering nearly every part of our life, from social care to emergency management and education. This omnipresence of volunteering led to a plethora of volunteer management systems (VMS), mainly supporting NPOs in scheduling and allocating tasks to volunteers. In contrast to this NPO-centric approach of existing VMS, we focus on volunteers by investigating the following core question: "How can the engagement of volunteers be digitized and exploited in a life-long way". To provide a first step towards answering this question, the contribution of this paper is threefold. First, an in-depth study of related approaches is provided identifying shortcomings but also promising concepts. Second, challenges which have to be tackled to deal with the broad spectrum and peculiarities of volunteering are identified and a vision for a next-generation VMS called iVolunteer is pointed out. Third, promising technologies are identified and discussed in detail to lay the basis for the technical architecture of our envisioned iVolunteer-prototype.

While Web applications have become pervasive in today's business, social interaction and information exchange, their usability is often deficient, even being a key factor for a website success. Usability problems repeat across websites, and many of them have been catalogued, but usability evaluation and repair still remains expensive. There are efforts from both the academy and industry to automate usability testing or to provide automatic statistics, but they rarely offer concrete solutions. These solutions appear as guidelines or patterns that developers can follow manually. This paper presents Kobold, a tool that detects usability problems from real user interaction (UI) events and repairs them automatically when possible, at least suggesting concrete solutions. By using the refactoring technique and its associated concept of bad smell, Kobold mines UI events to detect usability smells and applies usability refactorings on the client to correct them. The purpose of Kobold is to deliver usability advice and solutions as a service (SaaS) for developers, allowing them to respond to feedback of the real use of their applications and improve usability incrementally, even when there are no usability experts on the team. Kobold is available at: http://autorefactoring.lifia.info.unlp.edu.ar. A screencast is available at https://youtu.be/c-myYPMUh0Q.

Model-Driven Web Engineering approaches have become an attractive research and technology solution for Web application development. However, for more than 20 years of development, the industry has not adopted them due to the mismatch between technical versus research requirements. In the context of this joint work between academia and industry, the authors conduct a survey among hundreds of engineers from different companies around the world and, by statistical analysis, they present the current problems of these approaches in scale. Then, a set of guidelines is provided to improve Model-Driven Web Engineering approaches in order to make them viable industry solutions.

Websites augmentations have been adopted as a mean for improving the User Experience of applications \nthat often are not owned by the user. The augmentations alter the page in order to add, modify and even \nremove its content pursuing the satisfaction of a user’s need. However, these augmentations are limited to \npage modification or transcluding content from another site on Internet. Moreover, advance server-side based \naugmentations have been released only by developers because of the required technical skill for the task. In \nthis work, we have presented a novel approach for designing Web Augmentation coping client-side and server side using a Model-Driven Web Engineering approach. The approach rises the abstraction level for server side developments allowing end-users to design, and even implement the new functionalities. Additionally, \nthe approach uses advance separation of concern principles thus we provide a set of tools for designing the \ncomposition of the core application and the augmentation. We show as running example an augmentation that \nintroduces a site community’s review support upon an agriculture e-commerce site.

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.

Estimating the size of a software system is a critical task due to the implications the estimation has in the management of the development project. There are some widely accepted estimation techniques: Function Points, Use Case Points and Cosmic Points, but these techniques can only be applied after the availability of a requirements specification. In this paper, we propose an approach to estimate the size of an application previous to its requirements specification by using the application language itself, captured by the Language Extended Lexicon (LEL). Our approach is based on Use Case Points and on a technique which derives Use Cases from the LEL. The proposed approach provides a measure of the application's size earlier than the usual techniques, thus reducing the effort needed to apply them. An initial experiment was conducted to evaluate the proposal.

Model-Driven Engineering (MDE) is becoming a widely accepted paradigm for the design and development of complex distributed applications. MDE advocates the use of models and model transformations as key artefacts in all phases of the software process, from system specification and analysis, to design, development and testing. Each model usually addresses one concern, independently from the rest of the issues involved in the construction of the system. Thus, the basic functionality of the system can be separated from its final implementation, and the business logic can be separated from the underlying platform technology, etc. Transformations between models enable the automated implementation of a system from the different models defined for it.

Requirements conciliation can result one of the most expensive and critical tasks in Web development. It particularly depends on analysts' experiences since very frequently they have to use manual solution to cope with requirements conciliation. After some previous work presenting an approach oriented towards Web requirements conciliation, this paper proposes a tool for executing this task. It is based on the Model-driven paradigm and it is included in the context of NDT (Navigational Development Techniques) methodology.

Workflows play a major role in nowadays business and therefore its requirement elicitation must be accurate and clear for achieving the closest solution to business's needs. Due to Web applications popularity, the Web is becoming the standard platform for implementing business workflows. In this context, Web applications and their workflows must be adapted to market demands in such a way to minimize development effort. In this work we present a model-driven approach for specifying Web workflows adaptations using a Domain Specific Language for Web application requirement called WebSpec. We present an extension to WebSpec based on Pattern Specifications for dealing with crosscutting workflow requirements by identifying tangled and scattered behaviour and reducing inconsistencies early in the requirement gathering phase. Using simple but illustrative examples we show the expressive power of the approach.

Web Geographic Information Systems (GIS) are systems composed by software, hardware, spatial data and computing operations, which aim to collect, model, store, share, retrieve, manipulate and display geographically referenced data. The development of online geospatial applications is currently on the rise, but this type of application often involves dealing with concerns (i.e., properties) which are inherently volatile, implying a considerable effort for system evolution. Nevertheless, geospatial concerns (e.g., temporarily blocked streets), although changeable, are reusable. However, lack of modularization in software artifacts (including system's models) can compromise reusability. In this context, the use of requirements analysis patterns, enriched with aspect-oriented modeling techniques, can support reusability and improve modularity. In this paper, we introduce requirements analysis patterns for geospatial concerns, to facilitate modularity in GIS Web applications. These patterns are generated from the domain analysis of Web GIS applications and described using a template which is supported by a comprehensive tool, enabling the completion of specific geospatial patterns.

One of the main characteristics of most Web applications is their high dynamism. Once implemented and deployed for the first time, new functionalities are added to meet new or changed requirements. Some of these functionalities may appear on the Web in response to an unexpected event, or phenomena (such as a natural calamity) after which they are removed. Some others are activated periodically, to coincide with a particular date, or period of the year (such as, return to school, Christmas holidays, etc.). Implementing such volatile functionalities usually impacts on a number of aspects of a Web application, including content, navigation, presentation, business processes, and user operations. Their cyclic activation/deactivation, which requires repetitive changes in the application code, may be the cause of waste of effort and application quality deterioration, up to incorrect functioning. In this paper, we present an approach to decouple the design and implementation of volatile functionalities from that of stable ones, i.e. the core functionalities of the application. The approach is instantiated in the context of the Object-Oriented Hypermedia Design Method (OOHDM), but its principles and related techniques are generally applicable to any other Web engineering method. We show how our approach enables the deployment and removal of these functionalities in a cost-effective and safe way and at runtime, thus providing business agility. A framework to classify volatile functionalities and a number of examples are also reported.

Business processes face constantly changing context factors like varying customer behavior or market conditions that force to adapt the underlying workflows to these evolving situations. Information overload induced by the diversity of context factors, however, leads to the inability to provide coherently modeled, comprehensible, and re-usable workflows and the failure to recognize relevant situations in time. The main goal of our research project ProFlow is to leverage situation awareness in all phases of workflow management especially focusing on dynamic spatial systems as encountered, e.g., in the domain of road traffic management. ProFlow thereby bases on a generic ontology-driven framework for situation perception and comprehension. This paper details on the corresponding ontological representations especially addressing extension points that allow developers to extend and configure our framework for their own application domains. This forms the basis for the overall system architecture, which is laid out along its prototypical implementation.

Though Web Applications development fits well with Test-Driven Development, there are some problems that hinder its success. In this demo we present a tool suite to improve TDD; the suite supports the representation of web requirements using a domain-specific language and the automatic generation of interaction tests among others.

The state of the art in location models falls short to adapt to new requirements such as composition and integration of maps. Composing and integrating maps are typical operations we want to apply when we deal with ubiquitous computing applications because they evolve permanently (i.e. to add location information of new cities, buildings, means of transport, etc.). We propose a novel approach that by abstracting some concepts such as located objects and locations, can result in more flexible models, therefore allowing dynamic composition and integration of maps. With this approach, it is also possible to combine different location representations, making applications easier to extend.

Rich Internet applications (RIAs) combine the simplicity of the hypertext paradigm with the flexibility of desktop interfaces. The quick emergence of these applications is driving a new (r)evolution in the Webfield. Building RIAs from scratch is often unfeasible because companies do not want to loose their investments in legacy Web software; additionally, most users are still accustomed to the "old" Web interaction style. In this paper we present an evolutionary approach to transform conventional Web software into RIAs; we show how to apply the well known refactoring concept to seamless introduce rich interface functionality in a Web application. By applying refactoring at the model level, we make the transition more systematic and less prone to error. We briefly introduce the problem with a simple example, and then we describe two refactorings and present our approach to specify these refactorings at the interface design level.

Mobile (or Physical) Hypermedia combines the navigational style typical of Web applications with the functionality of location and context-aware software. Users explore digital and physical relationships while accessing to information about their actual location, e.g. the object in front of them. Similar to "conventional" Web applications one might suffer usability problems when dealing with multiple informational concerns, but the situation gets worse because of screen size issues, the need to avoid user distraction, etc. In this paper we outline our model-based approach for building mobile hypermedia applications by combining ("mashing up") information corresponding to multiple concerns in a modular, usable way. Architectural issues are discussed and a simple example is presented together with its implementation.

The goal of this paper is to argue the need to approach the personalization issues in Web applications from the very beginning in the application’s development cycle. Since personalization is a critical aspect in many popular domains such as e-commerce, it important enough that it should be dealt with through a design view, rather than only an implementation view (which discusses mechanisms, rather than design options). We present different scenarios of personalization covering most existing applications. Since our design approach is based on the Object-Oriented Hypermedia Design Method, we briefly introduce i the way in which we build Web application models as object -oriented views of conceptual models. We show how we specify personalized Web applications by refining views according to users’ profiles or preferences; we show that an object -oriented approach allows maximizing reuse in these specifications. We discuss some implementation aspects and compare our work with related approaches, and present some concluding remarks.

Designing high quality visual interfaces for hypermedia applications is difficult; it involves organizing different kinds of interface objects (for example those triggering navigation), prevent lhe user from cognitive overhead, etc. Unfortunately, interface design methods do not capture design decisions or rationale, so it is hard to record and convey interface design expertise.

In this paper we present a software engineering approach for building hypermedia applications. Our approach combines the use of an object-oriented method with a system of design patterns for navigational and interface design. We first present the core activities in the Object-Oriented Hypermedia Design Method (OOHDM), namely conceptual design navigation design, abstract interface design and implementation, describing the modeling constructs we use to build high-level, abstract navigational and interface structures. Next we give the rationale for using design patterns in the process of building high quality hypermedia applications, and present some simple patterns solving recurrent design problems. We finally discuss some further issues.

In this paper we describe a learning environment that combines usual features of object oriented programming environments with visualisation and animation of object-oriented applications. The purpose of this learning tool is to improve students' mental models of object-oriented systems.

Scenarios are well recognized as an important strategy towards understanding the interface between the environment and the system, as well as a means to elicit and specify software behavior. We have a broader understanding of scenarios: for us, a scenario is an evolving description of situations in the environment. Our proposal is framed by Leite's (1995) work on a client-oriented requirements baseline, which aims at modeling the external requirements of a software system and its evolution. Scenarios start by describing the environmental situation, according to the main actions performed outside the software system. Scenarios also help the clarification of the interrelation between functional and non-functional requirements. We have validated our strategy and related representations based on case studies of a real situation.