Showing papers on "User story published in 2020"

SPECMATE: Automated Creation of Test Cases from Acceptance Criteria

Abstract: In the agile domain, test cases are derived from acceptance criteria to verify the expected system behavior. However, the design of test cases is laborious and has to be done manually due to missing tool support. Existing approaches for automatically deriving tests require semi-formal or even formal notations of acceptance criteria, though informal descriptions are mostly employed in practice. In this paper, we make three contributions: (1) a case study of 961 user stories providing an insight into how user stories are formulated and used in practice, (2) an approach for the automatic extraction of test cases from informal acceptance criteria and (3) a study demonstrating the feasibility of our approach in cooperation with our industry partner. In our study, out of 604 manually created test cases, 56 % can be generated automatically and missing negative test cases are added.

ABCDE –agile block chain DApp engineering

Abstract: Blockchain software development is becoming more and more important for any modern software developer and IT startup. Nonetheless, blockchain software production still lacks a disciplined, organized and mature development process, as demonstrated by the many and (in)famous failures and frauds occurred in recent years. In this paper we present ABCDE, a complete method addressing blockchain software development. The method considers the software integration among the blockchain components—smart contracts, libraries, data structures—and the out-of-chain components, such as web or mobile applications, which all together constitute a complete DApp system. We advocate for ABCDE the use of agile practices, because these are suited to develop systems whose requirements are not completely understood since the beginning, or tend to change, as it is the case of most blockchain-based applications. ABCDE is based on Scrum, and is therefore iterative and incremental. From Scrum, we kept the requirement gathering with user stories, the iterative-incremental approach, the key roles, and the meetings. The main difference with Scrum is the separation of development activities in two flows—one for smart contracts and the other for out-of-chain software interacting with the blockchain—each performed iteratively, with integration activities every 2–3 iterations. ABCDE makes explicit the activities that must be performed to design, develop, test and integrate smart contracts and out-of-chain software, and documents the smart contracts using formal diagrams to help development, security assessment, and maintenance. A diagram derived from UML class diagram helps to effectively model the data structure of smart contracts, whereas the exchange of messages between the entities of the system is modeled using a modified UML sequence diagram. The proposed method has also specific activities for security assessment and gas optimization, through systematic use of patterns and checklists. ABCDE focuses on Ethereum blockchain and its Solidity language, but preserves generality and with proper modifications might be applied to any blockchain software project. ABCDE method is described in detail, and an example is given to show how to concretely implement the various development steps.

A Systematic Literature Review of Machine Learning Estimation Approaches in Scrum Projects

Abstract: It is inevitable for any successful IT industry not to estimate the effort, cost, and duration of their projects. As evident by Standish group chaos manifesto that approx. 43% of the projects are often delivered late and entered crises because of overbudget and less required functions. Improper and inaccurate estimation of software projects leads to a failure, and therefore it must be considered in true letter and spirit. When Agile principle-based process models (e.g., Scrum) came into the market, a significant change can be seen. This change in culture proves to be a boon for strengthening the collaboration between developer and customer. Estimation has always been challenging in Agile as requirements are volatile. This encourages researchers to work on effort estimation. There are many reasons for the gap between estimated and actual effort, viz., project, people, and resistance factors, wrong use of cost drivers, ignorance of regression testing effort, understandability of user story size and its associated complexity, etc. This paper reviewed the work of numerous authors and potential researchers working on bridging the gap of actual and estimated effort. Through intensive and literature review, it can be inferred that machine learning models clearly outperformed non-machine learning and traditional techniques of estimation.

Towards Supporting Collaborative Spatial Planning: Conceptualization of a Maptable Tool through User Stories

