Liwei Shen

Towards feature-oriented variability reconfiguration in dynamic software product lines

Dynamic Software Product Line (DSPL) provides a new paradigm for developing self-adaptive systems with the principles of software product line engineering. DSPL emphasizes variability analysis and design at development time and variability binding and reconfiguration at runtime, thus requires some kinds of variability mechanisms to map high-level variations (usually represented by features) to low-level implementation and support runtime reconfiguration. Existing work on DSPL usually assumes that variation features can be directly mapped to coarse-grained elements like services, components or plug-ins, making the methods hard to be applied for traditional software systems. In this paper, we propose a feature-oriented method to support runtime variability reconfiguration in DSPLs. The method introduces the concept of role model, an intermediate level between feature variations and implementations to improve their traceability. On the other hand, the method involves a reference implementation framework based on dynamic aspect mechanisms to implement the runtime reconfiguration. We illustrate the process of applying the proposed method with a concrete case study, which helps to validate the effectiveness of our method.

Incremental and iterative reengineering towards Software Product Line: An industrial case study

It is common in practice that a Software Product Line (SPL) is constructed by reengineering a set of existing variant products. To alleviate the problems of high risks of failures and the limitations of resources and cost, incremental reengineering towards a SPL is a natural choice in many cases. However, several problems remain unaddressed properly, such as how to define increments, how to satisfy regular product delivery in parallel with reengineering, and how to achieve early successes. In this paper, we report an industrial case study on a successful SPL-targeted reengineering project conducted in Alcatel-Lucent. In this project, the project team applied the principles of agile development in the process of SPL reengineering. The key practices of the project include value-based increment definition, domain-driven responsibility alignment, iterative component refactoring and integration. We analyze the reengineering process of a major component qualitatively and quantitatively, with the focus on initial investment required, trend of investment, returns on investment and quality improvement. Our case study shows that incremental and iterative approach with stakeholder-value considerations can help to achieve steady and successful SPL reengineering in a cost-effective manner. We also find that SPL adoption can be regarded as an emergent result of the reconstruction and improvement of existing product assets.

Toward SLA-constrained service composition

In a market-oriented service computing environment, both back-end SLA (service level agreement) offers and front-end SLA requirements should be considered when performing service composition. In this paper, we address the optimization problem of SLA-constrained service composition and focus on the following issues: the difficulties related to preference definition and to weight assignment, the limitation of linear utility functions in identifying preferred skyline solutions, and the efficiency and scalability requirements of the optimization algorithm. We present a systematic approach based on a fuzzy preference model and on evolutionary algorithms. Specifically, we first model this multi-objective optimization problem using the weighted Tchebycheff distance rather than a linear utility function. We then present a fuzzy preference model for preference representation and weight assignment. In the model, a set of fuzzy linguistic preference terms and their properties are introduced for establishing consistent preference order of multiple QoS dimensions, and a weighting procedure is proposed to transform the preference into numeric weights. Finally, we present two evolutionary algorithms, i.e., single_EA and hybrid_EA, that implement different optimization objectives and that can be used in different SLA management scenarios for service composition. We conduct a set of experimental studies to evaluate the effectiveness of the proposed algorithms in determining the optimal solutions, and to evaluate their efficiency and scalability for different problem scales.

A Comprehensive Feature-Oriented Traceability Model for Software Product Line Development

Feature-oriented traceability is essential for efficient Software Product Line (SPL) development, including product derivation and SPL evolution. Widely-used feature based method has been proved to be effective in domain analysis and modeling. However, it cannot support the traceability naturally due to the big gap between the problem space and the solution space. In this paper, we propose a comprehensive feature-oriented traceability model for SPL development, which provides mechanisms for various features and implementation types throughout the four levels of goal model, feature model, feature implementation model and program implementations. In it, the feature implementation model is introduced as the intermediate level between features and implementation artefacts. The feature interactions are captured in the finer role level, and they help to clarify the complex mapping between features and program implementations. The traceability meta-model for SPL development is introduced and an example on the library management domain is demonstrated.

Feature Implementation Modeling Based Product Derivation in Software Product Line

Although there has been significant research spent on feature modeling and application-oriented customization and some effective methods have been proposed, product derivation in SPL (Software Product Line) development is still a time- and effort-consuming activity due to the complicated mapping between feature model and program implementation. In this paper, we propose a feature implementation modeling based method for product derivation. In the method, feature implementation model is introduced as the intermediate level between feature model and program implementation. The feature implementation model captures feature interactions (including cross-cutting interactions) in the finer role level, and help to clarify the complex mapping between feature and program implementation. So, feature-driven program-level customization and configuration can be enabled by the model and role instantiation. AOP (Aspect-Oriented Programming) is adopted as the implementation technology for product derivation on the program level. Then program-level composition can be implemented by aspect weaving to finally achieve the feature-driven product derivation.

