Some limitations of object-oriented mechanisms are known to cause code clones (e. g., extension using inheritance). Novel programming paradigms such as feature-oriented programming (FOP) aim at alleviating these limit...
详细信息
ISBN:
(纸本)9781450301541
Some limitations of object-oriented mechanisms are known to cause code clones (e. g., extension using inheritance). Novel programming paradigms such as feature-oriented programming (FOP) aim at alleviating these limitations. However, it is an open issue whether FOP is really able to avoid code clones or whether it even facilitates (FOP-related) clones. To address this issue, we conduct an empirical analysis on ten feature-oriented software product lines with respect to code cloning. We found that there is a considerable number of clones in feature-oriented software product lines and that a large fraction of these clones is FOP-related (i.e., caused by limitations of feature-oriented mechanisms). Based on our results, we initiate a discussion on the reasons for FOP-related clones and on how to cope with them. We show by means of examples how such clones can be removed by applying refactorings.
feature-oriented programming (FOP) and Aspect-orientedprogramming (AOP) are complementary methodologies that can be combined to overcome their individual limitations. In the present study. usefulness of this approach...
详细信息
ISBN:
(数字)9783642227097
ISBN:
(纸本)9783642227080
feature-oriented programming (FOP) and Aspect-orientedprogramming (AOP) are complementary methodologies that can be combined to overcome their individual limitations. In the present study. usefulness of this approach has been investigated in developing Insurance Software: TG_Lifelnsurancesoft, using Eclipse-featureIDE-AJDT open source environment with feature composition framework and enhanced tool chain: featureHouse. It is observed that integration of AOP concepts into stepwise refinement method of FOP enhances its capability of expressing and handling homogeneous as well as advanced dynamic crosscutting, thus reducing code redundancy, complexity, development time, maintainability and cost of the software system. The study concludes that combination of FOP and AOP methodologies using Eclipse-featureIDE-AJDT environment offers a powerful support for modular design and implementation of comprehensible. reusable, consistent, maintainable and cost effective insurance software system with user selected features.
Achieving software reuse is a fundamental problem in software engineering. Component-based development (CBD) is widely accepted as a promising approach for software reuse. Current methods for component reuse concentra...
详细信息
ISBN:
(纸本)9781424445189
Achieving software reuse is a fundamental problem in software engineering. Component-based development (CBD) is widely accepted as a promising approach for software reuse. Current methods for component reuse concentrate primarily on the component consumer perspective, which are lack of the potential for component evolution itself. This paper proposes two complementary approaches to reusing existing components: binary class-level inheritance and feature composition. To meet variability requirements, a new component can be derived across component module from an old component. Furthermore, to narrow the gulf between the user and the developer perspectives, the system features are decomposed into a set of independent feature components that can be plugged into running object. The design and implementation method on component platform is presented. At last, this paper introduces the graphic user interface and mobile telephone projects development experiments that show the two approaches contribute to reuse.
A software product line comprises a set of products that share a common code base, but vary in specific characteristics called features. Ideally, features of a product line are developed in isolation and composed subs...
详细信息
ISBN:
(纸本)9781450371384
A software product line comprises a set of products that share a common code base, but vary in specific characteristics called features. Ideally, features of a product line are developed in isolation and composed subsequently. Product lines are increasingly used for safety-critical software, for which quality assurance becomes indispensable. While the verification of product lines gained considerable interest in research over the last decade, the subject of how to specify product lines is only covered rudimentarily. One challenge is composition;similar to inheritance in object-orientedprogramming, features of a product line may refine other features along with their specifications. In our work [1], we present a comprehensive discussion and empirical evaluation of how to specify product lines implemented by means of feature-oriented programming. In feature-oriented programs, implementation artifacts, such as methods, are distributed over the set of feature modules and subsequently composed together when the respective features are selected. Similar to this idea, contracts could be modularized, too, and are subsequently composed together with their respective methods. In particular, we investigate how refinement and composition of such specifications can be established and derive a notion of feature-oriented contracts comprising preconditions, postconditions, and framing conditions of a method (i.e., following the design-by-contract paradigm). While both design by contract and feature-oriented programming have been hot research topics for more than two decades, their combination had rarely been explored. When features refine methods, an important question is whether refinement of their contracts is inevitable or not. However, unlike method composition where only the order of features is relevant, it seems that contract composition has to be handled differently according to certain scenarios. Consequently, a diverse set of composition techniques is required. In total,
Software Product Lines (SPLs) enable customization by reusing commonalities and variabilities within a family of similar software systems. Design patterns are best practices of established solutions in object-oriented...
详细信息
ISBN:
(纸本)9789897582837
Software Product Lines (SPLs) enable customization by reusing commonalities and variabilities within a family of similar software systems. Design patterns are best practices of established solutions in object-oriented source code for recurring design challenges. Although certain design patterns realize variability, they are only defined in the context of stand-alone systems and not for SPLs. Employing design patterns to realize variability allows using best practices in design for SPL development. However, the exact usage of design patterns within SPLs has not been explored, and a formal notation to capture their usage within different features does not exist. In this work, we provide a model-based analysis method to determine the variability-aware usage of design patterns in source code within the context of feature-oriented programming (FOP). Moreover, we introduce Family Role Models (FRMs) as an extension to role modeling, which offer a language-independent, unified, formal notation for decomposed design patterns. We apply the analysis method in a case study on the variability-aware usage of design patterns in feature-oriented SPLs and derive FRMs from the results.
Software product lines (SPLs) are used to create tailor-made software products by managing and composing reusable assets. Generating a software product from the assets of an SPL is possible statically before runtime o...
详细信息
ISBN:
(纸本)9781605582672
Software product lines (SPLs) are used to create tailor-made software products by managing and composing reusable assets. Generating a software product from the assets of an SPL is possible statically before runtime or dynamically at load-time or runtime. Both approaches have benefits and drawbacks with respect to composition flexibility, performance, and resource consumption. Which type of composition is preferable should be decided by taking the application scenario into account. Current tools and languages, however, force a programmer to decide between static and dynamic composition during development. In this paper, we present an approach that employs code generation to support static and dynamic composition of features of a single code base. We offer an implementation on top of featureC++, an extension of the C++ programming language that supports software composition based on features. To simplify dynamic composition and to avoid creation of invalid products we furthermore provide means to (1) validate the correctness of a composition at runtime, (2) automatically instantiate SPLs in case of stand-alone applications, and (3) automatically apply interaction code of crosscutting concerns.
Analyzing software product lines is difficult, due to their inherent variability. In the past, several strategies for product-line analysis have been proposed, in particular, product-based, feature-based, and family-b...
详细信息
ISBN:
(纸本)9781450323734
Analyzing software product lines is difficult, due to their inherent variability. In the past, several strategies for product-line analysis have been proposed, in particular, product-based, feature-based, and family-based strategies. Despite recent attempts to conceptually and empirically compare different strategies, there is no work that empirically compares all of the three strategies in a controlled setting. We close this gap by extending a compiler for feature-oriented programming with support for product-based, feature-based, and family-based type checking. We present and discuss the results of a comparative performance evaluation that we conducted on a set of 12 feature-oriented, JAVA-based product lines. Most notably, we found that the family-based strategy is superior for all subject product lines: it is substantially faster, it detects all kinds of errors, and provides the most detailed information about them.
Software product lines (SPLs) and adaptive systems aim at variability to cope with changing requirements. Variability can be described in terms of features, which are central for development and configuration of SPLs....
详细信息
ISBN:
(纸本)9781450306898
Software product lines (SPLs) and adaptive systems aim at variability to cope with changing requirements. Variability can be described in terms of features, which are central for development and configuration of SPLs. In traditional SPLs, features are bound statically before runtime. By contrast, adaptive systems support feature binding at runtime and are sometimes called dynamic SPLs (DSPLs). DSPLs are usually built from coarse-grained components, which reduces the number of possible application scenarios. To overcome this limitation, we closely integrate static binding of traditional SPLs and runtime adaptation of DSPLs. We achieve this integration by statically generating a tailor-made DSPL from a highly customizable SPL. The generated DSPL provides only the runtime variability required by a particular application scenario and the execution environment. The DSPL supports self-configuration based on coarse-grained modules. We provide a feature-based adaptation mechanism that reduces the effort of computing an optimal configuration at runtime. In a case study, we demonstrate the practicability of our approach and show that a seamless integration of static binding and runtime adaptation reduces the complexity of the adaptation process.
Synchronization is a good candidate for an aspect in aspect-orientedprogramming (AOP) since programmers have to choose the best granularity of synchronization for the underlying hardware to obtain the best execution ...
详细信息
ISBN:
(纸本)9781605584942
Synchronization is a good candidate for an aspect in aspect-orientedprogramming (AOP) since programmers have to choose the best granularity of synchronization for the underlying hardware to obtain the best execution performance. If synchronization is an aspect, programmers can change the synchronization code independently of the rest of the program when the program runs on different hardware. However, existing AOP languages such as AspectJ have problems. They cannot select an arbitrary code region as a join point. Moreover, they cannot enforce weaving of a synchronization aspect. Since it is an alternative feature in feature modeling, at least one of available synchronization aspects must be woven. Otherwise, the program would be thread-unsafe. Since an aspect in AspectJ is inherently optional, programmers must be responsible for weaving it. To solve these problems, this paper proposes two new constructs for AspectJ, region cut and assertions for advice. Regioncut selects arbitrary code region as a join point and assertion for advice enforces weaving a mandatory advice. We implemented these constructs by extending the AspectBench compiler. We evaluated the design of our constructs by applying them to two open-source software products, Javassist and Hadoop.
Programs can be composed from features. We want to verify automatically that all legal combinations of features can be composed safely without errors. Prior work on this problem assumed that features add code monotoni...
详细信息
ISBN:
(纸本)9781605584942
Programs can be composed from features. We want to verify automatically that all legal combinations of features can be composed safely without errors. Prior work on this problem assumed that features add code monotonically. We generalize prior work to enable features to add and remove code, describe our analyses and implementation, and review case studies. We observe that more expressive features increase the complexity of developed programs rapidly - up to the point where tools and automated concepts as presented in this paper are indispensable for verification.
暂无评论