Abstract: Geographic information-based planning support tools implemented in a maptable have the potential to mediate collaborative spatial planning processes. However, available tools for a maptable either lack advanced analytical functions or have usability shortcomings. Given these limitations, this research aims to conceptualize an interactive planning support tool intended to fully exploit maptable capabilities while providing spatial analytical functions to better support planning and decision-making processes with a larger group of participants. To do so, we conducted a literature review of reported maptable-based applications and semi-structured interviews with identified intended user groups of such applications, and derived Agile user stories. We identified a) principal spatial analyses, b) must-have functionalities, c) required support for individual contributions, and d) preferred space-time settings for group work collaboration, and based on that conceptualized an interactive tool for a maptable. By involving the intended users in the conception of the tool we revealed a discrepancy between the understanding of scholars and developers with respect to what users need and what they do. Intended user groups require tailored but straightforward instruments, rather than complicated or time-consuming models. Our research has laid down the foundation for future maptable tool development to support collaborative planning processes.

A risk management framework for distributed scrum using PRINCE2 methodology

Abstract: The distributed Agile development approach has been accepted by software companies due to its promised benefits. However, due to the controversial nature of distributed and Agile development, significant challenges arise from spatial, temporal, social, and cultural differences between distributed teams. Scrum, as the most popular Agile methodology, assumes that team members work together in the same room. But this principle does not apply in a realistic scenario where Scrum teams are distributed in different locations. Hence, proposing a risk management framework is necessary in order to succeed such teams. The purpose of this research was to propose a risk management framework in Scrum using the PRINCE2 methodology, which includes the perceived risks in distributed Scrum projects and their causes and roots for managing these risks. By embedding distributed Scrum in delivery layer of PRINCE2 and considering perceived risk factors, along with a hybrid model, a risk management framework was suggested. This framework has been used in a case study, and the results showed its proper functionality in detecting and eliminating potential risks in the case under study. Also, using this framework led to higher team efficiency in terms of increasing the number of completed user stories in each sprint.

Requirements-Collector: Automating Requirements Specification from Elicitation Sessions and User Feedback

Abstract: In the context of digital transformation, speeding up the time-to-market of high-quality software products is a big challenge. Software quality correlates with the success of requirements engineering (RE) sessions and the ability to collect feedback from end-users in an efficient, dynamic way. Thus, software analysts are tasked to collect all relevant material of RE sessions and user feedback, usually specified on written notes, flip charts, pictures, and user reviews. Afterward comprehensible requirements need to be specified for software implementation and testing. These activities are mostly performed manually, which causes process delays, with a negative effect on software quality attributes such as reliability, usability, comprehensibility. This paper presents Requirements-Collector, a tool for automating the tasks of requirements specification and user feedback analysis. Our tool involves machine learning (ML) and deep learning (DL) computational mechanisms enabling the automated classification of requirements discussed in RE meetings (stored in the form of audio recordings) and textual feedback in the form of user reviews. We use such techniques as they demonstrated to be quite effective in text classification problems. We argue that Requirements-Collector has the potential to renovate the role of software analysts, which can experience a substantial reduction of manual tasks, more efficient communication, dedication to more analytical tasks, and assurance of software quality from conception phases. The results of this work have shown that our tool is able to classify RE specifications and user review feedback with reliable accuracy.

Caspar: extracting and synthesizing user stories of problems from app reviews

Abstract: A user's review of an app often describes the user's interactions with the app. These interactions, which we interpret as mini stories, are prominent in reviews with negative ratings. In general, a story in an app review would contain at least two types of events: user actions and associated app behaviors. Being able to identify such stories would enable an app's developer in better maintaining and improving the app's functionality and enhancing user experience. We present Caspar, a method for extracting and synthesizing user-reported mini stories regarding app problems from reviews. By extending and applying natural language processing techniques, Caspar extracts ordered events from app reviews, classifies them as user actions or app problems, and synthesizes action-problem pairs. Our evaluation shows that Caspar is effective in finding action-problem pairs from reviews. First, Caspar classifies the events with an accuracy of 82.0% on manually labeled data. Second, relative to human evaluators, Caspar extracts event pairs with 92.9% precision and 34.2% recall. In addition, we train an inference model on the extracted action-problem pairs that automatically predicts possible app problems for different use cases. Preliminary evaluation shows that our method yields promising results. Caspar illustrates the potential for a deeper understanding of app reviews and possibly other natural language artifacts arising in software engineering.

EmoG: Supporting the Sketching of Emotional Expressions for Storyboarding

