Search

Requirements engineering (RE) has attracted a great deal of attention from researchers and practitioners in recent years. Requirements engineering education (REE) is therefore an important undertaking if the field is to have professionals who are capable of successfully accomplishing software projects. This increasing interest demands that academia should provide software engineering students with a solid foundation in the subject matter. This paper aims to identify and to present the current research on REE that is available at present, and to select useful approaches and needs for future research. A systematic mapping study was therefore performed to classify the selected studies into five classification criteria: research type, empirical type, contribution type, RE activity, and curricula. A total of 79 papers were selected and classified according to these criteria. The results of this systematic mapping study are discussed, and a list of advice obtained from the REE literature for instructors is provided. [ABSTRACT FROM AUTHOR]

Machine Learning (ML) algorithms are widely used in building software-intensive systems, including safety-critical ones. Unlike traditional software components, Machine-Learned Components (MLC)s, software components built using ML algorithms, learn their specifications through generalizing the common features that they find in a limited set of collected examples. While this inductive nature overcomes the limitations of programming hard-to-specify concepts, the same feature becomes problematic for verifying safety in ML-based software systems. One reason is that, due to MLCs data-driven nature, there is often no set of explicitly written and pre-defined specifications, against which the MLC can be verified. In this regard, we propose to partially specify hard-to-specify domain concepts, which MLCs tend to classify, instead of fully relying on their inductive learning ability from arbitrarily-collected datasets. In this paper, we propose a semi-automated approach to construct a multi-level semantic web to partially outline the hard-to-specify, yet crucial, domain concept "pedestrian" in automotive domain. We evaluate the applicability of the generated semantic web in two ways: first, with a reference to the web, we augment a pedestrian dataset for a missing feature, wheelchair, to show training a state-of-the-art ML-based object detector on the augmented dataset improves its accuracy in detecting pedestrians; second, we evaluate the coverage of the generated semantic web based on multiple state-of-the-art pedestrian and human datasets. [ABSTRACT FROM AUTHOR]

In this paper, we describe a novel unsupervised approach for detecting, classifying, and tracing non-functional software requirements (NFRs). The proposed approach exploits the textual semantics of software functional requirements (FRs) to infer potential quality constraints enforced in the system. In particular, we conduct a systematic analysis of a series of word similarity methods and clustering techniques to generate semantically cohesive clusters of FR words. These clusters are classified into various categories of NFRs based on their semantic similarity to basic NFR labels. Discovered NFRs are then traced to their implementation in the solution space based on their textual semantic similarity to source code artifacts. Three software systems are used to conduct the experimental analysis in this paper. The results show that methods that exploit massive sources of textual human knowledge are more accurate in capturing and modeling the notion of similarity between FR words in a software system. Results also show that hierarchical clustering algorithms are more capable of generating thematic word clusters than partitioning clustering techniques. In terms of performance, our analysis indicates that the proposed approach can discover, classify, and trace NFRs with accuracy levels that can be adequate for practical applications. [ABSTRACT FROM AUTHOR]

In software reuse, the reuse of UML class diagram produced in design phase has received more attention due to the important influence on the following developing process. The reuse is based on similarity. The similarity between class diagrams contains semantic and structural aspects. The existing works focus on semantic similarity, while the structural similarity is little paid attention to. The structure of class diagram can be categorized into two aspects: intra-structure and inter-structure. The intra-structure refers to the composition of each class, and the inter-structure is represented as the relationships between classes. So, the structural similarity measure should be carried out from these two aspects. In this paper, we propose to use a graph named UML class graph (UCG) to represent a class diagram for the structural similarity measure. An algorithm based on UCG Maximum Common Subgraph Sequence is proposed for the inter-structure similarity measure, and UCG edit distance is proposed and introduced to the intra-structure similarity measure. The experimental results show that our proposed approach is effective within a domain or across domains. [ABSTRACT FROM AUTHOR]

