| dc.description.abstract | Features are an inherent unit of development of every software; and are defined as a
set of implementation artifacts that constitute a functionality that adds value to the
product, and is perceived useful by the customer. Locating features in source code is
a typical software developer task, whether it before implementing a new feature, or
maintaining and bug fixing of existing ones, as it is essential to know where to make
changes. For tracing features to their implementation, two mechanisms can be used;
external and internal documentation. As the names imply, external documentation
refers to maintaining the traceability links externally, whereas internal documentation involves labeling assets inside the source code (aka embedded annotations). For
internal documentation, two strategies are used namely eager and lazy approaches.
The former involves annotating the code artifacts during development, whereas the
latter requires extracting feature-related information from an un-annotated codebase based on heuristics. The former, although involves some added effort, result in
significant returns in terms of accuracy and degree of reuse, also enabling a wider
range of analyses. Also, the added effort can be minimal depending on the size of
the project but soon begins to prove its worth in the short-run (when aiming to
reuse) as well as the long run (when maintaining the code base).
Embedded annotations (with eager strategy) allow a minimally invasive and almost
cost-neutral way to document the product features inside source code. This brings
some benefits, the significant ones being easier co-evolution of code and traceability
links, elimination of feature location, and ease in tasks like feature and artifact
reuse (cloning) and maintenance (propagation). Several approaches exist today on
how to document features in source code. Different definitions lead to different
implementations and therefore, reuse is not directly possible. This work tackles
exactly this issue and provides a unified design of embedded annotations with a freeto-use reference library according to the presented specification. The functionality of
this library, aka. engine, is shown on the use case of partial feature-based commits.
Feature centric development, which is typical for agile projects get the possibility for
isolated source code commits based on specific features aka. embedded annotations. | sv |
