Requirements Artifacts Research Articles

Query expansion using novel use case scenario relationship for finding feature location

<span lang="EN-US">Feature location is a technique for determining source code that implements specific features in software. It developed to help minimize effort on program comprehension. The main challenge of feature location research is how to bridge the gap between abstract keywords in use cases and detail in source code. The use case scenarios are software requirements artifacts that state the input, logic, rules, actor, and output of a function in the software. The sentence on use case scenario is sometimes described another sentence in other use case scenario. This study contributes to creating expansion queries in feature locations by finding the relationship between use case scenarios. The relationships include inner association, outer association and intratoken association. The research employs latent Dirichlet allocation (LDA) to create model topics on source code. Query expansion using inner, outer and intratoken was tested for finding feature locations on a Java-based open-source project. The best precision rate was 50%. The best recall was 100%, which was found in several use case scenarios implemented in a few files. The best average precision rate was 16.7%, which was found in inner association experiments. The best average recall rate was 68.3%, which was found in all compound association experiments.</span>

Towards asset administration shell-based continuous engineering in process industries

Abstract In this work we emphasize the role of the engineering process within the industrial automation domain and its underrepresentation in the Industry 4.0 community possibly explained by discrete roots of Industry 4.0. Towards this aim, we revisit the value chain on the leading picture of Industry 4.0 and indicate gaps for “design-to-order” products and projects where requirement artifacts like Piping and Instrumentation Diagrams (P&IDs) or tag lists are exchanged prior to selecting, ordering and building the actual plant. After the understanding of the importance of the engineering process, we explore the opportunities of using Industry 4.0 technology stack to embed engineering information into the digital twin of a process plant. We underline possible synergies with the current developments of the Industry 4.0 community, like the Data Exchange in the Process Industry (DEXPI) and the Module Type Package (MTP) submodel template definitions. Finally, we present possible best practices for embedding existing engineering-related standards into the Industry 4.0 ecosystem and propose tactics and mechanisms for information modeling to accomplish this task in a most efficient and reusable way.

Identifying Key Activities, Artifacts and Roles in Agile Engineering of Secure Software with Hierarchical Clustering

Different activities, artifacts, and roles can be found in the literature on the agile engineering of secure software (AESS). The purpose of this paper is to consolidate them and thus identify key activities, artifacts, and roles that can be employed in AESS. To gain initial sets of activities, artifacts, and roles, the literature was first extensively reviewed. Activities, artifacts, and roles were then cross-evaluated with similarity matrices. Finally, similarity matrices were converted into distance matrices, enabling the use of Ward’s hierarchical clustering method for consolidating activities, artifacts, and roles into clusters. Clusters of activities, artifacts, and roles were then named as key activities, artifacts, and roles. We identified seven key activities (i.e., security auditing, security analysis and testing, security training, security prioritization and monitoring, risk management, security planning and threat modeling; and security requirements engineering), five key artifacts (i.e., security requirement artifacts, security repositories, security reports, security tags, and security policies), and four key roles (i.e., security guru, security developer, penetration tester, and security team) in AESS. The identified key activities, artifacts, and roles can be used by software development teams to improve their software engineering processes in terms of software security.

Automatic creation of acceptance tests by extracting conditionals from requirements: NLP approach and case study

Acceptance testing is crucial to determine whether a system fulfills end-user requirements. However, the creation of acceptance tests is a laborious task entailing two major challenges: (1) practitioners need to determine the right set of test cases that fully covers a requirement, and (2) they need to create test cases manually due to insufficient tool support. Existing approaches for automatically deriving test cases require semi-formal or even formal notations of requirements, though unrestricted natural language is prevalent in practice. In this paper, we present our tool-supported approach CiRA (Conditionals in Requirements Artifacts) capable of creating the minimal set of required test cases from conditional statements in informal requirements. We demonstrate the feasibility of CiRA in a case study with three industry partners. In our study, out of 578 manually created test cases, 71.8 % can be generated automatically. Additionally, CiRA discovered 80 relevant test cases that were missed in manual test case design. CiRA is publicly available at www.cira.bth.se/demo/.

Causality in requirements artifacts: prevalence, detection, and impact

