No full-text available
To read the full-text of this research,
you can request a copy directly from the authors.
Automated Techniques for Capturing Custom Traceability Links Across Heterogeneous Artifacts
Abstract
Software traceability is becoming an increasingly important facet of software engineering, especially as development projects become more distributed, decentralized, and dependent on third-party software. This chapter illustrates how traceability links can be automatically captured in situ, while software engineers perform their development tasks, through the use of specialized open hypermedia adapters and custom rules. Focusing on the mobile phone case study, we demonstrate how users can integrate their custom filters, heuristics, and relationship types, as well as their existing development tools, into our traceability system. We also show how our traceability link-capture technique can be incorporated with search tools and how traceability links can be effectively maintained. We provide practical usage scenarios and brief technical discussions for each of these capabilities.
... The most prevalent automated tracing techniques include the Vector Space Model (VSM) [22], Latent Dirichlet Allocation (LDA) [8], Latent Semantic Indexing (LSI) [5], and deep-learning techniques [20]. Automated approaches typically analyze the textual content of each artifact, compute their syntactic and semantic similarity, and assign a relatedness score between each pair of artifacts that depicts the likelihood that the artifacts are associated. ...
Software traceability establishes associations between diverse software artifacts such as requirements, design, code, and test cases. Due to the non-trivial costs of manually creating and maintaining links, many researchers have proposed automated approaches based on information retrieval techniques. However, many globally distributed software projects produce software artifacts written in two or more languages. The use of intermingled languages reduces the efficacy of automated tracing solutions. In this paper, we first analyze and discuss patterns of intermingled language use across multiple projects, and then evaluate several different tracing algorithms including the Vector Space Model (VSM), Latent Semantic Indexing (LSI), Latent Dirichlet Allocation (LDA), and various models that combine mono- and cross-lingual word embeddings with the Generative Vector Space Model (GVSM). Based on an analysis of 14 Chinese-English projects, our results show that best performance is achieved using mono-lingual word embeddings integrated into GVSM with machine translation as a preprocessing step.
... Both terms in the title and description of issue reports are considered, after stemming and stop word removal. The initial step in the recommendation process is in line with previous work on duplicate detection of issue reports [72], IR-based trace capture [86], and content-based RSSEs [87]. ...
Change Impact Analysis (CIA) during software evolution of safety-critical systems is a labor-intensive task. Several authors have proposed tool support for CIA, but very few tools were evaluated in industry. We present a case study on ImpRec, a recommendation System for Software Engineering (RSSE), tailored for CIA at a process automation company. ImpRec builds on assisted tracing, using information retrieval solutions and mining software repositories to recommend development artifacts, potentially impacted when resolving incoming issue reports. In contrast to the majority of tools for automated CIA, ImpRec explicitly targets development artifacts that are not source code. We evaluate ImpRec in a two-phase study. First, we measure the correctness of ImpRec's recommendations by a simulation based on 12 years' worth of issue reports in the company. Second, we assess the utility of working with ImpRec by deploying the RSSE in two development teams on different continents. The results suggest that ImpRec presents about 40 percent of the true impact among the top-10 recommendations. Furthermore, user log analysis indicates that ImpRec can support CIA in industry, and developers acknowledge the value of ImpRec in interviews. In conclusion, our findings show the potential of reusing traceability associated with developers' past activities in an RSSE.
... Both terms in the title and description of issue reports are considered, after stemming and stop word removal. The initial step in the recommendation process is in line with previous work on duplicate detection of issue reports [72], IR-based trace capture [86], and content-based RSSEs [87]. ...
Change Impact Analysis (CIA) during software evolution of safety-critical systems is a labor-intensive task. Several authors have proposed tool support for CIA, but very few tools were evaluated in industry. We present a case study on ImpRec, a recommendation System for Software Engineering (RSSE), tailored for CIA at a process automation company. ImpRec builds on assisted tracing, using information retrieval solutions and mining software repositories to recommend development artifacts, potentially impacted when resolving incoming issue reports. In contrast to the majority of tools for automated CIA, ImpRec explicitly targets development artifacts that are not source code. We evaluate ImpRec in a two-phase study. First, we measure the correctness of ImpRec’s recommendations by a simulation based on 12 years’ worth of issue reports in the company. Second, we assess the utility of working with ImpRec by deploying the RSSE in two development teams on different continents. The results suggest that ImpRec presents about 40% of the true impact among the top-10 recommendations. Furthermore, user log analysis indicates that ImpRec can support CIA in industry, and developers acknowledge the value of ImpRec in interviews. In conclusion, our findings show the potential of reusing traceability associated with developers’ past activities in an RSSE.
... Within Excel, SourceTrac can detect data scraped from the web through Excel's " Get External Data From Web " interface. If data is manually copied from a Web page or if a file is downloaded from a web site, it is also possible to determine the source by automatically inspecting the immediate history of the user's web browser (e.g., Firefox) and obtaining the visited URL (using a traceability technique[3]). Once the URL is captured, the cells are annotated with this URL.Figure 1shows data scraped using the Excel interface (background) which is then pasted onto a spreadsheet (foreground). ...
Analyzing data from multiple sources is a common task in scientific research. In particular, spreadsheet data is often aggregated from a variety of sources to identify patterns and synthesize reports. Yet, techniques are lacking for automatically capturing the provenance of such data within spreadsheet environments like Excel. We present a novel approach for fine-grained tracing of tabular data that may have been obtained from files, databases, or the Web. Our approach provides relevant provenance information at both the micro-level (per cell) and the macro-level (per sheet). Initial results suggest that our approach is scalable and beneficial to data analysts.
Software traceability links are established between diverse artifacts of the software development process in order to support tasks such as compliance analysis, safety assurance, and requirements validation. However, practice has shown that it is difficult and costly to create and maintain trace links in non-trivially sized projects. For this reason, many researchers have proposed and evaluated automated approaches based on information retrieval and deep-learning. Generating trace links automatically can also be challenging – especially in multi-national projects which include artifacts written in multiple languages. The intermingled language use can reduce the efficiency of automated tracing solutions. In this work, we analyze patterns of intermingled language that we observed in several different projects, and then comparatively evaluate different tracing algorithms. These include Information Retrieval techniques, such as the Vector Space Model (VSM), Latent Semantic Indexing (LSI), Latent Dirichlet Allocation (LDA), and various models that combine mono- and cross-lingual word embeddings with the Generative Vector Space Model (GVSM), and a deep-learning approach based on a BERT language model. Our experimental analysis of trace links generated for 14 Chinese-English projects indicates that our MultiLingual Trace-BERT approach performed best in large projects with close to 2-times the accuracy of the best IR approach, while the IR-based GVSM with neural machine translation and a monolingual word embedding performed best on small projects.
Même si le capital immatériel représente une part de plus en plus importante de la valeur de nos organisations, il n’est pas toujours possible de stocker, tracer ou capturer les connaissances et les expertises, par exemple dans des projets de taille moyenne. Le courrier électronique est encore largement utilisé dans les projets d’entreprise en particulier entre les équipes géographiquement dispersées. Dans cette étude, nous présentons une nouvelle approche pour détecter les zones à l'intérieur de courriels professionnels où des éléments de connaissances sont susceptibles de se trouver. Nous définissons un contexte étendu en tenant compte non seulement du contenu du courrier électronique et de ses métadonnées, mais également des compétences et des rôles des utilisateurs. Également l’analyse pragmatique linguistique est mêlée aux techniques usuelles du traitement de langage naturel. Après avoir décrit notre méthode KTR et notre modèle, nous l'appliquons à un corpus réel d’entreprise et évaluons les résultats en fonction des algorithmes d’apprentissage, de filtrage et de recherche
A substantial number of enterprises and independent software vendors are adopting a strategy in which software-intensive systems are developed with an open architecture (OA) that may contain open source software (OSS) components or components with open APIs. The emerging challenge is to realize the benefits of openness when components are subject to different copyright or property licenses. In this chapter, the authors identify key properties of OSS licenses, present a license analysis scheme to identify license conflicts arising from composed software elements, and apply it to provide guidance for software architectural design choices whose goal is to enable specific licensed component configurations. The scheme has been implemented in an operational environment and demonstrates a practical, automated solution to the problem of determining overall rights and obligations for alternative OAs as a technique for aligning such architectures with enterprise strategies supporting open systems.
Context and Motivation: Information retrieval (IR) trace link creation approaches have insufficient precision and do not perform well on unstructured data which is typical in issue tracker systems (ITS). Question/problem: We are interested in understanding how interaction tracking on artifacts can help to improve precision and recall of trace links between requirements specified unstructured in an ITS and source code. Principal ideas/results: We performed a study with open source project data in which artifact interactions while working on requirements specified in an ITS have been recorded. Contribution: The results of our study show that precision of interaction-based links is 100% and recall is 93% for the first and 80% for the second evaluated data set relative to IR-created links. Along with the study we developed an approach based on standard tools to automatically create trace links using interactions which also takes into account source code structure. The approach and the study show that trace links creation in practice can be supported with little extra effort for the developers.
[Context and motivation] Traceability links between requirements and code are often created after development, which can, for example, lead to higher development effort. To address this weakness, we developed in previous work an approach that captures traceability links between requirements and code as the development progresses by using artifacts from project management called work items. [Question/problem] It is important to investigate empirically what is the best way to capture such links and how these links are used during development. [Principal ideas/results] In order to link requirements, work items and code during development, we extended our approach from previous work by defining three traceability link creation processes. We are applying these processes in practice in a software development project conducted with undergraduate students. The results indicate that our approach creates correct traceability links between requirements and code with high precision/recall during development, while developers mainly used the third process to link work items after implementation. Furthermore, the students used a subset of the created traceability links for navigating between requirements and code during the early phase of the development project. [Contribution] In this paper, we report on preliminary empirical results from applying our approach in practice.
In this paper, we develop a vision of software evolution based on a feature-oriented perspective. From the fact that features provide a common ground to all stakeholders, we derive a hypothesis that changes can be effectively managed in a feature-oriented manner. Assuming that the hypothesis holds, we argue that feature-oriented software evolution relying on automatic traceability, analyses, and recommendations reduces existing challenges in understanding and managing evolution. We illustrate these ideas using an automotive example and raise research questions for the community.
[Context and motivation] In practice, trace ability links between requirements and code are often not created, because this would require increased development effort. To address this weakness, we developed in previous work an approach that semi-automatically captures trace ability links between requirements and code during development. We do this by using work items from project management that typically are stored in issue trackers. [Question/problem] Practitioners and researchers have discussed the practice of using work items to capture links between requirements and code, but there has been no systematic study of this practice. [Principal ideas/results] In this paper, we present such an empirical study based on the application of our approach. We applied our approach in three different software development projects conducted with undergraduate students. We evaluated the feasibility and practicability of our approach and its tool support. The feasibility results indicate that our approach creates correct trace ability links between all artifacts with high precision and recall during development. At the same time the practicability results indicate that the subjects found our approach and its tool support easy to use. [Contribution] The empirical evaluation in this paper contributes valuable insights into the tracing of requirements and code during software development.
Much research in traceability has focused on following requirements and features over the early phases of the software lifecycle. There has been comparatively little work on traceability into later phases and artifacts. In this paper, we tackle the problem of traceability across artifacts, including documents and source code, and maintaining traceability links through successive changes. We have developed Zelda, a prototype for associating arbitrary lines in text-based files with a feature map. This representation can be used to link together sections from many types of artifacts and can also contain annotations and notes. Zelda automatically tracks and presents the locations of these links in subsequent versions of the artifacts. We evaluated Zelda using 25 versions of jEdit, (260 KLOC). The overall precision for 419 links across the five features was 0.90 and the recall was 0.73. The average precision and recall per features is 0.78 and 0.69 respectively.
An accurate set of traceability relations between software development artifacts is desirable to support evolutionary development. However, even where an initial set of traceability relations has been established, their maintenance during subsequent development activities is time consuming and error prone, which results in traceability decay. This paper focuses solely on the problem of maintaining a set of traceability relations in the face of evolutionary change, irrespective of whether generated manually or via automated techniques, and it limits its scope to UML-driven development activities post-requirements specification. The paper proposes an approach for the automated update of existing traceability relations after changes have been made to UML analysis and design models. The update is based upon predefined rules that recognize elementary change events as constituent steps of broader development activities. A prototype traceMaintainer has been developed to demonstrate the approach. Currently, traceMaintainer can be used with two commercial software development tools to maintain their traceability relations. The prototype has been used in two experiments. The results are discussed and our ongoing work is summarized.
Use case diagrams (UCDs) are widely used to describe requirements and desired functionality of software products. However, UCDs are loosely linked to programs source code, and maintaining traces between the source code and ele- ments of UCDs is a manual, tedious, and laborious process. We offer a novel approach for automating a part of this process. Developers first specify few traceability links (TLs). Our system combines these links with run-time monitoring, program analysis, and machine-learning ap- proaches to recover and validate additional TLs between types and variables in Java programs and elements of UCDs. We evaluate our prototype implementation on open- source software projects, and our results suggest that our approach can generalize from a small set of initial links to recover many other TLs with a high degree of automation and precision.
Heterogeneously-licensed systems pose new challenges to analysts and system architects. Appropriate intellectual property rights must be available for the installed system, but without unnecessarily restricting other requirements, the system architecture, and the choice of components both initially and as it evolves. Such systems are increasingly common and important in e-business, game development, and other domains. Our semantic parameterization analysis of open-source licenses confirms that while most licenses present few roadblocks, reciprocal licenses such as the GNU General Public License produce knotty constraints that cannot be effectively managed without analysis of the system's license architecture. Our automated tool supports intellectual property requirements management and license architecture evolution. We validate our approach on an existing heterogeneously-licensed system.
Even when working on a well-modularized software system, programmers tend to spend more time navigating the code than working with it. This phenomenon arises because it is impossible to modularize the code for all tasks that occur over the lifetime of a system. We describe the use of a degree-of-interest (DOI) model to capture the task context of program elements scattered across a code base. The Mylar tool that we built encodes the DOI of program elements by monitoring the programmer's activity, and displays the encoded DOI model in views of Java and AspectJ programs. We also present the results of a preliminary diary study in which professional programmers used Mylar for their daily work on enterprise-scale Java systems.
Emerging software development environments are characterized by heterogeneity: they are composed of diverse object stores, user interfaces, and tools. This paper presents an approach for providing hypermedia services in this heterogeneous setting. Central notions of the approach include the following: anchors are established with respect to interactive views of objects, rather than the objects themselves; composable, n-ary links can be established between anchors on different views of objects which may be stored in distinct object bases; viewers may be implemented in different programming languages; and, hypermedia services are provided to multiple, concurrently active, viewers. The paper describes the approach, supporting architecture, and lessons learned. Related work in the areas of supporting heterogeneity and hypermedia data modeling is discussed. The system has been employed in a variety of contexts including research, development, and education.
An approach to recover/discover traceability links between software artifacts via the examination of a software system's version history is presented. A heuristic-based approach that uses sequential-pattern mining is applied to the commits in software repositories for uncovering highly frequent co-changing sets of artifacts (e.g., source code and documentation). If different types of files are committed together with high frequency then there is a high probability that they have a traceability link between them. The approach is evaluated on a number of versions of the open source system KDE. As a validation step, the discovered links are used to predict similar changes in the newer versions of the same system. The results show highly precision predictions of certain types of traceability links.
In this paper, we present NavTracks, a tool that supports browsing through software. NavTracks keeps track of the navigation history of software developers, forming associations between related files. These associations are then used as the basis for recommending potentially related files as a developer navigates the software system. We present the reasoning behind NavTracks, its basic algorithm, a case study, and propose some future work.
Program synthesis automatically derives programs from specifications of their behavior. At a lower level, compilation automatically derives machine code from source code (i.e. from a specification of its behavior). An advantage of program synthesis/compilation, as opposed to manual coding, is that there is a direct link between the specification and the derived program. This link is, however, not very fine-grained: it can be best characterized as program is-derived-from specification. When the generated program needs to be understood or modified, more fine-grained linking is useful. We present a technique for automatically deriving traceability relations between parts of a specification and parts of the synthesized program. The technique is very lightweight and we expect it to work - with varying degrees of success - for any process in which one artifact is automatically derived from another. We illustrate the generality of the technique by applying it to two kinds of automatic generation: synthesis of Kalman filter programs from specifications using the AUTOFILTER program synthesis system, and generation of assembly language programs from C source code using the GCC C compiler. We evaluate the effectiveness of the technique in the latter application.
This chapter offers a vision for traceability in software and systems engineering and outlines eight challenges that need to be addressed in order to achieve it. One of these challenges is referred to as the grand challenge of traceability because making traceability ubiquitous in software and systems development (traceability challenge eight) demands progress with all seven other challenges. A model of a generic traceability process is used as a framework through which the goals and requirements of each challenge are expressed. For each requirement, the current status of the traceability research and practice is summarised, and areas of promise are highlighted. This systematic analysis is used to articulate eight major research themes for the traceability community, along with a number of underlying research topics and positive adoption practices for industry. This work is a snapshot of an ongoing and collaborative effort between traceability researchers and practitioners within the Center of Excellence for Software Traceability. It is intended to form a structured agenda for traceability research and practice, a basis for classifying research contributions and a means to track progress in the field.
Software engineers confront many challenges during software development. One challenge is managing the relationships that exist between software artifacts. We refer to this task as information integration, since establishing a relationship between documents typically implies that an engineer must integrate information from each of the documents to perform a development task. In the past, we have applied open hypermedia techniques and technology to address this challenge. We now extend this work with the development of an information integration environment. We present the design of our environment along with details of its first prototype implementation. Furthermore, we describe our efforts to evaluate the utility of our approach. Our first experiment involves the discovery of keyword relationships between text-based software artifacts. Our second experiment examines the code of an open source project and generates a report on how its module relationships have evolved over time. Finally, our third experiment develops the capability to link code claiming to implement W3C (World Wide Web Consortium) standards with the XHTML (eXtensible HTML) representation of the standards themselves. These experiments combine to demonstrate the promise of our approach. We conclude by asserting that the process of software development can be significantly enhanced if more tools made their relationships available for integration.
The paper presents an approach helping developers to maintain source code identifiers and comments consistent with high-level artifacts. Specifically, the approach computes and shows the textual similarity between source code and related high-level artifacts. Our conjecture is that developers are induced to improve the source code lexicon, i.e., terms used in identifiers or comments, if the software development environment provides information about the textual similarity between the source code under development and the related high-level artifacts. The proposed approach also recommends candidate identifiers built from high-level artifacts related to the source code under development and has been implemented as an Eclipse plug-in, called COde Comprehension Nurturant Using Traceability (COCONUT). The paper also reports on two controlled experiments performed with master's and bachelor's students. The goal of the experiments is to evaluate the quality of identifiers and comments (in terms of their consistency with high-level artifacts) in the source code produced when using or not using COCONUT. The achieved results confirm our conjecture that providing the developers with similarity between code and high-level artifacts helps to improve the quality of source code lexicon. This indicates the potential usefulness of COCONUT as a feature for software development environments.
The support for traceability between requirement specifications has been recognised as an important task in the development life cycle of software systems. In this paper, we present a rule-based approach to support the automatic generation of traceability relations between documents which specify requirement statements and use cases (expressed in structured forms of natural language), and analysis object models for software systems. The generation of such relations is based on traceability rules of two different types. More specifically, we use requirement-to-object-model rules to trace the requirements and use case specification documents to an analysis object model, and inter-requirements traceability rules to trace requirement and use case specification documents to each other. By deploying such rules, our approach can generate four different types of traceability relations. To implement and demonstrate our approach, we have implemented a traceability prototype system. This system assumes requirement and use case specification documents and analysis object models represented in XML. It also uses traceability rules which are represented in an XML-based rule mark-up language that we have developed for this purpose. This XML-based representation framework makes it easier to deploy our prototype in settings characterised by the use of heterogeneous software engineering and requirements management tools. The developed prototype has been used in a series of experiments that we have conducted to evaluate our approach. The results of these experiments have provided encouraging initial evidence about the plausibility of our approach and are discussed in the paper.
Traceability is an important aspect of software development that is often required by various professional standards and government agencies. Yet current industrial approaches do not typically address end-to-end traceability. Moreover, many industry projects become entangled in process overhead and fail to derive much benefit from current traceability solutions. This paper presents a successful end-to-end software traceability tool developed at Wonderware, a software development company and a business unit of Invensys Systems, Inc. This process-oriented approach achieves comprehensive traceability and supports the entire software development life cycle by focusing on both requirements traceability and process traceability. We offer new perspectives in analyzing the problem as well as general traceability guidelines. These guidelines have emerged from the experience of implementing and deploying the traceability tool within actual company constraints. We discuss encouraging results and point to the advantages gained in using our approach.
Software traceability is a fundamentally important task in software engineering. The need for automated traceability increases as projects become more complex and as the num- ber of artifacts increases. We propose an automated tech- nique that combines traceability with a machine learning technique known as topic modeling. Our approach auto- matically records traceability links during the software de- velopment process and learns a probabilistic topic model over artifacts. The learned model allows for the semantic categorization of artifacts and the topical visualization of the software system. To test our approach, we have im- plemented several tools: an artifact search tool combining keyword-based search and topic modeling, a recording tool that performs prospective traceability, and a visualization tool that allows one to navigate the software architecture and view semantic topics associated with relevant artifacts and architectural components. We apply our approach to several data sets and discuss how topic modeling enhances software traceability, and vice versa.
In this paper1, we investigate and discuss the underlying nature
of the requirements traceability problem. Our work is based on
empirical studies, involving over 100 practitioners, and an
evaluation of current support. We introduce the distinction
between pre-requirements specification (pre-RS) traceability
and post-requirements specification (post-RS) traceability, to
demonstrate why an all-encompassing solution to the problem is
unlikely, and to provide a framework through which to
understand its multifaceted nature. We report how the majority
of the problems attributed to poor requirements traceability are
due to inadequate pre-RS traceability and show the fundamental
need for improvements here. In the remainder of the paper, we
present an analysis of the main barriers confronting such
improvements in practice, identify relevant areas in which
advances have been (or can be) made, and make
recommendations for research.
We will demonstrate ArchStudio, an environment for software architecture modeling and meta-modeling. We will also showcase a set of innovative architecture-centric applications that use ArchStudio technologies as their basis.
An information retrieval technique, latent semantic indexing, is used to automatically identify traceability links from system documentation to program source code. The results of two experiments to identify links in existing software systems (i.e., the LEDA library, and Albergate) are presented. These results are compared with other similar type experimental results of traceability link identification using different types of information retrieval techniques. The method presented proves to give good results by comparison and additionally it is a low cost, highly flexible method to apply with regards to preprocessing and/or parsing of the source code and documentation.
Many standards that mandate requirements traceability as well as current literature do not provide a comprehensive model of what information should be captured and used as a part of a traceability scheme. Therefore, the practices and usefulness of traceability vary considerably across systems development efforts, ranging from very simplistic practices just aimed at satisfying the mandates to very comprehensive traceability schemes used as an important tool for managing the systems development process. We present a case study of a systems development organization, employing a comprehensive view of traceability. A model describing the traceability practice in the organization, perceived benefits of such a scheme and lessons learnt from implementing it are presented.
Requirements traceability is essential for developing software systems of high quality. Whereas the traceability of the refinement, deployment, and use of a requirement is called post-traceability, the traceability of a requirement back to its origin is named pre-traceability. We present a requirements engineering environment, called PRO-ART, which enables requirements pre-traceability, PRO-ART is based on three main contributions: a three-dimensional framework for requirements engineering which defines the kind of information to be recorded; a trace-repository for structuring the trace information and enabling selective trace retrieval; a novel tool interoperability approach which enables (almost) automated trace capture. In addition, we report on experiences made with the first prototypical implementation of PRO-ART and the resulting redesign and re-implementation, called PRO-ART 2.0, which mainly addresses scalability problems faced with in real applications
Large scale development demands tracing requirements and other objects in the face of continuous evolution. Requirements change in nature, scope, content, and form to become more consistent, accurate, complete, and clear. We present a tracing tool that supports evolution and that treats requirements and relations among them as objects
Although the benefits of requirements traceability are widely recognized, the actual practice of maintaining a traceability scheme is not always entirely successful. The traceability infrastructure underlying a software system tends to erode over its lifetime, as time-pressured practitioners fail to consistently maintain links and update impacted artifacts each time a change occurs, even with the support of automated systems. This paper proposes a new method of traceability based upon event-notification and is applicable even in a heterogeneous and globally distributed development environment. Traceable artifacts are no longer tightly coupled but are linked through an event service, which creates an environment in which change is handled more efficiently, and artifacts and their related links are maintained in a restorable state. The method also supports enhanced project management for the process of updating and maintaining the system artifacts.
: Requirements traceability is essential for developing software systems of high quality. Whereas the traceability of the refinement, deployment, and use of a requirement is called posttraceability, the traceability of a requirement back to its origin is named pre-traceability. In this contribution we present a requirements engineering environment, called PRO-ART * , which enables requirements pre-traceability. PRO-ART is based on three main contributions: . a three-dimensional framework for requirements engineering which defines the kind of information to be recorded; . a trace-repository for structuring the trace information and enabling selective trace retrieval; . a novel tool interoperability approach which enables (almost) automated trace capture. In addition, we report on experiences made with the first prototypical implementation of PRO-ART and the resulting re-design and re-implementation, called PRO-ART 2.0, which mainly addresses scalability problems faced with in real ...
Architecture-Centric Traceability for Stakeholders: Technical Foundations
- H U Asuncion
- R N Taylor
A survey on tracing approaches in practice and research
- A Von Knethen
- B Paech
Concern-driven software evolution
- E Nistor
- E. Nistor
Grand challenges for traceability
- J Hayes
- A Dekhtyar