Alexander Delater

Improved representation of traceability links in requirements engineering knowledge using Sunburst and Netmap visualizations

The representation of traceability links in requirements knowledge is vital to improve the general understanding of requirements as well as the relevance and consequences of relations between requirements artifacts and other artifacts in software engineering. Various visualization techniques have been developed to support the representation of traceability information, e.g. traceability matrices, graphs and tree structures. However, these techniques do not scale well on large amounts of artifacts and often do not provide additional functionality to present supplementary data. In this paper, we use Sunburst and Netmap visualizations as alternative visualization techniques. These techniques perform well even on large amounts of artifacts and traceability links. Moreover, they provide the ability to present derivative data. An implementation of the visualizations was developed in conjunction with a requirements plugin for the Redmine project management platform. In this paper, the applicability of Sunburst and Netmap visualizations for requirements engineering knowledge is illustrated by applying it to an example project and the results are compared to traditional visualization techniques.

Tracing Requirements and Source Code during Software Development: An Empirical Study

[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.

Enhanced traceability in model-based CASE tools using ontologies and information retrieval

Model-based CASE tools provide mechanisms to capture and store heterogeneous artifacts produced during the software development process. These tools incorporate a meta-model describing artifact types and traceability links. Although model-based CASE tools provide required means to create and link different artifact types, still the process of linking artifacts is primarily manual resulting in missing or broken traceability links. This paper proposes a novel approach to create and utilize a project-specific ontology derived from the textual and structural information available in the development artifacts to assist the traceability link creation process. We discuss the benefits and challenges of incorporating the proposed approach in a model-based CASE tool.

Analyzing the tracing of requirements and source code during software development

[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.

Supporting Project Management Through Integrated Management of System and Project Knowledge

Software engineering is a knowledge-intensive task. Many different kinds of knowledge are created, for example, system knowledge, such as requirements, design, or code, and project knowledge, such as project plans, decisions, and work items. In this chapter, we study two kinds of project knowledge: work items and decisions. Work items document what should or has been done by whom and when. Decisions represent the solution to a decision problem. They are important to be kept in mind so that the future development will be consistent with the past. These kinds of knowledge can be implicit or explicit. Work items are typically managed explicitly in issue trackers, while decisions are mostly hidden in informal notes or in the artifacts, which result from these decisions. Rationale management research has suggested several approaches to make decisions and their rationale explicit. However, in contrast to issue trackers, which are widespread, these approaches are considered as overhead in industry. In this chapter, we argue that work items and decisions should be managed together with the system knowledge. This has several benefits for project management processes, such as project planning or monitoring, for example, with better information for the allocation of work items or risk identification. We present a vision detailing these benefits and discuss what is known in research and practice about the realization of this vision. In particular, we review existing approaches to capture work items or decisions and their links to other knowledge and discuss the empirical evidence of their benefits for an integrated system and project knowledge management in industry.

UNICASE Trace Client: (Semi-) Automatic Tracing of Requirements and Code During Development for Small and Medium Enterprises

Corporations are constantly making progress in their efforts towards traceability in software development. One challenge faced by small and medium enterprises (SMEs) is to create traceability links between requirements and code [1], e.g. to use them to prove to their customers that they implemented all requirements. However, these links are often created after development [2], which can, for example, result in increased costs and development time. In [3], we presented an approach to (semi-) automatically create links between requirements and code during development using artifacts from project management. Based on this approach, we developed the lightweight tool UNICASE Trace Client (UTC) [4]. It is an extension to the model-based CASE tool UNICASE [5], which is an Eclipse plug-in developed in an open-source project. As SMEs prefer tools supporting multiple aspects of software development, e.g. requirements, project management and code, UTC is particularly suited for them. In this paper, we introduce UTC and describe why it is valuable for SMEs.

Using requirements traceability links at runtime - a position paper

During software development a large amount of varied information is created. It comprises the requirements specification and depending artifacts such as design, code or test cases, as well as supporting information such as traceability links. This information is intended to be used during development time. The research in requirements at runtime has so far focused on using the requirements specification at runtime. This paper explores how to use the existing traceability links between requirements and other artifacts at runtime.