Causal relations in natural language (NL) requirements convey strong, semantic information. Automatically extracting such causal information enables multiple use cases, such as test case generation, but it also requires to reliably detect causal relations in the first place. Currently, this is still a cumbersome task as causality in NL requirements is still barely understood and, thus, barely detectable. In our empirically informed research, we aim at better understanding the notion of causality and supporting the automatic extraction of causal relations in NL requirements. In a first case study, we investigate 14.983 sentences from 53 requirements documents to understand the extent and form in which causality occurs. Second, we present and evaluate a tool-supported approach, called CiRA, for causality detection. We conclude with a second case study where we demonstrate the applicability of our tool and investigate the impact of causality on NL requirements. The first case study shows that causality constitutes around 28 % of all NL requirements sentences. We then demonstrate that our detection tool achieves a macro-hbox {F}_{1} score of 82 % on real-world data and that it outperforms related approaches with an average gain of 11.06 % in macro-Recall and 11.43 % in macro-Precision. Finally, our second case study corroborates the positive correlations of causality with features of NL requirements. The results strengthen our confidence in the eligibility of causal relations for downstream reuse, while our tool and publicly available data constitute a first step in the ongoing endeavors of utilizing causality in RE and beyond.

A Framework for Aspectual Requirements Validation: an Experimental Study

Requirements engineering is a discipline of software engineering that is concerned with the identification and handling of user and system requirements. Aspect-Oriented Requirements Engineering (AORE) extends the existing requirements engineering approaches to cope with the issue of tangling and scattering resulted from crosscutting concerns. Crosscutting concerns are considered as potential aspects and can lead to the phenomena “tyranny of the dominant decomposition”. Requirements-level aspects are responsible for producing scattered and tangled descriptions of requirements in the requirements document. Validation of requirements artefacts is an essential task in software development. This task ensures that requirements are correct and valid in terms of completeness and consistency, hence, reducing the development cost, maintenance and establish an approximately correct estimate of effort and completion time of the project. In this paper, we present a validation framework to validate the aspectual requirements and the crosscutting relationship of concerns that are resulted from the requirements engineering phase. The proposed framework comprises a high-level and low-level validation to implement on software requirements specification (SRS). The high-level validation validates the concerns with stakeholders, whereas the low-level validation validates the aspectual requirement by requirements engineers and analysts using a checklist. The approach has been evaluated using an experimental study on two AORE approaches. The approaches are viewpoint-based called AORE with ArCaDe and lexical analysis based on Theme/Doc approach. The results obtained from the study demonstrate that the proposed framework is an effective validation model for AORE artefacts.

Empirical studies on software traceability: A mapping study

AbstractDuring the last decades, software traceability has been studied in a large number of studies, from different perspectives (e.g., how to create traces and what are its benefits). This large body of knowledge needs to be better explored and exploited by both practitioners and researchers: We need an overview of different aspects of traceability and a structured way to assess and compare existing work in order to extend it with new research or apply it in practice, Thus, we have conducted a secondary study on this large corpus of primary studies, focusing on empirical studies on software traceability, without setting any further restrictions in terms of investigating a specific domain or concrete artifacts. The study explores the goals of existing approaches and the empirical methods used for their evaluation. Its main contributions are the investigation of (a) the type of artifacts linked through traceability approaches; (b) the benefits of using artifact traceability approaches; (c) the ways of measuring their benefit; and (d) the research methods used. The results of the study suggest that (i) requirements artifacts are dominant in traceability; (ii) the research corpus focuses on the proposal of novel techniques for establishing traceability; and (iii) the main benefits are the improvement of software correctness and maintainability. Finally, although many studies include some empirical validation, there is still room for improvements and research methods that can be used more extensively. The obtained results are discussed under the prism of both researchers and practitioners and are compared against the state‐of‐the‐art.

Wiki support for automated definition of software test cases

PurposeThe design of tests is a very important step in the software development process because it allows us to match the users’ expectations with the finished product. Considered as a cumbersome activity, efforts have been made to automatize and alleviate the burden of test generation, but it is still a largely neglected step. The study aims to propose taking advantage of existing requirement artifacts, like scenarios that describe the dynamic of the domain in a very early stage of software development, to obtain tests from them.Design/methodology/approachIn particular, the approach proposed complement the scenarios that are textually described with a glossary, the language extended lexicon. Thus, a set of rules to derive tests from scenarios is also proposed. The tests are then described using the task/method model.FindingsThe main findings of this study consist of an extension of a previously presented set of rules. And, a tool based on a media wiki platform that makes possible to record scenarios and the language extended lexicon and implement the rules to obtain the tests.Originality/valueThe main originality of this study is the glossary which complements scenarios, the semantic support to obtain tests and the tool to automatize the approach.

