scispace - formally typeset
Search or ask a question

Showing papers on "User story published in 2016"


Journal ArticleDOI
TL;DR: The Quality User Story (QUS) framework is proposed, a set of 13 quality criteria that user story writers should strive to conform to and a software tool, based on QUS, is presented, which relies on natural language processing techniques and suggests possible remedies.
Abstract: User stories are a widely adopted requirements notation in agile development. Yet, user stories are too often poorly written in practice and exhibit inherent quality defects. Triggered by this observation, we propose the Quality User Story (QUS) framework, a set of 13 quality criteria that user story writers should strive to conform to. Based on QUS, we present the Automatic Quality User Story Artisan (AQUSA) software tool. Relying on natural language processing (NLP) techniques, AQUSA detects quality defects and suggest possible remedies. We describe the architecture of AQUSA, its implementation, and we report on an evaluation that analyzes 1023 user stories obtained from 18 software companies. Our tool does not yet reach the ambitious 100 % recall that Daniel Berry and colleagues require NLP tools for RE to achieve. However, we obtain promising results and we identify some improvements that will substantially improve recall and precision.

149 citations


Book ChapterDOI
14 Mar 2016
TL;DR: The data shows that practitioners agree that using user stories, a user story template and quality guidelines such as the INVEST mnemonic improve their productivity and the quality of their work deliverables.
Abstract: [Context and motivation] User stories are an increasingly popular textual notation to capture requirements in agile software development. [Question/Problem] To date there is no scientific evidence on the effectiveness of user stories. The goal of this paper is to explore how practicioners perceive this artifact in the context of requirements engineering. [Principal ideas/results] We explore perceived effectiveness of user stories by reporting on a survey with 182 responses from practitioners and 21 follow-up semi-structured interviews. The data shows that practitioners agree that using user stories, a user story template and quality guidelines such as the INVEST mnemonic improve their productivity and the quality of their work deliverables. [Contribution] By combining the survey data with 21 semi-structured follow-up interviews, we present 12 findings on the usage and perception of user stories by practitioners that employ user stories in their everyday work environment.

116 citations


Proceedings ArticleDOI
01 Sep 2016
TL;DR: This paper proposes to automatically derive conceptual models from a concise and widely adopted NL notation for requirements: user stories, and presents an algorithm that combines state-of-the-art heuristics and that is implemented in the Visual Narrator tool.
Abstract: Natural language (NL) is still the predominant notation that practitioners use to represent software requirements. Albeit easy to read, NL does not readily highlight key concepts and relationships such as dependencies and conflicts. This contrasts with the inherent capability of graphical conceptual models to visualize a given domain in a holistic fashion. In this paper, we propose to automatically derive conceptual models from a concise and widely adopted NL notation for requirements: user stories. Due to their simplicity, we hypothesize that our approach can improve on the low accuracy of previous works. We present an algorithm that combines state-of-the-art heuristics and that is implemented in our Visual Narrator tool. We evaluate our work on two case studies wherein we obtained promising precision and recall results (between 80% and 92%). The creators of the user stories perceived the generated models as a useful artifact to communicate and discuss the requirements, especially for team members who are not yet familiar with the project.

82 citations


Book ChapterDOI
14 Mar 2016
TL;DR: This work develops the gamified requirements engineering model GREM that relates gamification, stakeholder engagement, and RE performance, and leads to the hypothesis that competitive game elements are advantageous for RE elicitation, while socialgame elements are favorable for RE phases where cooperation is demanded.
Abstract: [Context & Motivation] Engaging stakeholders in requirements engineering RE influences the quality of the requirements and ultimately of the system to-be. Unfortunately, stakeholder engagement is often insufficient, leading to too few, low-quality requirements. [Question/problem] We aim to evaluate the effectiveness of gamification to improve stakeholder engagement and ultimately performance in RE. We focus on agile requirements that are expressed as user stories and acceptance tests. [Principal ideas/results] We develop the gamified requirements engineering model GREM that relates gamification, stakeholder engagement, and RE performance. To evaluate GREM, we build an online gamified platform for requirements elicitation, and we report on a rigorous controlled experiment where two independent teams elicited requirements for the same system with and without gamification. The findings show that the performance of the treatment group is significantly higher, and their requirements are more numerous, have higher quality, and are more creative. [Contribution] The GREM model paves the way for further work in gamified RE. Our evaluation provides promising initial empirical insights, and leads us to the hypothesis that competitive game elements are advantageous for RE elicitation, while social game elements are favorable for RE phases where cooperation is demanded.

