Feature-oriented Programs Research Articles

Data flow testing of feature-oriented programs

Data flow testing of feature-oriented programs

Computing Dynamic Slices of Feature-Oriented Programs with Aspect-Oriented Extensions

This paper proposes a technique to compute dynamic slices of feature-oriented programs with aspect-oriented extensions. The technique uses a dependence based intermediate program representation called composite feature-aspect dependence graph (CFADG) to represent feature-oriented software that contain aspects. The CFADG of a feature-oriented program is based on the selected features that are composed to form a software product and the selected aspects to be weaved. The proposed dynamic slicing technique has been named feature-aspect node marking dynamic slicing (FANMDS) algorithm. The proposed feature-aspect node marking dynamic slicing algorithm is based on marking and unmarking the executed nodes in the CFADG suitably during run-time. The advantage of the proposed approach is that no trace le is used to store the execution history. Also, the approach does not create any additional nodes during run-time.

Computing Dynamic Slices of Concurrent Feature-Oriented Programs

This paper proposes a dynamic slicing algorithm for concurrent feature-oriented programs. The algorithm is named concurrent feature-oriented node-marking dynamic slicing (CFNMDS) algorithm. The proposed dynamic slicing technique uses a dependence based intermediate representation named concurrent composite feature dependence graph (CCFDG). It is based on marking and unmarking of the executed nodes in CCFDG appropriately during runtime. Ten standard open source product lines have been taken to experiment the proposed CFNMDS algorithm. Jak codes and feature-oriented models have been developed for these product lines. The advantage of the proposed approach is that no trace file is used to store execution history of the program. Also, no extra nodes are created during runtime in the proposed approach. Creation of extra nodes leads to take more time for marking and unmarking process. Use of any extra file also leads to higher runtime overhead for input/output operations. This results in taking more time to compute the slices. So, it is necessary to compute dynamic slices in less time without using any trace file and extra nodes. Using the proposed approach, slices can be extracted in O(1) i.e., in constant time. The slice computation time for various combinations of features for each product line has also been measured.

Computing Dynamic Slices of Feature--Oriented Programs Using Execution Trace File

Feature-Oriented Programming (FOP) is a general paradigm for synthesizing programs in software product lines. A family of software systems constitutes a software product line (SPL). The unique characteristics of feature-oriented programs such as mixin layers, refinements of classes, refinements of constructors, constants, refinements, etc. pose special difficulties in the slicing of these programs. This paper proposes a dynamic slicing algorithm for feature-oriented programs. The algorithm is named Execution Trace File Based Feature-Oriented Dynamic Slicing (ETBFODS) algorithm. The ETBFODS algorithm uses a dependence based representation called Dynamic Feature Composition Dependence Graph (DFCDG) and an execution trace file to store execution history of the program for a given input. The dynamic slice is computed by traversing the DFCDG in breadth--first or depth-first wise and then mapping the resultant traversed vertices to the program statements.

Extended Feature Algebra

Feature Algebra was introduced as an abstract framework for feature-oriented software development. One goal is to provide a common, clearly defined basis for the key ideas of feature-orientation. The algebra captures major aspects of feature-orientation, such as the hierarchical structure of features and feature composition. However, as we will show, it is not able to model aspects at the level of code, i.e., situations where code fragments of different features have to be merged. In other words, it does not reflect details of concrete implementations.In this paper we first present concrete models for the original axioms of Feature Algebra which represent the main concepts of feature-oriented programs. This shows that the abstract Feature Algebra can be interpreted in different ways. We then use these models to show that the axioms of Feature Algebra do not properly reflect all aspects of feature-orientation from the level of directory structures down to the level of actual code. This gives motivation to extend the abstract algebra, which is the second main contribution of the paper. We modify the axioms and introduce the concept of an Extended Feature Algebra. As third contribution, we introduce more operators to cover concepts like overriding in the abstract setting.

Family-based performance measurement

Most contemporary programs are customizable. They provide many features that give rise to millions of program variants. Determining which feature selection yields an optimal performance is challenging, because of the exponential number of variants. Predicting the performance of a variant based on previous measurements proved successful, but induces a trade-off between the measurement effort and prediction accuracy. We propose the alternative approach of family-based performance measurement , to reduce the number of measurements required for identifying feature interactions and for obtaining accurate predictions. The key idea is to create a variant simulator (by translating compile-time variability to run-time variability) that can simulate the behavior of all program variants. We use it to measure performance of individual methods, trace methods to features, and infer feature interactions based on the call graph. We evaluate our approach by means of five feature-oriented programs. On average, we achieve accuracy of 98%, with only a single measurement per customizable program. Observations show that our approach opens avenues of future research in different domains, such an feature-interaction detection and testing.

Access control in feature-oriented programming

In feature-oriented programming ( FOP) a programmer decomposes a program in terms of features. Ideally, features are implemented modularly so that they can be developed in isolation. Access control mechanisms in the form of access or visibility modifiers are an important ingredient to attain feature modularity as they allow programmers to hide and expose internal details of a module’s implementation. But developers of contemporary feature-oriented languages have not considered access control mechanisms so far. The absence of a well-defined access control model for FOP breaks encapsulation of feature code and leads to unexpected program behaviors and inadvertent type errors. We raise awareness of this problem, propose three feature-oriented access modifiers, and present a corresponding access modifier model. We offer an implementation of the model on the basis of a fully-fledged feature-oriented compiler. Finally, by analyzing ten feature-oriented programs, we explore the potential of feature-oriented modifiers in FOP.