Software Product Line Engineering for Developing Self-Adaptive Systems: Towards the Domain Requirements

Self-adaptive systems are now facing the anticipation of mass customization. Therefore, the Software Product Line (SPL) engineering for developing Self-Adaptive systems (SPL4SA) can be an effective way. At the first sight, SPL4SA is the straightforward combination of the two methodologies of SPL engineering and self-adaptive systems. However, the direct and unsystematic combination will bring difficulty in the domain requirements analysis and in the customization process. In this paper, in order to give a solution to the practical problems, we propose a domain requirements meta-model in SPL4SA. It is described with different point of views and the variability binding constraints inside are emphasized. Based on it, a guidance is concluded to support the consistent customization towards the domain model. In addition, an experimental study about a web-based business product line involving self-adaptation capability is conducted to evaluate the model.

Synchronized Architecture Evolution in Software Product Line Using Bidirectional Transformation

In the long-term evolution of a Software Product Line (SPL), how to ensure the alignment between the reference and application architectures is a critical problem. Existing ad-hoc methods for architecture synchronization cannot ensure the completeness. In this paper, we propose a model-driven method for synchronized SPL architecture evolution using bidirectional transformation, a well-developed technique with solid mathematical foundation. Based on the model-based architecture representation, we capture the variability-intensive consistency relations between reference and application architectures and specify them with Beanbag [1], a declarative language supporting operation-based synchronization. Then, with the generated synchronizer and additional mechanisms, we can achieve coordinated architecture evolution through periodic synchronizations.

Quality-Driven Self-Adaptation: Bridging the Gap between Requirements and Runtime Architecture by Design Decision

Running with static requirements and design decisions, a software system cannot always perform optimally in a highly uncertain and rapidly changing environment. Quality-driven self-adaptation, which enables a software system to continually adapt its structure and behavior to improve the overall quality satisfaction, thus becomes a promising capability of software systems. Existing researches on self-adaptive systems, although having proposed effective methods and techniques on requirements-driven self-adaptation and reflective components, do not well address the gap between requirements and runtime architecture. In this paper, we propose a quality-driven self-adaptation approach, which incorporates both requirements- and architecture-level adaptations. At the requirements level, value-based quality tradeoff decisions are made with the aim of maximizing system-level value propositions. At the architecture level, component-based architecture adaptations are conducted. To bridge the gap between requirements and runtime architecture, design decisions capturing alternative design options and their rationales are introduced to help map requirements adaptations and context changes to adaptation operations on the runtime architecture. To validate the effectiveness, we implement the approach based on a reflective component model and conduct an experimental study on it. The results show that the approach leads to better performance compared with traditional software and the overall quality satisfaction is kept maintained. Furthermore, the development effort is affordable but the approach still has shortage in extensibility.

Coordination-Policy Based Composed System Behavior Derivation

The coordination-policy that components interactions satisfied often determines the properties of nowadays component-based information systems, e.g. safety, liveness and fairness etc. Therefore, how to derive coordination-policy satisfying behavior all out of such system to achieve better system properties is of a significant problem that needs to be solved. Aim to this problem, we propose an optimistic policy- satisfying behavior derivation approach in this paper. The main idea of the approach is to automatically construct a Coordination Environment (CE) for such composed system that system components can work together in a deadlock-free and policy-satisfying manner, and so as to obtain desired system properties. In this approach, component-based information system is modeled by interface automaton network (IAN), and component coordination-policies are specified by LTL. To explain the correctness and validity of this approach, we give a corresponding example certification.

Feature-Driven and Incremental Variability Generalization in Software Product Line

In the lifecycle of a software product line (SPL), incremental generalization is usually required to extend the variability of existing core assets to support the new or changed application requirements. In addition, the generalization should conform to the evolved SPL requirements which are usually represented by a feature model. In this paper, we propose a feature-driven and incremental variability generalization method based on the aspect-oriented variability implementation techniques. It addresses a set of basic scenarios where program-level JBoss-AOP based reference implementations respond to the feature-level variability generalization patterns. It also provides the corresponding guidance to compose these patterns in more complex cases. Based on the method, we present a case study and related discussions.