Incremental Latent Semantic Indexing for Automatic Traceability Link Evolution Management

Software requirements traceability links have been widely recognized as an essential means for effective system evolution when requirements change. However, creating and maintaining traceability links is not an easy task in practice, especially when faced time pressure. Therefore, an automatic and accurate traceability link recovery approach is needed. Existing methods usually recover the traceability links through information retrieval models [1], which calculate text similarity among software artifacts. Although the text-similarity plays an essential role in correlating software artifacts, we argue that the context of software artifacts also renders important clues for establishing the traceability links among software artifacts. For example, for each software use case, its includes/extends use cases can be seen as its context information, contributing to comprehensively profiling the use case. The collection of software artifacts can be modeled as a graph structure through a variety of explicit relationships. Description-Embodied Knowledge Representation Learning (DKRL) [2] is a widely accepted method, which can effectively capture the structural information of explicit relationship and description information of entities. By effectively and precisely embedding such a graph, the context information can be meaningfully represented, contributing to the identification of requirements traceability links. In this paper, we propose a Traceability Link Recovery-Knowledge Representation Learning (TLR-KRL) to recover requirements traceability links between use cases and code based on DKRL. This work has been accepted in The 32nd International Conference on Software Engineering& Knowledge Engineering. TLR-KRL can comprehensively characterize software artifacts by embedding both text information and structural relationships, an overview of which is shown in Fig. 1. Specifically, we follow a systematic process to extend the DKRL model, improving its negative sampling method and thus minimizing false-negative samples generated by the original DKRL model. In such a way, we are able to obtain more precise embedding of software artifacts. Such meaningful embeddings are then used to train traceability link classifiers by using supervised machine learning algorithms. All traceability link candidates obtained from the classifier will be further screened by using triple classification in order to retrieve more correct traceability links. To verify the effectiveness of our method, we have carried out experiments on four datasets, including eTour, EAnci, Clinic, and ITrust. The evaluation results on each of the datasets have all shown that our approach can outperform existing work.

Trace links between requirements and code are beneficial for many software engineering tasks such as maintenance, program comprehension, and re-engineering. If trace links are created and used continuously during a project, they need to have high precision and recall to be useful. However, manual trace link creation is cumbersome and existing automatic trace link creation methods are typically only applied retrospectively and to structured requirements. Therefore, they focus on recall and accept manual effort to cope with low precision. Such manual effort is not acceptable continuously. Furthermore, the maintenance of existing links along with changing artefacts in a project is neglected in most automatic trace link creation approaches. Therefore, we developed and evaluated an interaction log-based trace link creation approach IL to continuously provide correct trace links during a project. IL links unstructured requirements specified in an issue tracker and source code managed in a version control system. In the latest version, ILCom, our approach uses the interactions of developers with files in an integrated development environment and issue identifiers provided in commit messages to create trace links continuously after each commit. In this paper, we present ILCom, its most recent evaluation study, and a systematic literature review (SLR) about trace link maintenance (TM). We also present a TM process for ILCom based on two approaches from our SLR. In the evaluation study, we show that precision of ILCom created links is above 90% and recall almost at 80%. In the SLR, we discuss 16 approaches. Our approach is the first trace link creation approach with very good precision and recall and integrated trace maintenance.

Maintaining traceability links of software systems is a crucial task for software management and development. Unfortunately, dealing with traceability links are typically taken as afterthought due to time pressure. Some studies attempt to use information retrieval-based methods to automate this task, but they only concentrate on calculating the textual similarity between various software artifacts and do not take into account the properties of such artifacts. In this paper, we propose a novel traceability link recovery approach, which comprehensively measures the similarity between use cases and source code by exploring their particular properties. To this end, we leverage and combine machine learning and logical reasoning techniques. On the one hand, our method extracts features by considering the semantics of the use cases and source code, and uses a classification algorithm to train the classifier. On the other hand, we utilize the relationships between artifacts and define a series of rules to recover traceability links. In particular, we not only leverage source code’s structural information, but also take into account the interrelationships between use cases. We have conducted a series of experiments on multiple datasets to evaluate our approach against existing approaches, the results of which show that our approach is substantially better than other methods.