Abstract: Storyboarding is an important ideation technique that uses sequential art to depict important scenarios of user experience. Existing data-driven support for storyboarding focuses on constructing user stories, but fail to address its benefit as a graphic narrative device. Instead, we propose to develop a data-driven design support tool that increases the expressiveness of user stories by facilitating sketching storyboards. To explore this, we focus on supporting the sketching of emotional expressions of characters in storyboards. In this paper, we present EmoG, an interactive system that generates sketches of characters with emotional expressions based on input strokes from the user. We evaluated EmoG with 21 participants in a controlled user study. The results showed that our tool has significantly better performance in usefulness, ease of use, and quality of results than the baseline system.

Automated Goal Model Extraction from User Stories Using NLP

Abstract: User stories are commonly used to capture user needs in agile methods due to their ease of learning and understanding. Yet, the simple structure of user stories prevents us from capturing relations among them. Such relations help the developers to better understand and structure the backlog items derived from the user stories. One solution to this problem is to build goal models that provide explicit relations among goals but require time and effort to build. This paper presents a pipeline to automatically generate a goal model from a set of user stories by applying natural language processing (NLP) techniques and our initial heuristics to build realistic goal models. We first parse and identify the dependencies in the user stories, and store the results in a graph database to maintain the relations among the roles, actions, and objects mentioned in the set of user stories. By applying NLP techniques and several heuristics, we generate goal models that resemble human-built models. Automatically generating models significantly decreases the time spent on this tedious task. Our research agenda includes calculating the similarity between the automatically generated models and the expert-built models. Our overarching research goals are to provide i. an NLP-powered framework that generates goal models from a set of user stories, ii. several heuristics to generate goal models that resemble human-built models, and iii. a repository that includes sets of user stories, with corresponding human-built and automatically generated goal models.

Agile Islands in a Waterfall Environment: Challenges and Strategies in Automotive

Abstract: Driven by the need for faster time-to-market and reduced development lead-time, large-scale systems engineering companies are adopting agile methods in their organizations. This agile transformation is challenging and it is common that adoption starts bottom-up with agile software teams within the context of traditional company structures. This creates the challenge of agile teams working within a document-centric and plan-driven (or waterfall) environment. While it may be desirable to take the best of both worlds, it is not clear how that can be achieved especially with respect to managing requirements in large-scale systems. This paper presents an exploratory case study focusing on two departments of a large-scale systems engineering company (automotive) that is in the process of company-wide agile adoption. We present challenges that agile teams face while working within a larger plan-driven context and propose potential strategies to mitigate the challenges. Challenges relate to, e.g., development teams not being aware of the high-level requirements, difficulties to manage change of these requirements as well as their relationship to backlog items such as user stories. While we found strategies for solving most of the challenges, they remain abstract and empirical research on their effectiveness is currently lacking.

Evaluating the usage of predefined interactive behaviors for writing user stories: an empirical study with potential product owners

Abstract: Behavior-driven development (BDD) has gained popularity in agile software development as a means of specifying user requirements through user stories and scenarios for interactive systems under construction. Templates for guiding the writing of such stories are widely employed and can be helpful to ensure that consistent information about the requirements is provided. With the aim of getting preliminary results about how product owners (POs) write their own user stories under a predefined template, we conducted a case study with potential POs at the department in charge of business trips in a French research institute. The participants were invited to write their own user stories to describe a feature they are used to perform. The resultant stories have been analyzed to check their adherence to a template including common interactive behaviors defined by an ontology for interactive systems. Although the participants have followed different specification strategies, we observed an overall high level of adherence to the proposed template (62.26%). The results also pointed out to a wide use of domain-dependent behaviors, with the interactive behaviors defined by the ontology being, to some extent, reproduced by the participants even without prior training in the adopted vocabulary.

Assessing Individual Contributions to Software Engineering Projects with Git Logs and User Stories