There is a general consensus on the importance of good requirements engineering for achieving high-quality software. Functional requirements capture the intended behavior of the system in terms of services, tasks, or functions the system is required to perform, while non-functional requirements capture required properties of the system, such as timing, performance, and security. These non-functional requirements play a crucial role during system development life cycle serving as selection criteria for choosing among myriads of design decisions. The ability to model and validate the system non-functional properties at the requirements level supports the detection of design errors during the early stages of a software development life cycle and helps reduce the cost of later redesign activities. The widespread interest in time modeling and analysis techniques at the requirements phase provides the major motivation for this research. This paper presents a novel and fully automated approach to describe and validate high-level timed requirements using the Timed Use Case Maps language. We extend the, ITU-T standard User Requirements Notation, Use Case Maps metamodel with time requirements. The resulting extensions are implemented within the jUCMNav tool and formalized using Abstract State Machines allowing for automated simulation and analysis. We illustrate the applicability of our approach using a business process model (conference review process model) and a real-time system model (IP multicast routing case study). [ABSTRACT FROM AUTHOR]

Software requirements are often not set in concrete at the start of a software development project; and requirement changes become necessary and sometimes inevitable due to changes in customer requirements and changes in business rules and operating environment; hence, requirements development, which includes requirements changes, is a part of a software process. Previous research reports that correcting requirements errors late costs many times more than correcting them during the requirements development phase. There is, hence, a need to manage them well and to analyse them in order to identify the impacts, difficulties and potential conflicts with existing requirements. Most studies on requirements change analysis are done at the source code level while paying less attention to the initiation of changes at a higher level. In this paper, we present a method of requirements change analysis based on the changes themselves which are initiated at higher levels. This method consists of three steps: namely (1) analysing the change using functions, (2) identifying the change difficulty and (3) identifying the dependencies using a matrix. We illustrate the usefulness of our method by applying it to a course management system of a university. [ABSTRACT FROM AUTHOR]

Rationale refers to the reasoning and justification behind human decisions, opinions, and beliefs. In software engineering, rationale management focuses on capturing design and requirements decisions and on organizing and reusing project knowledge. This paper takes a different view on rationale written by users in online reviews. We studied 32,414 reviews for 52 software applications in the Amazon Store. Through a grounded theory approach and peer content analysis, we investigated how users argue and justify their decisions, e.g., about upgrading, installing, or switching software applications. We also studied the occurrence frequency of rationale concepts such as issues encountered or alternatives considered in the reviews and found that assessment criteria like performance, compatibility, and usability represent the most pervasive concept. We identified a moderate positive correlation between issues and criteria and furthermore assessed the distribution of rationale concepts with respect to rating and verbosity. We found that issues tend to appear more in lower star rated reviews, while criteria, alternatives, and justifications seem to appear more in three star rated reviews. Also, reviews reporting alternatives seem to be more verbose than reviews reporting criteria. A follow-up qualitative study of sub-concepts revealed, that users also report other alternatives (e.g., alternative software provider), criteria (e.g., cost), and decisions (e.g., on rating software). We then used the truth set of manually labeled review sentences to explore how accurately we can mine rationale concepts from the reviews. We evaluated the classification algorithms Naive Bayes, Support Vector Machine, Logistic Regression, Decision Tree, Gaussian Process, Random Forest, and Multilayer Perceptron Classifier using a baseline and random configuration. Support Vector Classifier, Naive Bayes, and Logistic Regression, trained on the review metadata, syntax tree of the review text, and influential terms, achieved a precision around 80% for predicting sentences with alternatives and decisions, with top recall values of 98%. On the review level, precision was up to 13% higher with recall values reaching 99%. Using only word features, we achieved in most cases the highest precision and highest recall respectively using the Random Forest and Naive Bayes algorithm. We discuss the findings and the rationale importance for supporting deliberation in user communities and synthesizing the reviews for developers. [ABSTRACT FROM AUTHOR]

Global software development (GSD), where software teams are located in different parts of the world, has become increasingly popular. To devise a high-quality software requirements specification (SRS), effective communication and collaboration between stakeholders are necessary for GSD. However, geographical distance, cultural diversity, differences in time zones and language barriers create difficulties for stakeholders in engaging in effective collaboration. Taking into consideration the factors involved in GSD, previous research showed that the ways by which requirements are documented and validated for collocated software development projects cannot be used effectively for GSD. In this paper, we present a method of GSD requirements specification and validation. Our method begins with generating a requirements graph to understand details of the software requirements with respect to different GSD sites. The information obtained from a requirements graph is to be contained in a requirements specification document, and then be circulated between different GSD sites for reviewing, updating and finalizing its content. Finally, the requirements contained in the specification document are to be validated by generating and comparing validation matrices at different GSD sites. Past researchers used student groups in a university environment to play the roles of stakeholders in experiments in GSD studies. We therefore validate our method by applying it to a case study of an online shopping system, where the roles of stakeholders were played by a group of students. [ABSTRACT FROM AUTHOR]

