David Wille

Interface variability in family model mining

Model-driven development of software gains more and more importance, especially in domains with high complexity. In order to develop differing but still similar model-based systems, these models are often copied and modified according to the changed requirements. As the variability between these different models is not documented, issues arise during maintenance. For example, applying patches becomes a tedious task because errors have to be fixed in all of the created models and no information about modified and unchanged parts exists. In this paper, we present an approach to analyze related models and determine the variability between them. This analysis provides crucial information about the variability (i.e., changed parts, additional parts, and parts without any modification) between the models in order to create family models. The particular focus is the analysis of models containing components with differing interfaces.

Family model mining for function block diagrams in automation software

Automation systems are mostly individual highly customized system variants, consisting both of hardware and software. In order to reduce development effort, it is a common practice to use a clone-and-own approach by modifying an existing variant to fit the changed requirements of a new variant. The information about the commonalities and differences between those variants is usually not well documented and leads to problems in maintenance, testing and evolution. To alleviate these problems, in this paper, we present an improved version of a family mining approach for automatically discovering commonality and variability between related system variants. We apply this approach to function block diagrams used to develop automation software and show its feasibility by a manufacturing case study.

Managing lots of models: the FaMine approach

In this paper we present recent developments in reverse engineering variability for block-based data-flow models.

Extractive software product line engineering using model-based delta module generation

To satisfy demand for customized products, companies commonly apply so-called clone-and-own strategies by copying functionality from existing products and modifying it to create product variants that have to be developed, maintained, and evolved in isolation. In previous work, we introduced a variability mining technique to identify variability information (commonalities and differences) in block-based model variants (e.g., MATLAB/Simulink models), which can be used to guide manual transition from clone-and-own to managed reuse of a software product line (SPL). In this paper, we present a procedure that uses the extracted variability information to generate a transformational delta-oriented SPL fully automatically. We generate a delta language specifically tailored to transforming models in the analyzed modeling language and utilize it to generate delta modules expressing variation of the SPLs implementation artifacts. The procedure seamlessly integrates with our variability mining technique and allows to fully adopt a managed reuse strategy (i.e., generation of products from a single code base) without manual overhead. We show the feasibility of the procedure by applying it to state chart and MATLAB/Simulink model variants from two industrial case studies.

Identifying Variability in Object-Oriented Code Using Model-Based Code Mining

A large set of object-oriented programming (OOP) languages exists to realize software for different purposes. Companies often create variants of their existing software by copying and modifying them to changed requirements. While these so-called clone-and-own approaches allow to save money in short-term, they expose the company to severe risks regarding long-term evolution and product quality. The main reason is the high manual maintenance effort which is needed due to the unknown relations between variants. In this paper, we introduce a model-based approach to identify variability information for OOP code, allowing companies to better understand and manage variability between their variants. This information allows to improve maintenance of the variants and to transition from single variant development to more elaborate reuse strategies such as software product lines. We demonstrate the applicability of our approach by means of a case study analyzing variants generated from an existing software product line and comparing our findings to the managed reuse strategy.

Variability mining of state charts

Companies commonly use state charts to reduce the complexity of software development. To create variants with slightly different functionality from existing products, it is common practice to copy the corresponding state charts and modify them to changed requirements. Even though these so-called clone-and-own approaches save money in the short-term, they introduce severe risks for software evolution and product quality in the long term as the relation between the software variants is lost so that all products have to be maintained separately. In previous work, we introduced variability mining algorithms to identify the relations between related MATLAB/Simulink model variants regarding their common and varying parts. In this paper, we adapt these algorithms for state charts by applying guidelines from previous work to make them available for developers to better understand the relations between a set of state chart variants. Using this knowledge, maintenance of related variants can be improved and migration from clone-and-own based single variant development to more elaborate reuse strategies is possible to increase maintainability and the overall product quality. We demonstrate the feasibility of variability mining for state charts by means of a case study with models of realistic size.

Improving custom-tailored variability mining using outlier and cluster detection