Abstract: Software Engineering courses often incorporate large-scale projects with collaboration between students working in teams. However, it is difficult to objectively assess individual students when their projects are a product of collaborative efforts. This study explores measurements of individuals' contributions to their respective teams. I analyzed ten Software Engineering team projects (n=42) and evaluations of individual contributions using automated evaluation of the version control system history (Git logs) and user stories completed on their project management (Kanban) boards. Unique insights from meta-data within the Git history and Kanban board user stories reveal complicated relationships between these measurements and traditional assessments, such as peer review and subjective instructor evaluation. From the results, I suggest supplementing and validating traditional assessments with insights from individuals' commit history and user story contributions.

Microservices Backlog - A Model of Granularity Specification and Microservice Identification

Abstract: Microservices are a software development approach where applications are composed of small independent services that communicate through well-defined APIs. A major challenge of designing these applications is determining the appropriate microservices granularity, which is currently done by architects using their judgment. This article describes Microservice Backlog (MB), a fully automatic genetic-programming technique that uses the product backlog’s user stories to (1) propose a set of microservices for optimal granularity and (2) allow architects to visualize at design time their design metrics. Also, a new Granularity Metric (GM) was defined that combines existing metrics of coupling, cohesion, and associated user stories. The MB-proposed decomposition for a well-known state-of-the-art case study was compared with three existing methods (two automatics and one semi-automatic); it had consistently better GM scoring and fewer average calls among microservices, and it allowed to identify critical points. The wider availability of techniques like MB will allow architects to automate microservices identification, optimize their granularity, visually assess their design metrics, and identify at design time the system critical points.

An Industrial Investigation into Effort Estimation Predictors for Mobile App Development in Agile Processes

Abstract: Effort estimation is essential for all development teams in order to ensure the user's story for the software project is delivered on time, boxed released. The characteristics of mobile apps make app development different from other traditional software. There are many challenges in developing a mobile app that could lead to inaccurate estimation of user stories. Therefore, the aim of this paper is to provide a comprehensive investigation into the factors that affect the accuracy of effort estimation. The effort estimation factors have been collected from previous studies and validated with 20 practitioners across 18 organisations in the development field of mobile applications.

The impact of using a domain language for an agile requirements management

Abstract: Context: The development of software systems is a complex activity because of its nature and the management of its construction. It is challenging to create and follow a plan. Moreover, budget overrun is a common consequence of this situation. Agile methods, like Scrum, help to mitigate this problem using incremental and iterative development. Agile methods jump start new developments, but it is difficult to be agile after several months when the software has to deal with many requirements that are scattered and tangled across several User Stories written in different Sprints. Objective: In this paper, we propose a traceability approach anchored on an index structure to access specific User Stories from a large set. Our proposed strategy has the goal to consolidate the information dispersed in different User Stories into a particular lexicon: The Language Extended Lexicon (LEL). Method: The proposed approach consists of a set of rules which extract the information dispersed in the User Stories and organize it in symbols of the Lexicon. Thus, the Lexicon supplies a consolidated and organized structure to mitigate the problem of tangled information that generates lack of traceability among different sprints. Results: We assessed how the Lexicon built by our approach improves everyday activities related to requirement management. The assessment is based on a quantitative evaluation with 36 subjects. Conclusion: The approach presents benefits for requirement tracing in agile methodologies supported by the preliminary results of the evaluation. We have developed an application (a prototype) that automates the LEL derivation rules from a set of User Stories.

User Story Estimation Based on the Complexity Decomposition Using Bayesian Networks

Abstract: Currently, in Scrum, there are different methods to estimate user stories in terms of effort or complexity. Most of the existing techniques consider factors in a fine grain level; these techniques are not always accurate. Although Planning Poker is the most used method in Scrum to estimate user stories, it is primarily effective in experienced teams since the estimation mostly depends on the observation of experts, but it is difficult when is used by inexperienced teams. In this paper, we present a proposal for complexity decomposition in a coarse grain level, in order to consider important factors for complexity estimation. We use a Bayesian network to represent those factors and their relations. The edges of the network are weighted with the judge of professional practitioners about the importance of the factors. The nodes of the network represent the factors. During the user estimation phase, the Scrum team members introduce the values for each factor; in this way, the network generates a value for the complexity of a User story, which is transformed in a Planning Poker card number, which represents the story points. The purpose of this research is to provide to development teams without experience or without historical data, a method to estimate the complexity of user stories through a model focused on the human aspects of developers.