63 citations


Journal ArticleDOI
TL;DR: A method is proposed that facilitates better understanding of execution order and integration dependencies of user stories by making use of business process models and contributes to the discipline of conceptual modeling in agile development.
Abstract: ContextAgile software development projects often manage user requirements with models that are called user stories. Every good user story has to be independent, negotiable, valuable, estimable, small, and testable. A proper understanding of a user story also requires an understanding of its dependencies. The lack of explicit representation of such dependencies presumably leads to missing information regarding the context of a user story. ObjectiveWe propose a method that facilitates better understanding of execution order and integration dependencies of user stories by making use of business process models. The method associates user stories with the corresponding business process model activity element. MethodWe adopted a situational method engineering approach to define our proposed method. In order to provide understanding of proposed method's constructs we used ontological concepts. Our method associates a user story to an activity element. In this way, the business process model can be used to infer information about the execution order and integration dependencies of the user story. We defined three levels of association granularity: a user story can be more abstract, approximately equal to, or more detailed than its associated business process model activity element. In our experiment we evaluate each of these three levels. ResultsOur experiment uses a between-subject design. We applied comprehension, problem-solving and recall tasks to evaluate the hypotheses. The statistical results provide support for all of the hypotheses. Accordingly, there appears to be significantly greater understanding of the execution order and integration dependencies of user stories when associated business process models are available. ConclusionsWe addressed a problem which arises from managing user stories in software development projects and focuses on the missing context of a user story. Our method contributes to the discipline of conceptual modeling in agile development. Our experiment provides empirical insight into requirement dependencies.

52 citations


01 Jan 2016
TL;DR: A conceptual framework and evaluation model of LMS is built through the lens of User Experience (UX) research and practice, an epistemology that is quite important but currently neglected in the elearning domain.
Abstract: Learning Management Systems (LMS) have been the main vehicle for delivering and managing e-learning courses in educational, business, governmental and vocational learning settings. Since the mid-nineties there is a plethora of LMS in the market with a vast array of features. The increasing complexity of these platforms makes LMS evaluation a hard and demanding process that requires a lot of knowledge, time, and effort. Nearly 50% of respondents in recent surveys have indicated they seek to change their existing LMS primarily due to user experience issues. Yet the vast majority of the extant literature focuses only on LMS capabilities in relation to administration and management of teaching and learning processes. In this study the authors try to build a conceptual framework and evaluation model of LMS through the lens of User Experience (UX) research and practice, an epistemology that is quite important but currently neglected in the elearning domain. They conducted an online survey with 446 learning professionals, and from the results, developed a new UX-oriented evaluation model with four dimensions: pragmatic quality, authentic learning, motivation and engagement, and autonomy and relatedness. Their discussion on findings includes some ideas for future research.

43 citations


Proceedings ArticleDOI
01 Jun 2016
TL;DR: This paper shows the feasibility of building the rationale diagram, then points to the use of these consistent sets of US for iteration content planning and an integrated Computer-Aided Software Engineering (CASE) tool supports the approach.
Abstract: Requirements representation in agile methods is often done on the basis of User Stories (US) which are short sentences relating a WHO, WHAT and (possibly) WHY dimension. They are by nature very operational and simple to understand thus very efficient. Previous research allowed to build a unified model for US templates associating semantics to a set of keywords based on templates collected over the web and scientific literature. Since the semantic associated to these keywords is mostly issued of the i∗ framework we overview in this paper how to build a custom rationale diagram on the basis of a US set tagged using that unified template. The rationale diagram is strictly speaking not an i∗ strategic rationale diagram but uses parts of its constructs and visual notation to build various trees of relating US elements in a single project. Indeed, the benefits of editing such a rationale diagram is to identify depending US, identifying EPIC ones and group them around common Themes. The paper shows the feasibility of building the rationale diagram, then points to the use of these consistent sets of US for iteration content planning. To ensure the US set and the rationale diagram constitute a consistent and not concurrent whole, an integrated Computer-Aided Software Engineering (CASE) tool supports the approach.

