14 research outputs found
Fitting the Pieces Together: A Machine-Checked Model of Safe Composition
ABSTRACT Programs of a software product line can be synthesized by composing features which implement a unit of program functionality. In most product lines, only some combination of features are meaningful; feature models express the highlevel domain constraints that govern feature compatibility. Product line developers also face the problem of safe composition -whether every product allowed by a feature model is type-safe when compiled and run. To study the problem of safe composition, we present Lightweight Feature Java (LFJ), an extension of Lightweight Java with support for features. We define a constraint-based type system for LFJ and prove its soundness using a full formalization of LFJ in Coq. In LFJ, soundness means that any composition of features that satisfies the typing constraints will generate a well-formed LJ program. If the constraints of a feature model imply these typing constraints then all programs allowed by the feature model are type-safe
Recommended from our members
Extending Type Inference to Variational Programs
Through the use of conditional compilation and related tools, many software projects can be used to generate a huge
number of related programs. The problem of typing such variational software is difficult. The brute-force strategy
of generating all variants and typing each one individually is (1) usually infeasible for efficiency reasons and (2)
produces results that do not map well to the underlying variational program. Recent research has focused mainly
on efficiency and addressed only the problem of type checking. In this work we tackle the more general problem of
variational type inference and introduce variational types to represent the result of typing a variational program. We
introduce the variational lambda calculus (VLC) as a formal foundation for research on typing variational programs.
We define a type system for VLC in which VLC expressions are mapped to correspondingly variational types. We
show that the type system is correct by proving that the typing of expressions is preserved over the process of
variation elimination, which eventually results in a plain lambda calculus expression and its corresponding type.
We identify a set of equivalence rules for variational types and prove that the type unification problem modulo these
equivalence rules is unitary and decidable; we also present a sound and complete unification algorithm. Based on
the unification algorithm, the variational type inference algorithm is an extension of algorithm W. We show that
it is sound and complete and computes principal types. We also consider the extension of VLC with sum types, a
necessary feature for supporting variational data types, and demonstrate that the previous theoretical results also
hold under this extension. Finally, we characterize the complexity of variational type inference and demonstrate the
efficiency gains over the brute-force strategy.This is an author's peer-reviewed final manuscript, as accepted by the publisher. The published article is copyrighted by the Association for Computing Machinery and can be found at: http://toplas.acm.org/.Keywords: variational type inference, variational types, variational lambda calculu
Supporting the grow-and-prune model for evolving software product lines
207 p.Software Product Lines (SPLs) aim at supporting the development of a whole family of software products through a systematic reuse of shared assets. To this end, SPL development is separated into two interrelated processes: (1) domain engineering (DE), where the scope and variability of the system is defined and reusable core-assets are developed; and (2) application engineering (AE), where products are derived by selecting core assets and resolving variability. Evolution in SPLs is considered to be more challenging than in traditional systems, as both core-assets and products need to co-evolve. The so-called grow-and-prune model has proven great flexibility to incrementally evolve an SPL by letting the products grow, and later prune the product functionalities deemed useful by refactoring and merging them back to the reusable SPL core-asset base. This Thesis aims at supporting the grow-and-prune model as for initiating and enacting the pruning. Initiating the pruning requires SPL engineers to conduct customization analysis, i.e. analyzing how products have changed the core-assets. Customization analysis aims at identifying interesting product customizations to be ported to the core-asset base. However, existing tools do not fulfill engineers needs to conduct this practice. To address this issue, this Thesis elaborates on the SPL engineers' needs when conducting customization analysis, and proposes a data-warehouse approach to help SPL engineers on the analysis. Once the interesting customizations have been identified, the pruning needs to be enacted. This means that product code needs to be ported to the core-asset realm, while products are upgraded with newer functionalities and bug-fixes available in newer core-asset releases. Herein, synchronizing both parties through sync paths is required. However, the state of-the-art tools are not tailored to SPL sync paths, and this hinders synchronizing core-assets and products. To address this issue, this Thesis proposes to leverage existing Version Control Systems (i.e. git/Github) to provide sync operations as first-class construct