Variability and Commonality Requirement Specification on Agile Software Development: Scrum, XP, Lean, and Kanban

Abstract: The user story widely studied insufficiently describes the software requirements. Many studies discuss the challenges of requirements specifications and proposed solutions. However, there are many agile methods and each method embraces different practices. Therefore, the solution has to follow each method’s ceremonies. Only a few studies discuss conducted practices in requirements specification development with the agile method and there are no studies that discuss practices comparisons among these methods. In this paper, we performed a systematic literature review to gather the available studies in procuring a current insight into the requirements engineering practices incorporate into the agile method. This study aims to map the variability and commonality practices among agile methods. The various and standard agile RE practices show crucial practices in the requirements specification development process. Moreover, it gives information on practices from other methods that increase the success of requirements specification development. From the systematic literature review, we found a total of 12 studies relevant to the study. There are eight variability and commonality practices between Scrum, XP, and Lean methods.

Conceptualizing Requirements Using User Stories and Use Cases: A Controlled Experiment

Abstract: [Context and motivation] Notations for expressing requirements are often proposed without explicit consideration of their suitability for specific tasks. Consequently, practitioners may choose a sub-optimal notation, thereby affecting task performance. [Question/problem] We investigate the adequacy of two well-known notations: use cases and user stories, as a starting point for the manual derivation of a static conceptual model. In particular, we examine the completeness and correctness of the derived conceptual model. [Principal ideas/results] We conducted a two-factor, two-treatment controlled experiment with 118 subjects. The results indicate that for deriving conceptual models, user stories fit better than use cases. It seems that the repetitions in user stories and their conciseness contribute to these results. [Contribution] The paper calls for evaluating requirements notations in the context of various requirements engineering tasks and for providing evidence regarding the aspects that need to be taken into account when selecting a requirement notation.

Reducing Ambiguity in Requirements Elicitation via Gamification

Abstract: The overall quality and success of software highly depends on the involvement of stakeholders. Requirements elicitation supports RE analyst to gather requirements from the stakeholders based on their needs. There are multiple elicitation techniques present in literature and used by the practitioners. Some of them are questionnaires, interviews, prototyping, and user stories etc. However, these techniques are based on textual representation of requirements. These techniques are quite common among the requirement engineers yet problems of ambiguity, inconsistency, incompleteness still exist mostly due to their textual nature and lack of stakeholder involvement. Lack of clarity about the system increases the ambiguity of what exactly are the system requirements. Since elicitation is carried at an early stage of development the users are not sure of what they want, as requirements tend to evolve with the help of discussions and interactions among various stakeholders and technical team. Furthermore, the conventional elicitation methods are limited when it comes to stakeholders’ participation and involvement, thus leaving a space for more ambiguous and incomplete requirements. In this work, Gamification, a game-based context will be used in non-gaming context for user involvement in fun ways. During elicitation, gamification would help to involve and interact with the stakeholders, with an intention to develop their interest in eliciting and finalizing system requirements. The goal of this paper is to reduce ambiguity during requirements elicitation. This would help in reducing the cost and time of development. Furthermore, we will elicit software requirements using gamification by developing a gamification tool with a focus to elicit unambiguous requirements by ensuring users’ participation and maintaining interest. The validation of tool would be done using multiple confirmatory case studies from software industry.

Enabling the Reuse of Software Development Assets Through a Taxonomy for User Stories

