A Feature Model of E-Government Systems Integrated with Formal Specifications

Software product line (SPL) engineering has emerged to become a mature domain for maximizing reuse within the context of a family of related software products. Within the process of SPL, the variability and commonality among the different products within the scope of a family is captured and modeled into a system's `feature model'. Currently, there are no architecture description languages (ADLs) that support the relationship between the feature model domain and the system architecture domain, leaving a gap which significantly increases the complexity of analyzing the system's architecture and insuring that it complies with its set feature model and variability requirements. In this paper we present ADLARS, an architecture description language that supports the relationship between the system's feature model and the architectural structures in an attempt to alleviate the aforementioned problem. The link between the two spaces also allows the automatic generation of product architectures from the family reference architecture

Software Product Lines (SPL) are systematic approach to develop families of similar software products by explicating their commonalities and variability, e.g., in a feature model. Using techniques from model-driven development, it is then possible to automatically derive a concrete product from a given configuration (i.e., selection of features). However, this is problematic for interactive applications with complex user interfaces (UIs) as automatically derived UIs often provide limited usability. Thus, in practice, the UI is mostly created manually for each product, which results in major drawbacks concerning efficiency and maintenance, e.g., when applying changes that affect the whole product family. This paper investigates these problems based on real-world examples and analyses the development of product families from a UI perspective. To address the underlying challenges, we propose the use of abstract UI models, as used in HCI, to bridge the gap between automated, traceable product derivation and customized, high quality user interfaces. We demonstrate the feasibility of the approach by a concrete example implementation for the suggested model-driven development process.

Modern conflict-driven clause-learning (CDCL) Boolean SAT solvers provide efficient automatic analysis of real-world feature models (FM) of systems ranging from cars to operating systems. It is well-known that solver-based analysis of real-world FMs scale very well even though SAT instances obtained from such FMs are large, and the corresponding analysis problems are known to be NP-complete. To better understand why SAT solvers are so effective, we systematically studied many syntactic and semantic characteristics of a representative set of large real-world FMs. We discovered that a key reason why large real-world FMs are easy-to-analyze is that the vast majority of the variables in these models are unrestricted, i.e., the models are satisfiable for both true and false assignments to such variables under the current partial assignment. Given this discovery and our understanding of CDCL SAT solvers, we show that solvers can easily find satisfying assignments for such models without too many backtracks relative to the model size, explaining why solvers scale so well. Further analysis showed that the presence of unrestricted variables in these real-world models can be attributed to their high-degree of variability. Additionally, we experimented with a series of well-known nonbacktracking simplifications that are particularly effective in solving FMs. The remaining variables/clauses after simplifications, called the core, are so few that they are easily solved even with backtracking, further strengthening our conclusions. We explain the connection between our findings and backdoors, an idea posited by theorists to explain the power of SAT solvers. This connection strengthens our hypothesis that SAT-based analysis of FMs is easy. In contrast to our findings, previous research characterizes the difficulty of analyzing randomly-generated FMs in terms of treewidth. Our experiments suggest that the difficulty of analyzing real-world FMs cannot be explained in terms of treewidth.

This paper presents a quantitative radiomics feature model for performing prostate cancer detection using multiparametric MRI (mpMRI). It incorporates a novel tumor candidate identification algorithm to efficiently and thoroughly identify the regions of concern and constructs a comprehensive radiomics feature model to detect tumorous regions. In contrast to conventional automated classification schemes, this radiomics-based feature model aims to ground its decisions in a way that can be interpreted and understood by the diagnostician. This is done by grouping features into high-level feature categories which are already used by radiologists to diagnose prostate cancer: Morphology, Asymmetry, Physiology, and Size (MAPS), using biomarkers inspired by the PI-RADS guidelines for performing structured reporting on prostate MRI. Clinical mpMRI data were collected from 13 men with histology-confirmed prostate cancer and labeled by an experienced radiologist. These annotated data were used to train classifiers using the proposed radiomics-driven feature model in order to evaluate the classification performance. The preliminary experimental results indicated that the proposed model outperformed each of its constituent feature groups as well as a comparable conventional mpMRI feature model. A further validation of the proposed algorithm will be conducted using a larger dataset as future work.

Automating feature model refactoring: A Model transformation approach

Feature models are widely used for describing the variability of a software product line. A feature model contains a tree of features and a set of constraints over these features, which define valid feature combinations. In the industrial practice, large feature models containing hundreds of features and constraints are common. Furthermore, in a hierarchical product line a feature model can be related to other feature models through inter-model constraints. Due to the model size and complexity, understanding industrial feature models is a challenging task.In this paper, we describe the feature model understanding challenges reported by feature model developers at Robert Bosch GmbH. To support the developers in model understanding, we extend the idea of a feature implication graph to feature relation graph by abstracting groups of implications to feature relations. A transitively closed relation graph shows all modeled and implicit feature relations and spans all related feature models. The graph is also used to identify modeling problems, such as false optional or dead features, and to show the derivation of any implicit relation or problem from the modeled constraints. In a case study at Bosch, we evaluate the use of feature relation graph for model understanding. We propose further use cases of the graph, supporting model maintenance, evolution and configuration.

