In the teaching-learning processes, research and continuous innovation are encouraged. Now, when talking about innovation, the concept of adapting methodologies that have been successfully applied to speed up and increase the quality of software projects begins to emerge, is the case of agile software development methodologies. Scrum is one of the most widely used methodologies in the software development process, it increases productivity and deliverable quality of software development teams, but there is not much evidence of how to use it to structure learning content and its use to transfer new knowledge in training or software development contexts. To fill this gap, this research analyzes the applicability of Scrum for transferring new knowledge among software developers is developed. In this paper, we describe the details of how to start transferring knowledge using Scrum, guiding the reader through its standards, processes, phases, and objectives. We also report an experiment for improving students’ performance to support the approach’s benefits in the academy context and a case study performed inside the company context.

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.

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.

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.

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.

REP (Requirements Engineering Process) is one of the most essential processes within the software project life cycle because it allows describing software product requirements. This specification should be as consistent as possible to enable estimating in a suitable manner the effort required to obtain the final product. REP is complex in itself, but this complexity is greatly increased in big, distributed and heterogeneous projects with multiple analyst teams and high integration among functional modules. This paper presents an approach for the systematic conciliation of functional requirements in big projects dealing with a modelbased approach. It also explains how this approach may be implemented in the context of NDT (Navigational Development Techniques) methodology and finally, it describes a preliminary evaluation of our proposal in CALIPSOneo project by analyzing the improvements obtained with our approach.

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.

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.