Recovering semantic traceability between requirements and design for change impact analysis

One of the ultimate challenges in change impact analysis is traceability modeling between several software artifacts in the software life cycle. This paper proposes a traceability approach that relates requirements and design artifacts modeled in UML. Our method faces two essential challenges: the semantic ambiguities of requirement artifacts that could be written in different natural languages and the heterogeneity of the artifacts that have to be traced (textual description, UML diagrams, etc.). To face these challenges, our method determines the semantic relationships between the requirements modeled with the use case diagram and design modeled with the class and the sequence diagrams through a semantic model which is an intelligent natural language processing technique that analyzes the semantics among the sentences, regardless of the language they are written with. Thanks to the semantic model our approach compares similarities between words having the same role, which makes it more efficient than computing similarities between words of different kinds. The empirical investigation demonstrates the advantages of the semantic traceability using a semantic model compared to the use of an information retrieval technique.

An Ontology-based Approach to Support for Requirements Traceability in Agile Development

The paper proposes an ontology-based approach to support for requirements traceability in Agile development. The task of supporting the requirements traceability in a software development project is considered as a part of requirements engineering process. A brief overview of the benefits of requirements traceability usage is given. The expediency of using the ontology-based approach to support for requirements engineering, requirements traceability in particular, is shown through the analysis of scientific publications. OWL ontology is chosen to support the requirements engineering process. The ontology is implemented in the Protégé environment. The developed ontology takes into account particular qualities of working with the requirements in Agile projects, accumulates knowledge about the requirements types and requirements artefacts, enables tracing the relations between them.

Annotation of Software Requirements Specification (SRS), Extractions of Nonfunctional Requirements, and Measurement of Their Tradeoff

Software requirement artifacts such as manuals request for proposals, and software requirements specification (SRS) are commonly focused on functional requirements. In most SRS files, nonfunctional requirements do not formally encoded or encoded as a whole, not for an individual design problem. Moreover, these nonfunctional requirements are intermingled with functional requirements. Therefore, these nonfunctional requirements need special attention to understand for successful project development. These nonfunctional requirements have an impact on each other and optimal tradeoff is required for balanced nonfunctional requirements set. NFRs have a negative and positive tradeoff with each other such as increase confidentiality, decrease the availability, and enhance authenticity. So, an optimum tradeoff among these design problem within a module is required to have better design decisions. Instead of considering all nonfunctional requirements, the NFRs that have mutual tradeoff is considered. In this paper, we devised a novel document annotation scheme for SRS and extracted nonfunctional requirements from these annotated artifacts. In the next step, we classified NFRs into two classes security triad and performance triad, and the cost is assumed constant for each NFR. From the design problem, the tradeoff ratio is calculated among NFRs associated with it. Then, the production possibility graph is plotted to estimate the optimum tradeoff ratio within the module. For estimation economic optimum from a set of NFR, iso-cost graphs by assuming the constant cost. Some hypothetical variations in cost are also examined using 3D iso-cost graph. The reason to measure these tradeoff is to make design decision more empirical and helpful for the selection of design patterns, especially secure design patterns.

СИСТЕМА ПОДДЕРЖКИ ПРИНЯТИЯ РЕШЕНИЙ ПРИ ГИБКОМ ПОДХОДЕ К ИНЖЕНЕРИИ ТРЕБОВАНИЙ НА ОСНОВЕ OWL-ОНТОЛОГИИ

The article proposes the approach to intellectual decision support in the field of software requirements engineering based on OWL-ontology. The approach presented takes into account the specifics of requirements engineering for agile project management. The architecture of the developed decision support system consists of a user interface, a Python application including the reasoner, the OWL ontology and the file database. OWL ontology accumulates knowledge about the criteria for assessing the quality of requirements. The ontology enables accumulating in the form of instances of class’s information about the software product requirements, requirements artefacts, and requirements sources. The ontology includes the axioms of descriptor logic, enabling to perform reasoning about the requirements, to identify the implicit relations between the requirements. The ontology includes the knowledge that is necessary to analyze the correspondence of user stories and behavior scenarios to the criteria for evaluating their syntactic quality, to determine the priority and risk level of user stories. Also, the ontology enables bottom-up or top-down tracing of requirements and assessing the completeness of individual requirements. Application of the developed system ensures to lessen the wrong decisions number with management of requirements to the software.