Software reuse can be defined as the process of creating software products from the existing ones rather than developing software from scratch. Thus, software reuse is normally proposed to increase software productivity and quality and leads to economic benefits. In this sense, the reuse of software requirements has received important attention because it provides a solid support to develop quality software through obtaining and reusing quality software requirements [i.e., software product line (SPL) approach used in large-sized software enterprises]. However, the small-sized enterprises-which represent up to 85 % of all software organizations in many countries around the world-cannot implement a SPL approach because it does not fit with the context, properties, and complexity of their software projects. Moreover, the software engineering community has not adequately explored a more proper approach in the context of small-sized software enterprises. The use of a software requirements catalog could be this proper approach. In this context, the aim of this paper was to introduce the requirements reuse model for software requirements catalog (RRMSRC). Also, a set of guidelines to perform the main activities defined for reusing functional requirements within small-sized software enterprises is provided. As evidence of its feasibility, RRMSRC has been used in an industrial context, and the obtained results and learned lessons are summarized. [ABSTRACT FROM AUTHOR]

This paper proposes an explicit definition of green software requirements and a tool to support their evaluation . The proposed evaluation tool describes the green efficiency by considering the energy consumption as the main aspect to be studied during the development stage. This approach consists of building a multiple regression model, by using a supervised learning algorithm, in order to reproduce the energy consumption pattern of devices at different workload circumstances. The energy consumption model is then deployed to estimate the impact of software applications based on their resource usage. Our work has been validated on desktop and mobile devices. The experiments show the effectiveness of the proposed energy profiling tool that provided relevant information on the energy consumption of software applications. [ABSTRACT FROM AUTHOR]

Large-scale software applications are complex systems that involve a myriad of different concerns. Ideally, these concerns should be organized into separated and different modules, but often some of these concerns overlap and crosscut each other. Such a situation is problematic, as concerns are tangled and scattered into different modules; thus, design and source code become difficult to produce and maintain. The Modularity community has been addressing crosscutting concerns by developing techniques based on separation of concerns. This separation must be done as early as possible during software construction to obtain a more modular and consequently better maintainable software, where evolution is performed with less effort and the possibility of introducing unforeseen mistakes is minimal. In this paper, we propose a strategy to identify crosscutting concerns at requirements level, i.e., at early stages in the software development process, by using the Language Extended Lexicon. [ABSTRACT FROM AUTHOR]

Requirements engineering is one of the most important areas of software engineering because it enables practitioners to determine the characteristics and constraints of the software to be developed. Therefore, the requirements elicitation process aims to obtain a preliminary version of the requirements before their specification, but it is difficult to know if the elicited requirements have the desired attributes (i.e., these requirements are complete, correct, consistent, etc.) due to the nature of this process. There are some measures that allow requirements engineers to quantify certain aspects of the requirements elicitation process and its final product (i.e., the preliminary version of the requirements, also known as preliminary requirements), but there is no way of measuring and controlling the quality of the elicited preliminary requirements. With the aim of understanding, evaluating, and improving the activities of the requirements elicitation process, some of the existing measures for this process were analyzed and, consequently, a case study was conducted to define and implement a measurement program with a set of eight measures that are proposed in this study. This program is based on the ISO/IEC/IEEE 15939:2017—systems and software engineering—measurement process, an international standard that establishes a common process and framework for the measurement of systems and software. The measurement program corresponds to a lightweight implementation of the standard in the context of a small-sized software organization (where the size of the software staff is 11–50 people, the size of projects is 50,000–100,000 LOC, and the time spent on the projects is six to twelve months) and the obtained results showed a preliminary positive influence when obtaining high-quality preliminary requirements. [ABSTRACT FROM AUTHOR]