35 citations


Book ChapterDOI
14 Nov 2016
TL;DR: This paper proposes to transform specific elements of a US set into a Use-Case Diagram using the granularity information obtained through tagging, and involves continuous round-tripping between the US and UC views.
Abstract: User Stories (US) are mostly used as basis for representing requirements in agile development. Written in a direct manner, US fail in producing a visual representation of the main system-to-be functions. A Use-Case Diagram (UCD), on the other hand, intends to provide such a view. Approaches that map US sets to a UCD have been proposed; they however consider every US as a Use Case (UC). Nevertheless, a valid UC should not be an atomic task or a sub-process but enclose an entire scenario of the system use instead. A unified model of US templates to tag US sets was previously build. Within functional elements, it notably distinguishes granularity levels. In this paper, we propose to transform specific elements of a US set into a UCD using the granularity information obtained through tagging. In practice, such a transformation involves continuous round-tripping between the US and UC views; a CASE-tool supports this.

35 citations


Book ChapterDOI
17 Jul 2016
TL;DR: A grammar for stories of interaction called UserX Story is presented, in order to remedy the difficulties encountered by teams to insert UX aspects and usability requirements in the first steps of software conception.
Abstract: In the last decade, many strategies have been employed successfully to incorporate User Experience UX practices into agile development in order to increase user satisfaction with the product. In this paper, we present a grammar for stories of interaction called UserX Story, in order to remedy the difficulties encountered by teams to insert UX aspects and usability requirements in the first steps of software conception. An action research approach was applied to carry out the research within the industry, allowing us to work closely with the agile teams. The research cycle was split in three steps. In the first step, we carried out a technical literature survey, aiming to investigate the use of user stories in the agile methodologies, and additionally, an ethnographic study also was carried out in order to understand how the traditional user stories were being developed by product owners. In the second step, we proposed together with both teams - UX and agile - a grammar to UserX Story incorporating two concepts of UX: personas and Nielsen's heuristics. In the third step, six product owners were invited to implement the UserX Stories in real projects. After that, we interviewed the participants aiming to collect their experiences with the implementation of UserX Stories. Thus, we have found out that most of the agile teams approved the use of the stories incorporating UX aspects.

30 citations


Book ChapterDOI
07 Nov 2016
TL;DR: This work proposes a different approach focused on satisfying end user needs employing Design Thinking iterative software development, which was applied in five real software development projects which have been analyzed as part of this work.
Abstract: The importance of understanding end user needs and involving them in the software development process is well known in software engineering. Agile Software Development methodologies have incorporated user feedback in different ways. User stories should represent the needs of a user, but often express the views of the Product Owner or the software development team. Several works have investigated integrating User Centered Design into Agile Software Development to satisfy end user needs. This work proposes a different approach focused on satisfying end user needs employing Design Thinking iterative software development. This methodology was applied in five real software development projects which have been analyzed as part of this work.

30 citations