Abstract: Context - Agile Software Development (ASD) and Reuse-Driven Software Engineering (RDSE) are well-accepted strategies to improve the efficiency of software processes. A challenge to integrate both approaches is that ASD relies mostly on tacit knowledge, hampering the reuse of software development assets. An opportunity to enable RDSE for ASD is by improving the traceability between user stories (USs), the most used notation to register product requirements in ASD. Having enough link semantics between USs could enable defining similarity between them and, consequently, promote RDSE for ASD. However, this is an open challenge. Objective - To propose a taxonomy for adding link semantics between USs, focusing on easing the task of identifying similar ones. Such links, with support of traceability tools, enable the reuse of USs and their related assets. Method : We constructed a taxonomy for types of US focusing on Web Information Systems. The taxonomy is used to classify the US, given two facets: module and operation. Such information is used to infer the similarity between USs using link rules. We developed the taxonomy based on an empirical analysis of five product backlogs, containing a total of 118 USs. Afterward, we validated the taxonomy in terms of its potential to enable the reuse of US-related assets. First, we executed an offline validation by applying it to classify 530 USs from 26 already ended projects. Finally, we applied the taxonomy in a case study with two ongoing projects (59 USs). Results : The proposed taxonomy for USs is composed of two sub-facets, namely, module and operation, which have, respectively, three and 18 terms. In terms of coverage, for the offline study and case study, we classified 90.17% of the USs with the proposed taxonomy. For the case study, we classified all the USs analyzed. Conclusion : We concluded that it is possible to use our approach to compare USs and, consequently, retrieve their related assets. Our results regarding its practical utility have shown that users considered the taxonomy a useful approach to ease the process of assessing the similarity between user stories.

Decision support technology for sprint planning

Abstract: Context. The article describes the relevant planning process of software projects, planning problems and different solutions to these problems basis on use of the Scrum methodology. Objective. The purpose of the work is to develop the technology for solving the sprint planning task in the face of uncertainty and possible risks from software development standpoint. Method. The most used software life cycle models are described. The choice of the Scrum as a widely used representative of agile methodology for software development is justified. An analytical review of the methods for estimation of the complexity of user stories is carried out. The major problems of sprint planning are highlighted. The model of the business process to implement an ITproject by Scrum in the form of an BPMN-diagram has been developed. The algorithm to solve the problem of Sprint Backlog planning with uncertainty has been elaborated. The common process of user stories selection from Product Backlog to Sprint Backlog and ways of solving the possible problems are considered. The task of estimation of labor intensity of user stories and the task of risk evaluation in planning are formalized. The technology of user story selection for Sprint Backlog has been developed. Numerical studies of the decision support technology proposed in the article are carried out. It allows suggesting it as the practical tool during sprint planning. The method of adequacy evaluation of proposed technology is offered. The set of key performance indicators for assessing the team performance is selected. Results. The sprint planning technology was developed, which project managers, product owners and development teams for increasing the effectiveness of decision-making process can use. Conclusions. The conducted experiments have confirmed the importance of the proposed decision support technology and allow recommending it for use in practice for planning of software projects. Scientific novelty is to improve the sprint planning process with the assistance of the proposed technology, which alleviates uncertainty while defining labor intensity of user stories and decreases time spent on decision making.

Topic Modeling on User Stories using Word Mover's Distance

Abstract: Requirements elicitation has recently been complemented with crowd-based techniques, which continuously involve large, heterogeneous groups of users who express their feedback through a variety of media. Crowd-based elicitation has great potential for engaging with (potential) users early on but also results in large sets of raw and unstructured feedback. Consolidating and analyzing this feedback is a key challenge for turning it into sensible user requirements. In this paper, we focus on topic modeling as a means to identify topics within a large set of crowd-generated user stories and compare three approaches: (1) a traditional approach based on Latent Dirichlet Allocation, (2) a combination of word embeddings and principal component analysis, and (3) a combination of word embeddings and Word Mover's Distance. We evaluate the approaches on a publicly available set of 2,966 user stories written and categorized by crowd workers. We found that a combination of word embeddings and Word Mover's Distance is most promising. Depending on the word embeddings we use in our approaches, we manage to cluster the user stories in two ways: one that is closer to the original categorization and another that allows new insights into the dataset, e.g. to find potentially new categories. Unfortunately, no measure exists to rate the quality of our results objectively. Still, our findings provide a basis for future work towards analyzing crowd-sourced user stories.

RNN-CNN MODEL:A Bi-directional Long Short-Term Memory Deep Learning Network For Story Point Estimation