Understanding information needs of agile teams to improve requirements communication

Abstract For traditional software development processes, we have detailed empirical knowledge about role-specific information needs that have to be satisfied in requirements documents. Particularly, we gained detailed knowledge about priorities of a set of traditional requirements artifacts in a series of empirical studies from the viewpoint of software architects, usability engineers, and testers. However, little is known about such information needs from the viewpoint of agile team members. Motivated by the widespread use of agile development approaches and existing challenges faced by requirements engineering in agile projects, our current research aims at investigating whether agile teams could also benefit from the empirical results regarding information needs that we gained in our previous research. We envision the development of guidelines based on empirical data in order to support the extensive collaboration and communication necessary in agile projects. In this paper, we present our research agenda as well as first results of our work. This includes a mapping analyis by the authors where the scope and content of the outcome of agile RE practices (e.g., user stories) was compared to previously investigated traditional RE artifacts. This analysis shows that artifacts resulting from agile practices cover key requirements information, but at a lower level of detail than in traditional RE artifacts. Based on these first findings, we conducted interviews and performed surveys with agile team members in order to better understand current challenges and the possible impacts of these challenges. The results reveal that, for instance, less detailed documentation leads to problems such as communication lapses, rework and product inconsistencies in agile settings. We also gained first insights regarding the relevance of agile RE practices from the viewpoint of different agile team members. Finally, we elaborated initial guidelines to be used and evaluated within the scope of industry and research projects in the near future.

Size and Effort Estimation Based on Problem Domain Measures for Object-Oriented Software

This paper analyzes the correlations between the problem domain measures such as the number of distinct nouns and distinct verbs in the requirements artifacts and the solution domain measures such as the number of software classes and methods in the corresponding object-oriented software. For this purpose, 14 completed software development projects of a CMMI Level-3 certified defense industry company have been analyzed. The observed strong correlation is taken as the indication of linear relationship between the measures and a size estimation model based on linear regression analysis is proposed. Prediction performance of the method is analyzed on the 14 software projects. Moreover, it has been observed that there is a high correlation between the problem domain measures and the development effort. Therefore, the linear regression analysis is also used to estimate the effort in terms of the problem domain measures. The effort estimations are also evaluated and compared with the efforts predicted using the size measured by the COSMIC Function Point (CFP) method. The results show that the proposed method provides more accurate effort estimates compared to the effort estimated by using CFP size measurement.

Text Categorization Approach for Secure Design Pattern Selection Using Software Requirement Specification

Secure patterns provide a solution for the security requirement of the software. There are large number of secure patterns, and it is quite difficult to choose an appropriate pattern. Moreover, selection of these patterns needs security knowledge; generally, developers are not specialized in the domain of security knowledge. This paper can help in the selection of secure pattern on the basis of tradeoffs of the secure pattern using text categorization. A repository of secure design patterns is used as a data set and a repository of requirements artifacts in the form of software requirements specification (SRS) are used for this paper. A text categorization scheme, which begins with preprocessing, indexing of secure patterns, ends up by querying SRS features for retrieving secure design pattern using document retrieval model. For the evaluation of the proposed model, we have used three different domains’ SRS. These three SRS documents represent three different domains, i.e., e-commerce, social media, and desktop utility program. A traditional precision and recall method along with F-measure used for evaluation of information/document retrieval model is used to evaluate the results. F-measure for 17 different design problems shows around 81% accuracy with recall up to 0.69%.

DataMock: An Agile Approach for Building Data Models from User Interface Mockups

In modern software development, much time is devoted and much attention is paid to the activity of data modeling and the translation of data models into databases. This has motivated the proposal of different approaches and tools to support this activity, such as semiautomatic approaches that generate data models from requirements artifacts using text analysis and sets of heuristics, among other techniques. However, these approaches still suffer from important limitations, including the lack of support for requirements traceability, the poor support for detecting and solving conflicts in domain-specific requirements, and the considerable effort required for manually checking the generated models. This paper introduces DataMock, an Agile approach that enables the iterative building of data models from requirements specifications, while supporting traceability and allowing inconsistencies detection in data requirements and specifications. The paper also describes how the approach effectively allows improving traceability and reducing errors and effort to build data models in comparison with traditional, state-of-the-art, data modeling approaches.