Proceedings ArticleDOI
04 Apr 2016
TL;DR: This goal is to investigate the impact that documentation debt brings to projects developed by using Agile Requirements by performing a retrospective study in a real software project that used AR in its development.
Abstract: Documentation debt is a type of technical debt that describes problems in documentation such as missing, inadequate or incomplete artifacts. Unlike traditional methods, agile methodologies usually employ short iterative cycles and rely on tacit knowledge within a team. In particular, Agile Requirements (AR) (e.g., user stories) tend to reduce the focus on requirements specification activities. This scenario contributes to the occurrence of documentation debt. The goal of this paper is to investigate the impact that this type of debt brings to projects developed by using AR. We address this goal by performing a retrospective study in a real software project that used AR in its development. Our analysis was concentrated on data from 132 maintenance and evolution tasks. Of this total, 65 were related to the presence of documentation debt and were performed within a timeframe of 18 months. The findings indicated an extra maintenance effort of about 47% of the total effort estimated for developing the project and an extra cost of about 48% of the initial cost of the development phase.

Book ChapterDOI
14 Nov 2016
TL;DR: A novel, automated method for visualizing requirements—by showing the concepts the text references and their relationships—at different levels of granularity is introduced and experimented on.
Abstract: The majority of practitioners express software requirements using natural text notations such as user stories. Despite the readability of text, it is hard for people to build an accurate mental image of the most relevant entities and relationships. Even converting requirements to conceptual models is not sufficient: as the number of requirements and concepts grows, obtaining a holistic view of the requirements becomes increasingly difficult and, eventually, practically impossible. In this paper, we introduce and experiment with a novel, automated method for visualizing requirements—by showing the concepts the text references and their relationships—at different levels of granularity. We build on two pillars: (i) clustering techniques for grouping elements into coherent sets so that a simplified overview of the concepts can be created, and (ii) state-of-the-art, corpus-based semantic relatedness algorithms between words to measure the extent to which two concepts are related. We build a proof-of-concept tool and evaluate our approach by applying it to requirements from four real-world data sets.

Proceedings ArticleDOI
26 Jun 2016
TL;DR: The business process ontology for defining user story is proposed, a knowledge base designed to collect the user stories in term of N-triple and the synonym property is introduced to simplify and reduce the number of the nodes in the ontology.
Abstract: Writing a user story is essential to communicate with end users and developers. It is popular practices found in most agile methodologies. Therefore, to reuse the user stories from the previous successful projects becomes necessary. In this paper, we propose the business process ontology for defining user story. The ontology is a knowledge base designed to collect the user stories in term of N-triple. The ontology schema is designed using classes and hierarchy relation along with the properties according to Role-Action-Object relations. We introduce the synonym property to simplify and reduce the number of the nodes in the ontology as well. Finally, we demonstrate how to initially populate and build the ontology from the historical user stories.

Book ChapterDOI
Oliver F. Nandico1
01 Jan 2016
TL;DR: This chapter proposes a lightweight enterprise architecture framework which serves the demands of enterprise architects being confronted with a digital transformation scenario with an agile development approach and emphasizes the adaptability and the possibility for propagation of change throughout the defined architecture.
Abstract: This chapter proposes a lightweight enterprise architecture framework which serves the demands of enterprise architects being confronted with a digital transformation scenario with an agile development approach. This framework therefore emphasizes the adaptability and the possibility for propagation of change throughout the defined architecture instead of addressing all possible concerns of all stakeholders. The framework itself is roughly based on TOGAF 9.1 and uses definitions of its content metamodel and follows ADM.

Proceedings ArticleDOI
01 Oct 2016
TL;DR: A set of metrics which give insights into the adherence to agile practices in teams are proposed, which measure aspects which students frequently have issues with and that diminish process adoption and student engagement.
Abstract: Teaching agile software development by pairing lectures with hands-on projects has become the norm. This approach poses the problem of grading and evaluating practical project work as well as process conformance during development. Yet, few best practices exist for measuring the success of students in implementing agile practices. Most university courses rely on observations during the course or final oral exams. In this paper, we propose a set of metrics which give insights into the adherence to agile practices in teams. The metrics identify instances in development data, e.g. commits or user stories, where agile processes were not followed. The identified violations can serve as starting points for further investigation and team discussions. With contextual knowledge of the violation, the executed process or the metric itself can be refined. The metrics reflect our experiences with running a software engineering course over the last five years. They measure aspects which students frequently have issues with and that diminish process adoption and student engagement. We present the proposed metrics, which were tested in the latest course installment, alongside tutoring, lectures, and oral exams.