Abstract: In recent years, an increased interest in the adaption of agile software development by companies. Using iterative methodology enables them to do issue-based estimation and respond quickly to changes in the requirements. Agile methodology adopts Story Point Approach to estimate the effort that involves a user story or a resolving issue. Unlike traditional estimation, Agile Methodology focuses on individual programming task estimation instead of whole project estimation. In this work, we approach story point estimation using the RNN-CNN model. We consider the contextual information in a user story in both forward and backward directions to build the RNN-CNN model. The proposed model adopts a Bi-directional Long Short-Term Memory (BiLSTM), a tree-structured Recurrent Neural Network (RNN) with Convolutional Neural Network (CNN), tries to predict a story point for a user story description. Here, BiLSTM forward and backward feature learning will make network preserve the sequence data and CNN makes feature extraction accurate. The experimental results show the improvement in estimating the story points with a user story as an input using the proposed RNN-CNN. Furthermore, the analysis shows that the proposed RNN-CNN model outperforms the existing model and gives 74.2 % R2 Score on the Bamboo data set.

Generating Use Case Scenarios from User Stories

Abstract: Textual user stories capture interactions of users with the system as high-level requirements. However, user stories are typically rather short and backlogs can include many stories. This makes it hard to (a) maintain user stories and backlogs, (b) fully understand the scope of a software project without a detailed analysis of the backlog, and (c) analyse how user stories impact design decisions during sprint planning and implementation. This paper proposes a technique to automatically transform textual user stories into visual use case scenarios in the form of robustness diagrams (a semi-formal scenario-based visualisation of workflows). In addition to creating diagrams for individual stories, the technique allows combining diagrams of multiple stories into one diagram to visualise workflows within sets of stories (e.g., a backlog). Moreover, the technique supports "viewpoint-based" diagrams, i.e., diagrams that show relationships between actors, domain entities and user interfaces starting from a diagram element (e.g., an actor) selected by the analyst. The technique utilises natural language processing and rule-based transformations. We evaluated the technique with more than 1,400 user stories from 22 backlogs and show that (a) the technique generates syntactically valid robustness diagrams, and (b) the quality of automatically generated robustness diagrams compares to the quality of diagrams created by human experts, but depends on the quality of the textual user stories.

Explicit Alignment of Requirements and Architecture in Agile Development

Abstract: [Context & Motivation] Requirements and architectural components are designed concurrently, with the former guiding the latter, and the latter restricting the former. [Question/problem] Effective communication between requirements engineers and software architects is often experienced as problematic. [Principal ideas/results] We present the Requirements Engineering for Software Architecture (RE4SA) model with the intention to support the communication within the development team. In RE4SA, requirements are expressed as epic stories and user stories, which are linked to modules and features, respectively, as their architectural counterparts. Additionally, we provide metrics to measure the alignment between these concepts, and we also discuss how to use the model and the usefulness of the metrics by applying both to case studies. [Contribution] The RE4SA model employs widely adopted notations and allows for explicitly relating a system’s requirements and architectural components, while the metrics make it possible to measure the alignment between requirements and architecture.

Persona Design in Participatory Agile Software Development

Abstract: Personas are a popular method of user centered design (UCD) in technical product development and have become indispensable in software development. In agile software development, which is nowadays predominantly used in modern projects, personas do not have a role of their own. User needs are usually introduced into development via the Product Owner role by means of user stories. Especially when software is developed for user groups with special needs, it is often difficult for developers to understand the needs of the users based on common user stories.

Ensuring the Consistency between User Requirements and Task Models: A Behavior-Based Automated Approach

Abstract: Evaluating and ensuring the consistency between user requirements and modeling artifacts is a long-time issue for model-based software design. Conflicts in requirements specifications can lead to many design errors and have a decisive impact on the quality of systems under development. This article presents an approach based on Behavior-Driven Development (BDD) to provide automated assessment for task models, which are intended to model the flow of user and system tasks in an interactive system. The approach has been evaluated by exploiting user requirements described by a group of experts in the domain of business trips. Such requirements gave rise to a set of BDD stories that have been used to automatically assess scenarios extracted from task models that were reengineered from an existing web system for booking business trips. The results have shown our approach, by performing a static analysis of the source files, was able to identify different types of inconsistencies between the user requirements and the set of task models analyzed.