Bayesian networks for enhancement of requirements engineering: a literature review

Requirements analysis is the software engineering stage that is closest to the users' world. It also involves tasks that are knowledge intensive. Thus, the use of Bayesian networks (BNs) to model this knowledge would be a valuable aid. These probabilistic models could manage the imprecision and ambiguities usually present in requirements engineering (RE). In this work, we conduct a literature review focusing on where and how BNs are applied on subareas of RE in order to identify which gaps remain uncovered and which methods might engineers employ to incorporate this intelligent technique into their own requirements processes. The scarcity of identified studies (there are only 20) suggests that not all RE areas have been properly investigated in the literature. The evidence available for adopting BNs into RE is sufficiently mature yet the methods applied are not easily translatable to other topics. Nonetheless, there are enough studies supporting the applicability of synergistic cooperation between RE and BNs. This work provides a background for understanding the current state of research encompassing RE and BNs. Functional, non-functional and -ilities requirements artifacts are enhanced by the use of BNs. These models were obtained by interacting with experts or by learning from databases. The most common criticism from the point of view of BN experts is that the models lack validation, whereas requirements engineers point to the lack of a clear application method for BNs and the lack of tools for incorporating them as built-in help functions.

TOWARDS IMPLEMENTING A FRAMEWORK FOR MODELING SOFTWARE REQUIREMENTS IN MAGICDRAW UML

UML is considered to be de facto standard for software modeling. However, in software requirements analysis it is quite common to apply only use case and activity diagrams and focus on the textual requirements specification with some non-standard graphical illustrations. In this paper we present a framework for modeling software requirements consistently using multiple UML diagrams. We illustrate the application of this framework with the examples of different requirements artifacts based on a case study system MagicTest. We discuss how such a framework could be implemented in one of the most popular UML tools, MagicDraw UML, by using its powerful features for customizing the modeling environment, defining methodology wizards, specifying validation rules, analyzing model element relationships, and generating documentation based on user-defined templates. We recognize that our approach provides the foundation, which could and should be refined and extended for special cases of requirements analysis. Our work should be considered as a starting point for practitioners trying to adopt UML for requirements analysis and for scientists working on creating more detailed requirements analysis methods based on UML.

3.3.1 An Improved Taxonomy for Major Needs and Requirements Artifacts

AbstractEach of the major systems engineering standards and guides has a different focus, uses slightly different terms for the various needs and requirements artifacts, and reflects a different emphasis on each of the activities from the enterprise level down to the system level. While there is a lack of consistency among documents with the use of terms and artifacts (and all are internally inconsistent to some degree), the differences are not significant and mostly reflect the different emphases on particular levels or specific parts of the overall process. None‐the‐less, the disparate views result in considerable obscuration of the underlying process which can only be resolved after considerable study and deliberation. Worse, the lack of a common taxonomy in the early part of system/requirements engineering process adds confusion at a very critical time in the definition of the system of interest. This paper reviews the early processes and the needs and requirements artifacts described in the major systems engineering standards and guides. An improved (synthesized) taxonomy is proposed that clarifies the language used to describe the major processes and artifacts in the early portion of the system life cycle.

Story Points Based Effort Estimation Model for Software Maintenance

Software is developed with prior requirements and it is maintained continuously with rapid progresses in domain, technology, economy, and other fields. Software maintenance is vital and it requires more efforts and resources than development phase. There are fewer methods available for maintenance effort estimation. An iterative maintenance life cycle using extreme programming is a model for software maintenance based on agile methodology that uses RC stories as requirement artifacts. Agile methodology uses analogy and expert opinion based estimation techniques such as planning poker. But in software maintenance, historical data and experts may not be present or accurate. Therefore, a heuristic method is required for the calculation of maintenance efforts. In this paper, we propose a Software Maintenance Effort Estimation Model (SMEEM) for software maintenance estimation. The SMEEM technique uses story points to calculate the volume of maintenance and value adjustment factors that are affecting story points for effort estimation. The proposed model will be illustrated with various types of maintenance projects. The model generates accurate and effective results as compared to other software maintenance effort estimation models. This model is applicable only for agile and extreme programming based maintenance environment.