DOI
11 Mar 2016
TL;DR: The quality of JIT requirements can be characterized as ‘Just-Enough and Just-in-Time Quality’, and a framework for those quality criteria for open source feature requests is developed.
Abstract: The goal of this thesis was to obtain a deeper understanding of the notion of quality for Just-in-Time (JIT) Requirements. JIT requirements are the opposite of up-front requirements. JIT requirements are not analyzed or defined until they are needed meaning that development is allowed to begin with incomplete requirements. We started our analysis by investigating one specific format of JIT requirements: open source feature requests. We discovered that in open source projects there is the problem of many duplicate feature requests. We found seven different categories for those duplicates. Analyzing the duplicates has also led to recommendations for manual search and creation of feature requests. Furthermore we have indicated possible tool support to avoid duplicate feature requests. One possibility for tool support is to visualize so-called feature request networks. For this one needs to have the links between feature requests. We show that it is possible to detect horizontal traceability links between feature requests by using a Vector Space Model with TF-IDF as a weighing scheme. We have determined the optimal preprocessing steps for the feature requests to be used for our text-based analysis. Using a more advanced technique like Latent Semantic Analysis takes significantly more processing time without yielding better results in the three open source projects that we have included in our experiment. Then we took a step back to look at quality criteria for JIT requirements in general. We developed a framework for those quality criteria and constructed a specific list of quality criteria for open source feature requests. We used agile user stories to indicate how the framework could be customized for other types of JIT requirements. We conducted interviews with agile practitioners to evaluate our framework. After their positive feedback we conducted a case study in three open source projects in which we used our framework to score the quality of feature requests. This case study also led to recommendations for practitioners working with feature requests. We conclude this thesis with a broader perspective on JIT requirements quality by presenting the results of a systematic literature review on quality criteria for agile requirements. This review resulted in a list of 28 quality criteria for JIT requirements, recommendations for practitioners working on quality assessment of agile requirements and a research agenda on quality of agile requirements. To conclude we claim that the quality of Just-in-Time Requirements can be characterized as ‘Just-Enough and Just-in-Time Quality’. Our framework can be used to define what Just-Enough and Just-in-Time mean for the specific JIT environment.

Proceedings ArticleDOI
01 Jun 2016
TL;DR: An approach that uses semantic similarity measures to suggest possible cases of duplication between user stories is presented, which can help Product Owners and Scrum Masters in the decision about excluding duplicate user stories from the Product Backlog.
Abstract: In the Scrum process, Product Backlog consists of a prioritized list of desired software functionalities recorded in the form of user stories. As the software product is developed, new functionalities are discovered and included in the Product Backlog. However, in large-scale projects, duplicate stories may arise because of the large number of generated stories, the lack of communication among team members, and due to the speed of development imposed by the Scrum process. In this case, it is important to detect such story as being duplicate, in order to avoid the rework of the software feature. This paper presents an approach that uses semantic similarity measures to suggest possible cases of duplication between user stories. This alert can help Product Owners and Scrum Masters in the decision about excluding duplicate user stories from the Product Backlog.

Proceedings ArticleDOI
01 May 2016
TL;DR: There is a need to have an all-inclusive picture of DevOps and how its related concepts can be leveraged to improve delivery of software applications to end-users while enhancing quality and reducing lead time.
Abstract: The ‘DevOps’ phenomenon that advocates a collaborative and unified method for delivering software, has been gaining tremendous attention from various sectors of the IT industry with organizations adopting this movement exhibiting significant growth in performance. It can be challenging for an organization to commence their DevOps journey owing to the abundant and diverse resources available. There is a need to have an all-inclusive picture of DevOps and how its related concepts can be leveraged to improve delivery of software applications to end-users while enhancing quality and reducing lead time. This paper strives to bring insight into the practices associated with DevOps. An end-to-end solution is provided through an integrated toolchain and a customizable workflow. The role of Docker containers is considered in the context of extending infrastructure provisioning capability of the workflow. In a bid to accelerate delivery and improve testability of applications, a framework to automate Model-View-Controller architectures has been proposed. Through these processes, the cyclical journey of an application is traced from ‘User Stories’ to a running state — ‘User Reality’ on the cloud.