Abstract To satisfy demand for customized software solutions, companies commonly use so-called clone-and-own approaches to reuse functionality by copying existing realization artifacts and modifying them to create new product variants. Lacking clear documentation about the variability relations (i.e., the common and varying parts), the resulting variants have to be developed, maintained and evolved in isolation. In previous work, we introduced a semi-automatic mining algorithm allowing custom-tailored identification of distinct variability relations for block-based model variants (e.g., MATLAB/Simulink models or statecharts) using user-adjustable metrics. However, variants completely unrelated with other variants (i.e., outliers) can negatively influence the usefulness of the generated variability relations for developers maintaining the variants (e.g., erroneous relations might be identified). In addition, splitting the compared models into smaller sets (i.e., clusters) can be sensible to provide developers separate view points on different variable system features. In further previous work, we proposed statistical clustering capable of identifying such outliers and clusters. The contribution of this paper is twofold. First, we present guidelines and a generic implementation that both ease adaptation of our variability mining algorithm for new languages. Second, we integrate our clustering approach as a preprocessing step to the mining. This allows users to remove outliers prior to executing variability mining on suggested clusters. Using models from two industrial case studies, we show feasibility of the approach and discuss how our clustering can support our variability mining in identifying sensible variability information.

Decision Support for Reducing Unnecessary IT Complexity of Application Architectures

As many companies exist for decades, their software systems and IT architectures grow massively with the companies requirements. To avoid failures due to changes to a productive system, new demands often lead to new solutions while neglecting to restructure existing software systems despite a similar purpose of use. As a consequence, the IT complexity of such software systems and IT architectures increases sharply accompanied by higher costs, reduced adaptability and increased effort for evolving and maintaining the entire IT landscape. Although there are applications that fulfill a companys requirements, there are also software solutions and variants of them that seems to be redundant. This causes unnecessary IT complexity, which is not essential for a companys goals and requirements. To identify and reduce this unnecessary part of IT complexity, we introduce an approach to support experts in decision making regarding these redundant artifacts. We provide a method to identify variability of application architectures (AAs) and an iterative decision process to determine and remove artifacts that are not required, which enable experts to reduce unnecessary IT complexity of given AAs. We show the feasibility of our approach by applying it to industrial data in a preliminary case study.

Automated recommendations for reducing unnecessary variability of technology architectures

A technology architecture (TA) represents the technical infrastructure of a company and consists of hardware and software components. As the evolution of such TAs is typically uncoordinated, their complexity often grows with a company’s requirements. As a consequence, a variety of redundancies and architectural variants exist, which are not necessary for the architecture’s purpose. This leads to increased costs and higher effort for evolving and maintaining the entire IT landscape. To alleviate these problems, unnecessary variability has to be identified and reduced. As a manual approach requires high effort and is not feasible for largescale analysis, experts face a major challenge. For this purpose, we propose an automated approach, which provides experts with recommendations for restructurings of related TAs in order to reduce unnecessary variability. We show suitability of our approach by expert interviews and an industrial case study with real-world TAs.

Detecting Variability in MATLAB/Simulink Models: An Industry-Inspired Technique and its Evaluation

Model-based languages such as MATLAB/Simulink play an essential role in the model-driven development of software systems. To comply with new requirements, it is common practice to create new variants by copying existing systems and modifying them. Commonly referred to as clone-and-own, severe problems arise in the long-run when no dedicated variability management is installed. To allow for a documented and structured reuse of systems, their variability information needs to be reverse-engineered. In this paper, we propose an advanced comparison procedure, the Matching Window Technique, and a customizable metric. Both allow us to overcome structural alterations commonly performed during clone-and-own. We analyze related MATLAB/Simulink models and determine, classify and represent their variability information in an understandable way. With our technique, we assist model engineers in maintaining and evolving existing variants. We provide three feasibility studies with real-world models from the automotive domain and show our technique to be fast and precise. Furthermore, we perform semi-structured interviews with domain experts to assess the potential applicability of our technique in practice.