Maintaining traceability links between software release notes and corresponding development artifacts, e.g., pull requests (PRs), commits, and issues, is essential for managing technical debt and ensuring maintainability. However, in opensource environments where contributors work remotely and asynchronously, establishing and maintaining these links is often error-prone, time-consuming, and frequently overlooked. Our empirical study of GitHub repositories revealed that 47 % of release artifacts lacked traceability links, and <tex xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">$\mathbf{1 2 \%}$</tex> contained broken links. To address this gap, we first analyzed release notes to identify their What, Why, and How information and assessed how these align with PRs, commits, and issues. We curated a benchmark dataset consisting of 3,500 filtered and validated traceability link instances. Then, we implemented LLM-based approaches to automatically establish traceability links of three pairs between release note contents & PRs, release note contents & PRs and release note contents & issues. By combining the time proximity feature, the LLM-based approach, e.g., Gemini 1.5 Pro, achieved a high Precision@1 value of 0.73 for PR traceability recovery. To evaluate the usability and adoption potential of this approach, we conducted an online survey involving 33 opensource practitioners. 16 % of respondents rated as very important, and 68 % as somewhat important for traceability maintenance.

Traceability is defined by Center of Excellence for Software Traceability as the ability to interrelate any uniquely identifiable software engineering artifact to any other, maintain required links over time, and use resulting network to answer questions of both software product and its development process. It is an essential element in software development process, especially for Safety-Critical systems where trace links are used to demonstrate that all hazards and faults are mitigated in delivered system. Maintaining trace links as a software system evolves over time is difficult, error-prone and costly. As a result, trace links tend to become outdated and safety-cases, which rely on trace links and associated data to compose arguments and evidence for system safety are invalidated. In practice, software developers must therefore painstakingly update trace links in order to re-validate safety-cases whenever they seek re-certification of their product. While a significant body of work exists in area of trace link creation, very limited research has focused on problem of link evolution. The goal of this dissertation is therefore to deliver an accurate, scalable, and practical approach for supporting trace link evolution across a diverse set of software artifacts including requirements, source code and safety cases.

Maintaining traceability links between application code and unit test cases plays an important role for effectively managing the development and evolution of software systems. Unfortunately, the support in the contemporary development environment to identify such links is still inadequate. This research presents an automated solution to recover traceability links between test cases and classes under test. The approach is based on dynamic slicing and conceptual coupling. A preliminary evaluation indicates that the proposed approach identifies trace ability links between unit test cases and tested classes with a high accuracy and greater stability than existing techniques.

In Model Driven Engineering, traceability is used to establish relationships between various software artifacts during the software life cycle. Traceability can be also used to define dependencies between related elements in different models, to propagate and verify properties from one model to another and to analyze the impact of changes. In this paper we describe how to define typed trace-links between different kinds of models in our model transformation chain PUMA4SOA, which generates Layered Queuing performance models from UML software models of service-oriented applications. The goal of PUMA4SOA is to help evaluate the performance of SOA systems in the early development phases. In our approach, the traceability links are stored externally in a new model, which maintain traces separately from the source and target models they refer to. We illustrate how traceability links can be used to propagate the results of the performance model back to the original software model.

In recent years, the quest for finding practical software traceability approaches has intensified. Several existing approaches have not utilized every level of information in creating trace link pairs, so their accuracy is low. Since software artifacts are term-heavy, semantics becomes an essential feature. This study proposes a comprehensive concept-based Property Listing Task (PLT) encompassing semantic, structural, and physical features for traceability. PLT is a novel concept in software traceability in which it extracts properties from software artifacts. PLTs from source and target software artifacts are used as a guide in finding the trace link. Based on our case study experimentation on Coffee Maker Project, the result indicates that the proposed Property Listing Task can generate an accurate trace link.

When a system evolves, while the source code is changed, documentation and traceability links are barely ever updated: maintaining traceability information between software artifacts is a costly and tedious activity, which is frequently sacrificed during development and maintenance due to market pressure. The paper presents a new method to recovery traceability links between high level and low level artifacts. The method is based on the partial knowledge of a subset of tracability links. It can be fully automated and the human intervention is only required to confirm or confute recovered traceability links. The method has been applied to software written in Java, to trace classes onto functional requirements. Experimental results demonstrate the superiority of the novel method over previously published results on the same system.

The ever-increasing globalization of the software industry presents challenges related to requirements engineering activities. Managing requirements’ changes and tracing software artifacts is not trivial in a multi-site environment composed of a variety of stakeholders that do not trust each other. In this study, we propose a neural blockchain prototype for the traceability of requirements (BC4RT) throughout the software development lifecycle in interorganizational software projects. The prototype is implemented using a neural blockchain platform, namely NDL ArcaNet, due to its inherent properties: performance efficiency, sustainability, and scalability. Besides these features, the proposed prototype provides a holistic and reliable view of software artifacts, requirements’ changes, and trace links. The increased visibility enhances collaboration, communication, and trust among stakeholders, and can potentially improve software development efficiency and quality.KeywordsBlockchain technologyRequirements traceabilityInterorganizational software projectsNeural distributed ledger