Book ChapterDOI
01 Jan 2016
TL;DR: Based on US and Italian experiences, some of the common challenges in implementing agile practices and recommended solutions to overcome these barriers are discussed.
Abstract: Traditional defense acquisition frameworks are often too large, complex, and slow to acquire information technology (IT) capabilities effectively. Defense acquisition organizations for years have been concerned about the lengthy IT development timelines and given the pace of change in operations and technology, it is critical to look for new strategies to acquire IT for defense systems. Over the last decade, agile software development emerged as a leading model across industry with growing adoption and success. Agile is centered on small development Teams delivering small, frequent releases of capabilities, with active user involvement. From a planning and execution viewpoint, agile emphasizes an iterative approach with each iteration informing the next. The focus is less on extensive upfront planning for entire programs and more on responsiveness to internal and external changes, such as operations, technology, and budgets. Based on US and Italian experiences, this paper discusses some of the common challenges in implementing agile practices and recommended solutions to overcome these barriers.

Proceedings ArticleDOI
04 Jun 2016
TL;DR: This paper built two apps that allow users to express feedback with text, ratings and pictures whenever using a product and compared the quantity, relevance, and nature of the feedback collected with both UX evaluation apps to traditional evaluation methods.
Abstract: User studies and expert reviews are established methods for evaluating usability and user experience (UX) in user-centered design. However, practitioners often struggle to integrate these often time-consuming and costly methods in their design processes. As technological products and services are becoming increasingly mobile, their contexts of use are increasingly diverse and less predictable. While this changing context is hard to capture in lab studies, the same mobile technologies also provide possibilities for new study methods. In this paper we advocate lightweight mobile tools for crowdsourcing UX feedback. In cooperation with a design agency, we built two apps that allow users to express feedback with text, ratings and pictures whenever using a product. The second app assigns feedback to categories, while the first does not. In a case study we compared the quantity, relevance, and nature of the feedback collected with both UX evaluation apps to traditional evaluation methods. The feedback collected with the apps was considered highly useful by designers and provided more user stories and context than traditional evaluations.

Proceedings ArticleDOI
14 May 2016
TL;DR: This work describes a gamification based approach which promotes quicker completion and acceptance of user stories in such distributed Agile projects and helps create project-wide awareness regarding the progress of different teams.
Abstract: Large organizations need to be nimble in delivering software solutions for meeting rapidly changing business requirements and technology landscape. Following Agile principles of software development is a natural choice. However, to truly leverage the power of Agile, big organizations need to be able to utilize distributed teams effectively. Agile relies hugely on shared context and awareness among team members and this can become a stumbling block among such geographically dispersed teams. Moreover, in such large projects there is a need for incentivizing quick delivery of user stories so that the teams have a constructive sense of competition and are recognized in-process. Here, we describe a gamification based approach which promotes quicker completion and acceptance of user stories in such distributed Agile projects. Our approach captures important events from the development environment and then helps create project-wide awareness regarding the progress of different teams. A model of earning revenue for faster delivery of user stories is used to determine the leading team at the end of each sprint. This approach has been implemented in an Agile process guidance and awareness workbench that we are piloting within our organization.