Recommender systems for requirements are typically built on the assumption that similar requirements can be used as proxies to retrieve similar software. When a stakeholder proposes a new requirement, natural language processing (NLP)-based similarity metrics can be exploited to retrieve existing requirements, and in turn, identify previously developed code. Several NLP approaches for similarity computation between requirements are available. However, there is little empirical evidence on their effectiveness for code retrieval. This study compares different NLP approaches, from lexical ones to semantic, deep-learning techniques, and correlates the similarity among requirements with the similarity of their associated software. The evaluation is conducted on real-world requirements from two industrial projects from a railway company. Specifically, the most similar pairs of requirements across two industrial projects are automatically identified using six language models. Then, the trace links between requirements and software are used to identify the software pairs associated with each requirements pair. The software similarity between pairs is then automatically computed with JPLag. Finally, the correlation between requirements similarity and software similarity is evaluated to see which language model shows the highest correlation and is thus more appropriate for code retrieval. In addition, we perform a focus group with members of the company to collect qualitative data. Results show a moderately positive correlation between requirements similarity and software similarity, with the pre-trained deep learning-based BERT language model with preprocessing outperforming the other models. Practitioners confirm that requirements similarity is generally regarded as a proxy for software similarity. However, they also highlight that additional aspect comes into play when deciding software reuse, e.g., domain/project knowledge, information coming from test cases, and trace links. Our work is among the first ones to explore the relationship between requirements and software similarity from a quantitative and qualitative standpoint. This can be useful not only in recommender systems but also in other requirements engineering tasks in which similarity computation is relevant, such as tracing and change impact analysis. [ABSTRACT FROM AUTHOR]

Many software users give feedback online about the applications they use. This feedback often contains valuable requirements information that can be used to guide the effective maintenance and evolution of a software product. Yet, not all software users give online feedback. If the demographics of a user-base aren't fairly represented, there is a danger that the needs of less vocal users won't be considered in development. This work investigates feedback on three prominent online channels: app stores, product forums, and social media. We directly survey software users about their feedback habits, as well as what motivates and dissuades them from providing feedback online. In an initial survey of 1040 software users, we identify statistically significant differences in the demographics of users who give feedback (gender, age, etc.), and key differences in what motivates them to engage with each of the three studied channels. In a second survey of 936 software users, we identify the top reasons users don't give feedback, including significant differences between demographic groups. We also present a detailed list of user-rated methods to encourage their feedback. This work provides meaningful context for requirements sourced from online feedback, identifying demographic groups who are underrepresented. Findings on what motivates and discourages user feedback give insight into how feedback channels and developers can increase engagement with their user-base. [ABSTRACT FROM AUTHOR]

A correction to this paper has been published: https://doi.org/10.1007/s00766-021-00354-4 [ABSTRACT FROM AUTHOR]

Expert judgement is a common method for software effort estimations in practice today. Estimators are often shown extra obsolete requirements together with the real ones to be implemented. Only one previous study has been conducted on if such practices bias the estimations. We conducted six experiments with both students and practitioners to study, and quantify, the effects of obsolete requirements on software estimation. By conducting a family of six experiments using both students and practitioners as research subjects ( N = 461 ), and by using a Bayesian Data Analysis approach, we investigated different aspects of this effect. We also argue for, and show an example of, how we by using a Bayesian approach can be more confident in our results and enable further studies with small sample sizes. We found that the presence of obsolete requirements triggered an overestimation in effort across all experiments. The effect, however, was smaller in a field setting compared to using students as subjects. Still, the over-estimations triggered by the obsolete requirements were systematically around twice the percentage of the included obsolete ones, but with a large 95% credible interval. The results have implications for both research and practice in that the found systematic error should be accounted for in both studies on software estimation and, maybe more importantly, in estimation practices to avoid over-estimations due to this systematic error. We partly explain this error to be stemming from the cognitive bias of anchoring-and-adjustment, i.e. the obsolete requirements anchored a much larger software. However, further studies are needed in order to accurately predict this effect. [ABSTRACT FROM AUTHOR]

App features are one of the most important factors that people consider when choosing apps. In order to satisfy users' needs and attract their eyes, deciding what features should be added in next release becomes very important. Different from traditional requirement elimination, app stores provide a new platform for developers to gather requirements and perform market-wide analysis. Considering that software features provided to users can be found out by exploring existing apps, an important way to elicit requirements is analyzing existing features provided by products which offer related functions and then finding new trends and fashions promptly. In this context, we propose a data-driven approach for recommending software features of mobile applications based on user interface comparison. Our approach mines similar user interfaces (UIs) from publicly available online repository. To calculate UI similarity through the best matches of components of two UIs, text similarity is used to measure the similarity of UI components and genetic algorithm is introduced to improve the comparison efficiency. Then, we develop an algorithm to extract features from similar UIs based on a set of identification rules. These features are further clustered with text similarity algorithm and finally recommended to developers. The approach is empirically validated with 44 features from 10 UIs. The experiment results indicate that our recommended features are valuable for requirement elicitation. [ABSTRACT FROM AUTHOR]