The feature model considers several products as a collection of features and describes the commonality and variability of the family in terms of feature relationships. Traditional informal feature models lacked the support of tools to automate the process of feature modeling, so formal methods were introduced implement automated support for feature modeling tools. For large software, writing formal specifications for feature models directly is quite difficult and requires technical background and experience. In this paper, we propose a formal template-based approach to constructing feature models and their formal descriptions, each template is used to formalize a class of PFA expressions. We give a structural definition of the templates and for constructing feature models from templates and generating formal descriptions of the corresponding features. We give a case study to illustrate the effectiveness of our method.

Needs for mass customization and economies of scale have pushed engineers to develop Software Product Lines (SPLs). SPLs are families of products sharing commonalities and exhibiting differences, built by reusing software assets abstractly represented by features. Feature models describe the constraints that link the features and allow the configuration of tailored software products. Common SPLs involve hundreds, even thousands of features, leading to billions of possible software products. As a result, testing a product line is challenging due to the enormous size of the possible products. Existing techniques focus on testing based on the product line's feature model by selecting a limited set of products to test. Being created manually or reverse-engineered, feature models are prone to errors impacting the generated test suites. In this paper, we examine ability of test suites to detect such errors. In particular, we propose two mutation operators to derive erroneous feature models (mutants) from an original feature model and assess the capability of the generated original test suite to kill the mutants. Experimentation on real feature models demonstrate that dissimilar tests suites have a higher mutant detection ability than similar ones, thus validating the relevance of similarity-driven product line testing.

Feature models are frequently used to capture the knowledge about configurable software systems and product lines. However, feature modeling of large-scale systems is challenging as many models are needed for diverse purposes. For instance, feature models can be used to reflect the perspectives of product management, technical solution architecture, or product configuration. Furthermore, models are required at different levels of granularity. Although numerous approaches and tools are available, it remains hard to define the purpose, scope, and granularity of feature models. In this paper we thus present experiences of developing feature models for two large-scale industrial automation software systems. Specifically, we extended an existing feature modeling tool to support models for different purposes and at multiple levels. We report results on the characteristics and modularity of the feature models, including metrics about model dependencies. We further discuss lessons learned during the modeling process.

Feature modeling is used to express commonality and variability among a family of software products called the software product line. To offer customized products to their customers, organizations need to build packages of features taking into consideration customer needs and preferences. This paper presents a platform named SPLP (Software Product Line Profiling) which allows pre-configuring feature models through the restriction of the configuration space to meet the requirements of a specific market segment. Considering that concerns and preferences of this latter are a key criteria to achieve a tailored pre-configuration, authors propose the integration of user profiling in the SPLP platform through the definition of a user profile model describing information about the user and the products he is used to consume. This information is then exploited by the SPLP platform to perform an automated pre-configuration according to each user profile requirements and preferences.

This paper presents a feature modeling endeavour for a television set product family by a major consumer electronics company. This work consists of three stages. First, a feature model is constructed, based on the analysis of the product family requirements. The constructed model is supplemented with a feature glossary. FeatureIDE is used as the model editor. Feature attributes, not supported by FeatureIDE, are represented in the basic feature model by using additional features. Second, the feature model in XML is converted into the schema of the analysis tool, using a custom parser developed for this purpose. Third, the model is analyzed by well-known analysis operations. FAMA is used as the analysis tool. Performance results are obtained. Finally, lessons learned from the whole effort are discussed.

Modern systems need to be able to self-adapt to changes in user needs, and changes affecting the system itself or its environment. Dynamic software product line (DSPL) is an engineering approach for developing self-adaptive systems based on commonalities and variabilities for a family of similar systems. Currently, many DSPL approaches fail to meet all adaptability requirements, and in many cases, they are developed in a such unstructured manner that the controller is not explicitly represented, for example. We specify a two-dimension taxonomy to address basic technical issues for realising variability in DSPLs. The self-adaptation dimension classifies the different design choices for the adaptability requirements. The DSPL variability dimension classifies different design choices for implementing variability schemes and for creating different kinds of feature models. Our study was substantiated by surveying several DSPL approaches, and evaluating and comparing their different design strategies. We also summarise practical issues and difficulties, identify major trends in actual DSPL proposals, and suggest directions for future.

Creating products according to own needs is omnipresent on the Internet. We choose the properties we want to have in a product from a product configurator, such as a car or printer configurator. The underlying models from the configurators are hidden. The migration of legacy configurators into feature models is meaningful to use the advantages of software configurations for product configurators. We introduce an abstraction level and assumptions for product configurators to readout information needed for a feature model. Furthermore, we develop an algorithm called FeatureDiagramSynthesizer. The algorithm consists of two parts which are finding features and adding constraints. For the algorithm, different strategies are used to create the feature model from a product configurator. Moreover, we implement the extensible algorithm FeatureDiagramSynthesizer and a prototype for the product configurator from Ricoh. Based on our developed algorithm, it is only basically possible to readout a feature models from product configurators which fulfill our assumptions.

Software product line engineering (SPLE) is a paradigm to promote systematic software reuse. A Feature Model (FM) is a common means to illustrate the commonality and variability of software products in a family. In most existing FM extraction approaches, keywords in the requirement document or certain types of system behavior or external events are considered features. The resulting FM is a combination of user activities and system actions (SAs), making it hard to understand. In this paper, we present an automatic approach to generate a product line FM from multiple requirement documents. We consider user activity and SAs separately in our approach and focus on the expected behaviors of the software system, together with the data being processed. The resulting FM clearly illustrates the expected functionalities of the software system and their variability in the product line. We also compared our approach with existing techniques by processing the same textual documents, and noted improvements in our results.

Trusted Product Lines