Proceedings ArticleDOI
08 Jun 2016
TL;DR: The evaluation of the third feature (adding new user story/re-prioritize user story by customer) shows that the simple implementation provided for this feature is not sufficient and, hence, there is a need for a more thorough study to best involve customers through agile planning tools.
Abstract: Planning is an integral part of agile software project management. Several agile software planning tools were developed; they grow in number and complexity. Our analysis of 30 of the most known agile planning tools shows that while the majority of them support the key agile planning activities, they still have limitations. In this paper, we presented three limitations to the current agile planning tools and we developed three features to overcome them. A questionnaire is used to evaluate the identified limitations and the proposed features. The evaluation shows that the identified limitations are sound and exist in the real software projects. In addition, most of the participants agree about how to implement the first and second proposed features (providing task effort notification and improving user story prioritization). The evaluation of the third feature (adding new user story/re-prioritize user story by customer) shows that the simple implementation provided for this feature is not sufficient and, hence, there is a need for a more thorough study to best involve customers through agile planning tools. This research contributes in developing advanced agile planning tools supporting the key agile planning activities.

Journal ArticleDOI
TL;DR: A literature review aiming to identify how agile teams have integrated UCD tools into their agile software development process to a better understanding of the user requirements without losing sight of the agile values and principles finds approaches that could lead to a comprehensive user-centric software engineering.
Abstract: The lack of user engagement, the absence of user feedback, incomplete and continuously changing user requirements are among the critical concerns that cause projects to fail User-centered design (UCD) and agile software development are two iterative approaches that have been proposed to overcome such concerns UCD is a design process focusing on user research, user interface design and usability evaluation Introduced by software engineering practitioners, agile refers to a number of iterative and incremental software development practices that emphasize people’s needs, communication between developers and stakeholders and the ability to adapt to change In both the agile and UCD communities, however, a full understanding of user requirements is often seen as incompatible with early and quick development iterations We performed a literature review aiming to identify how agile teams have integrated UCD tools into their agile software development process to a better understanding of the user requirements without losing sight of the agile values and principles UCD tools adaptations and minimal-up-front design applied in agile development are among the approaches discovered in this study The findings could lead to a comprehensive user-centric software engineering that will overcome inherent problems faced by agile teams to understand user needs, priorities and goals

Proceedings ArticleDOI
24 Feb 2016
TL;DR: It is argued that the Agent-SA produced with the transformation process contributes to the overall project agility.
Abstract: Agile principles have taken an increasing importance in the last decades. Software Architecture (SA) definition is perceived as a non-agile practice as it is executed in a top-down manner, reminding waterfall development, and sometimes imposes heavy documentation. This paper proposes to systematically build an agent-oriented SA from a set of User Stories (US), the core artifact to document requirements in agile methodologies. Previous research has allowed to define a unified US meta-model for the generation of templates relating WHO, WHAT and WHY elements. This meta-model’s elements define a syntax issued from practitioners templates associated with semantics from Goal Oriented Requirements Engineering frameworks, more precisely i*. With a set of US following the templates of this previous model, the link between the US and SA concepts is systematically studied and a transformation process is proposed. The SA can decline agent behaviors aligned with requirements and organizational behaviors. Moreover, requirements (thus US) are subject to evolution through agile iterations; the SA can evolve with these changes in a semi-automatic manner. We thus argue that the Agent-SA produced with our transformation process contributes to the overall project agility.

Posted Content
TL;DR: In this article, the authors propose a prediction model for estimating story points based on a novel combination of two powerful deep learning architectures: long short-term memory and recurrent highway network, which is trainable from raw input data to prediction outcomes without any manual feature engineering.
Abstract: Although there has been substantial research in software analytics for effort estimation in traditional software projects, little work has been done for estimation in agile projects, especially estimating user stories or issues. Story points are the most common unit of measure used for estimating the effort involved in implementing a user story or resolving an issue. In this paper, we offer for the \emph{first} time a comprehensive dataset for story points-based estimation that contains 23,313 issues from 16 open source projects. We also propose a prediction model for estimating story points based on a novel combination of two powerful deep learning architectures: long short-term memory and recurrent highway network. Our prediction system is \emph{end-to-end} trainable from raw input data to prediction outcomes without any manual feature engineering. An empirical evaluation demonstrates that our approach consistently outperforms three common effort estimation baselines and two alternatives in both Mean Absolute Error and the Standardized Accuracy.