Cross-level requirement trace links (i.e., links between high-level requirements (HLRs) and low-level requirements (LLRs)) record the top-down decomposition process of requirements and support various development and management activities (e.g., requirement validation). Undoubtedly, updating trace links synchronously with requirement changes is critical for their constant availability. However, large-scale open-source software that is rapidly iterative and continually released has numerous requirements that are dynamic. These requirements render timely update of trace links challenging. To address these problems, in this study, a novel deep-learning-based method, deep requirement trace analyzer fusing heterogeneous features (DRAFT), was proposed for updating trace links between various levels of requirements. Considering both the semantic information of requirement text descriptions and the process features based on metadata, trace link data accumulated in the early stage are comprehensively used to train the trace link identification model. Particularly, first, we performed second-phase pre-training for the bidirectional encoder representations from transformers (BERT) language model based on the project document corpus to realize project-related knowledge transfer, which yields superior text embedding. Second, we designed 11 heuristic features based on the requirement metadata in the open-source system. Based on these features and semantic similarity between HLRs and LLRs, we designed a cross-level requirement tracing model for new requirements. The superiority of DRAFT was verified based on the requirement datasets of eight open-source projects. The average F1 and F2 scores of DRAFT were 69.3% and 76.9%, respectively, which were 16.5% and 22.3% higher than baselines. An ablation experiment proved the positive role of two key steps in trace link construction.

A key part of software evolution and maintenance is the continuous integration from collaborative efforts, often resulting in complex traceability challenges between software artifacts: features and modules remain scattered in the source code, and traceability links become harder to recover. In this paper, we perform a systematic mapping study dealing with recent research recovering these links through information retrieval, with a particular focus on natural language processing (NLP).Our search strategy gathered a total of 96 papers in focus of our study, covering a period from 2013 to 2021. We conducted trend analysis on NLP techniques and tools involved, and traceability efforts (applying NLP) across the software development life cycle (SDLC). Based on our study, we have identified the following key issues, barriers, and setbacks: syntax convention, configuration, translation, explainability, properties representation, tacit knowledge dependency, scalability, and data availability.Based on these, we consolidated the following open challenges: representation similarity across artifacts, the effectiveness of NLP for traceability, and achieving scalable, adaptive, and explainable models. To address these challenges, we recommend a holistic framework for NLP solutions to achieve effective traceability and efforts in achieving interoperability and explainability in NLP models for traceability.

Requirements Traceability (RT) refers to the process of tracing requirements through the software development life-cycle. It is essential for the software development process because a lot of information is used and produced and it should be kept related or traceable. Nevertheless, as the complexity of a system increases, the myriad of related artifacts also increases. Therefore, one is encumbered of tracing requirements through different abstraction levels. Proposing a common abstraction to the requirements traceability process and also providing query mechanisms to retrieve trace links has been recognized as one of the grand challenges of RT. Hence, in this paper, we propose a Traceability Representation Language (TRL), which provides abstractions to requirements, artifacts and trace links as well as queries, through which trace links can be searched, retrieved and filtered. To evaluate the proposed language, we have conducted an empirical experiment comparing TRL with other traceability languages, namely TracQL and TQL. We observed the readability and writability of the languages as well as their trace links representations and query declarations and concluded that the proposed TRL language is a feasible abstraction to the RT process. As a final remark, we discuss how the proposed language contributes towards portable and scalable traceability.

Developers are the most important resource to build and maintain software projects. Due to various reasons, some developers take more responsibility, and this type of developers are more valuable and indispensable for the project. Without them, the success of the project would be at risk. We use the term key developers for these essential and valuable developers, and identifying them is a crucial task for managerial decisions such as risk assessment for potential developer resignations. We study key developers under three categories: jacks, mavens and connectors. A typical jack (of all trades) has a broad knowledge of the project, they are familiar with different parts of the source code, whereas mavens represent the developers who are the sole experts in specific parts of the projects. Connectors are the developers who involve different groups of developers or teams. They are like bridges between teams.

The traceability links among software artifacts plays a very important role for the maintenance of consistency in the evolution of software product lines. This paper introduces an improved approach to the recovery of traceability information between requirement documents and source codes based on Latent Semantic Indexing (LSI) and the special features of object-oriented source codes. In order to obtain accurate traceability links, it employs the hierarchical information caused by the inheritance relationship among classes and recovers the traceability links using class clusters. Moreover, it assigns different weights for the terms in source codes according to their degrees of correlation to the documents. The case demonstrates the improved approach, and the experimental results show that it can increase the extraction precision by 3%~6%, compared with that based on the traditional LSI.