Understanding and keeping the customer happy is a central tenet of requirements engineering. Strategies to gather, analyze, and negotiate requirements are complemented by efforts to manage customer input after products have been deployed. For the latter, support tickets are key in allowing customers to submit their issues, bug reports, and feature requests. If insufficient attention is given to support issues, however, their escalation to management becomes time-consuming and expensive, especially for large organizations managing hundreds of customers and thousands of support tickets. Our work provides a step toward simplifying the job of support analysts and managers, particularly in predicting the risk of escalating support tickets. In a field study at our large industrial partner, IBM, we used a design science research methodology to characterize the support process and data available to IBM analysts in managing escalations. In a design science methodology, we used feature engineering to translate our understanding of support analysts’ expert knowledge of their customers into features of a support ticket model. We then implemented these features into a machine learning model to predict support ticket escalations. We trained and evaluated our machine learning model on over 2.5 million support tickets and 10,000 escalations, obtaining a recall of 87.36% and an 88.23% reduction in the workload for support analysts looking to identify support tickets at risk of escalation. Further on-site evaluations, through a prototype tool we developed to implement our machine learning techniques in practice, showed more efficient weekly support ticket management meetings. Finally, in addition to these research evaluation activities, we compared the performance of our support ticket model with that of a model developed with no feature engineering; the support ticket model features outperformed the non-engineered model. The artifacts created in this research are designed to serve as a starting place for organizations interested in predicting support ticket escalations, and for future researchers to build on to advance research in escalation prediction. [ABSTRACT FROM AUTHOR]

A significant impediment to the uptake of formal refinement-based methods among practitioners is the challenge of validating that the formal specifications of these methods capture the desired intents. Animation of specifications is widely recognized as an effective way of addressing such validation. However, animation tools are unable to directly execute (and thus animate) the typical uses of several of the specification constructs often found in ideal formal specifications. To address this problem, we have developed transformation heuristics that, starting with an ideal formal specification, guide its conversion into an animatable form. We show several of these heuristics and address the need to prove that the application of these transformations preserves the relevant behavior of the original specification. Portions of several case studies illustrate this approach. [ABSTRACT FROM AUTHOR]

Until now, quality assessment of requirements has focused on traditional up-front requirements. Contrasting these traditional requirements are just-in-time (JIT) requirements, which are by definition incomplete, not specific and might be ambiguous when initially specified, indicating a different notion of "correctness." We analyze how the assessment of JIT requirements quality should be performed based on the literature of traditional and JIT requirements. Based on that analysis, we have designed a quality framework for JIT requirements and instantiated it for feature requests in open source projects. We also indicate how the framework can be instantiated for other types of JIT requirements. We have performed an initial evaluation of our framework for feature requests with eight practitioners from the Dutch agile community, receiving overall positive feedback. Subsequently, we have used our framework to assess 550 feature requests originating from three Open Source Software systems (Netbeans, ArgoUML and Mylyn Tasks). In doing so, we obtain a view on the feature request quality for the three open source projects. The value of our framework is threefold: (1) it gives an overview of quality criteria that are applicable to feature requests (at creation time or JIT); (2) it serves as a structured basis for teams that need to assess the quality of their JIT requirements; and (3) it provides a way to get an insight into the quality of JIT requirements in existing projects. [ABSTRACT FROM AUTHOR]

The importance of prioritizing requirements stems from the fact that not all requirements can usually be met with available time and resource constraints. Efficient and trustworthy methods for prioritizing requirements are therefore in high demand. In this article, we present results of a systematic mapping study in order to appreciate the different considerations that have influenced prioritization of software requirements, identify the various types of artifacts proposed toward prioritizing software requirements, and examine certain characterizations of these artifacts. The results emphasize the heightened attention the domain of requirement prioritization has received in recent years. On the basis of this study, we are able to provide the following inferences regarding possible future research trajectories in software requirement prioritization artifacts: (1) focus on frameworks and tools; (2) emphasis on specialization; and (3) proposition of theory-based artifacts. Additional research possibilities are also pointed out at the end and are expected to stimulate further research on the topic. [ABSTRACT FROM AUTHOR]