Proceedings ArticleDOI
13 Sep 2016
TL;DR: A platform that supports co-designers in capturing unwitting user-generated contributions and use them in the co- design of meaningful user experience for digitally augmented cultural heritage exhibitions is proposed.
Abstract: Co-design as a tactic of exploring and shaping possible futures would benefit from contributions of unwitting participants. That is, researchers gather information from them while performing some activities without participants being explicitly aware of it. We propose a platform that supports co-designers in capturing unwitting user-generated contributions and use them in the co-design of meaningful user experience for digitally augmented cultural heritage exhibitions. We report on a use case for ideating futures for cultural heritage and discuss the tradeoffs of involving unwitting participants in exploratory design as well as lessons learnt on the integration of users contributions into co-design processes.

Book ChapterDOI
22 Jun 2016
TL;DR: This work focuses on the resolution of semantically incomplete user-generated sentences and provides ontology-based gap-filling suggestions how to complete unverbalized information in the user’s demand.
Abstract: One purpose of requirement refinement is that higher-level requirements have to be translated to something usable by developers. Since customer requirements are often written in natural language by end users, they lack precision, completeness and consistency. Although user stories are often used in the requirement elicitation process in order to describe the possibilities how to interact with the software, there is always something unspoken. Here, we present techniques how to automatically refine vague software descriptions. Thus, we can bridge the gap by first revising natural language utterances from higher-level to more detailed customer requirements, before functionality matters. We therefore focus on the resolution of semantically incomplete user-generated sentences (i.e. non-instantiated arguments of predicates) and provide ontology-based gap-filling suggestions how to complete unverbalized information in the user’s demand.

Proceedings ArticleDOI
01 Aug 2016
TL;DR: The results show that the use of annotations in planning poker increases estimation accuracy, and it is proposed to annotate user stories with symbols that highlight risk and effort drivers to give all team members a better understanding of a project's challenges.
Abstract: The accuracy of effort estimates is an important factor for the success of a project. In agile projects, these estimates are often obtained through the structured group estimation process of planning poker. To increase the accuracy of such estimates, we propose to annotate user stories with symbols that highlight risk and effort drivers and thus give all team members a better understanding of a project's challenges. In this paper, we report on the results of a study that examines the effect of using risk and effort annotations on project teams' level of shared understanding, estimation accuracy and estimation bias. Our results show that the use of annotations in planning poker increases estimation accuracy.

Proceedings ArticleDOI
18 Feb 2016
TL;DR: This paper describes the process used by a separate team formed to reduce technical debt in a large legacy system using pragmatic approach and presents holistic lifecycle approach with four stages and various practices in each stage for managing technical debt.
Abstract: Tackling the issues of technical debt in a large system in parallel with continuing to enable it to evolve is a challenging problem.In this paper, we are describing a case study of managing technical debt on a legacy project referred here as Global Configurator Project (GCP) using pragmatic approach. The paper presents holistic lifecycle approach with four stages and various practices in each stage for managing technical debt. Given life cycle approach and practices will be useful for any software project. In particular, these practices will be significant to any legacy project towards repaying debt. These methods can also be applied to continuously improve code quality and product quality. This paper also focus on technical debt user stories to gain business buy-in and share few 'best in market' tools that we used in repaying technical debt. It also focuses on sensitizing developers to the concept of debt and improving their skills. This paper describes the process used by a separate team formed to reduce technical debt in a large legacy system.The paper targets to the Project Managers, Test Managers architects and Scrum Masters in agile software development.

Journal ArticleDOI
TL;DR: Use-Case 2.0 as mentioned in this paper is the new generation of use-case-driven development-light, agile, and lean-inspired by user stories and the agile methodologies Scrum and Kanban.
Abstract: Use cases have been around for almost 30 years as a requirements approach and have been part of the inspiration for more-recent techniques such as user stories. Now the inspiration has flown in the other direction. Use-Case 2.0 is the new generation of use-case-driven development-light, agile, and lean-inspired by user stories and the agile methodologies Scrum and Kanban.