Language interoperability (e.g., calling Python methods from Java programs) is a critical challenge in software development, often leading to code inconsistencies, human errors, and reduced readability.

Understanding variability is essential to allow the configuration of software systems to diverse requirements. Variability-aware program analysis techniques have been proposed for analyzing the space of program variants. Such techniques are highly beneficial, e.g., to determine the potential impact of changes during maintenance. This article presents an interprocedural and configuration-aware change impact analysis (CIA) approach for determining the possibly impacted source code elements when changing the source code of a product family. The approach also supports engineers, who are adapting the code of specific product variants after an initial pre-configuration. The approach can be adapted to work with different variability mechanisms, it is more precise than existing CIA approaches, and it can be implemented using standard control flow and data flow analysis. We report evaluation results on the benefit and performance of the approach using industrial product lines.

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 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. This paper first reports results and experiences of an exploratory case study on developing feature models for two large-scale industrial automation software systems. We report results on the characteristics and modularity of the feature models, including metrics about model dependencies. Based on the findings from the study, we developed FORCE, a modeling language, and tool environment that extends an existing feature modeling approach to support models for different purposes and at multiple levels, including mappings to the code base. We demonstrate the expressiveness and extensibility of our approach by applying it to the well-known Pick and Place Unit example and an injection molding subsystem of an industrial product line. We further show how our approach supports consistency between different feature models. Our results and experiences show that considering the purpose and level of features is useful for modeling large-scale systems and that modeling dependencies between feature models is essential for developing a system-wide perspective.

Today's software systems need to be highly flexible and managing their variability plays an essential role during development. Variability-aware program analysis techniques have been proposed to support developers in understanding code-level variability by analyzing the space of program variants. Such techniques are highly beneficial, e.g., when determining the impact of changes during maintenance and evolution. Two strategies have been proposed in the literature to make existing program analysis techniques variability-aware:(i) program analysis can be lifted by considering variability already in the parsing stage; or(ii) analysis can be delayed by considering and recovering variability only when needed. Both strategies have advantages and disadvantages, however, a systematic comparison is still missing. The contributions of this paper are an in-depth comparison of SPLLIFT and COACH, two existing approaches representing these two strategies, and an analysis and discussion of the trade-offs regarding precision and run-time performance. The results of our experiment show that the delayed strategy is significantly faster but typically less precise. Our findings are intended for researchers and practitioners deciding which strategy to select for their purpose and context.

Static code analysis techniques examine programs without actually executing them. The main benefits lie in improving software quality by detecting problematic code constructs and potential defects in early development stages. Today, static code analysis is a widely used quality assurance technique and numerous tools are available for established programming languages like C/C++, Java, or C#. However, in the domain of programmable logic controller (PLC) programming, static code analysis tools are still rare, although many properties of PLC programming languages are beneficial for static analysis techniques. Therefore, an approach and tool for static code analysis of IEC 61131-3 programs has been developed which is capable of detecting a range of issues commonly occurring in PLC programming. The approach employs different analysis methods, like pattern-matching on program structures, control flow and data flow analyses, and, especially, call graph and pointer analysis techniques. Based on results from an initial analysis project, where common issues for static analysis of PLC programs have been investigated, this paper illustrates adoption and extensions of analysis techniques for PLC programs and presents results from large-scale industrial application.

Slicing-based change impact analysis is an important and established technique to assess the effects of modifications to source code. Program slicing is usually done by performing a graph reachability analysis on a system dependence graph representing the control and data flow dependencies between statements. However, analyzing large-scale software systems can lead to performance issues, resulting in huge dependence graphs and long analysis times. In this paper we present an approach that exploits the modularity of large-scale systems to first perform program analysis for individual modules, and later compose the pre-computed analysis results. However, partitioning a system dependence graph is not straightforward, as it carries presence conditions representing variability. We thus use placeholders that are resolved when composing the pre-computed SDG modules during configuration-aware program analysis. Our approach is particularly useful in the context of product lines, when product variants are derived by composing modules depending on specific customer requirements. We present preliminary results of an evaluation based on a product line from an industrial partner.

Due to increased market demands for highly customized and machine-specific solutions in manufacturing, industrial software systems are often developed as software product lines (SPL) and organized as software ecosystems (SECO) with internal and external developers composing individual solutions based on a common technological platform. In such settings, software development usually occurs in a multistage process: system variants initially derived from a platform are adapted and extended to meet specific requirements. This common approach, however, results in significant challenges for software development and maintenance. In this paper we review key challenges we have been observing when investigating our industrial partner's software ecosystems. We then present a feature-oriented development approach we have been developing to tackle those. Our approach is backed with static analysis methods to deal with system variants and versions created in software maintenance.

Feature models are commonly used in industrial contexts to guide and automate the derivation of product variants. However, in real-world product lines the derivation process goes beyond selecting and composing product features. Specifically, developers often perform clone-and-own reuse, i.e., they copy, modify, and extend existing code to provide the functionality required by customers. Clones are created at different levels of granularity, ranging from individual features to entire systems. Refactoring and reverse engineering approaches have been proposed for dealing with cloned product variants. However, managing clones has not been addressed in the context of feature models. For instance, if clones are created to address customer requirements in specific product variants, the connection to the original feature models is frequently lost. We thus present a modeling approach based on prototypes, i.e., prefabricated objects from which clones are created. Our approach allows to manage prototypes and their clones at the levels of products, components, and features. We use compliance levels to define the required level of consistency between prototypes and clones. We further adapt an existing consistency checking framework for detecting inconsistent clones when the product line evolves. Our approach uses feature-to-code mappings to determine the impact of changes on code elements. We present a case study illustrating prototypes, clones, and compliance levels in selected development scenarios of our industry partner's product line. We also discuss the use of static code analysis techniques to support engineers in determining the impact of changed prototypes on affected clones, an area we plan to address in our future work.

Static code analysis techniques are widely and successfully used for mainstream programming languages. However, domain-specific languages and company-specific variations of languages often lack the same level of support. An example is the domain of industrial automation, where programmable logic controller programs are mainly written in languages conforming to the IEC 61131-3 standard, a non-mainstream family of languages. This experience paper reports about the development of a program analysis framework for the IEC 61131-3 languages. We use OMG's Abstract Syntax Tree Meta-Model (ASTM) as an abstract representation and show our extensions of this model to represent the different IEC 61131-3 languages. Using this representation our approach generates Jimple code, an intermediate representation used by the Soot program analysis framework. We use Soot's standard analysis methods to compute a system dependence graph, which is then used for change impact analysis. We apply our approach to industrial-size product lines of our industry partner to demonstrate its correctness and performance. Finally, we discuss experiences and lessons learned intended for developers of program analysis methods for nonmainstream languages.

Understanding variability is essential to allow the configuration of software systems to diverse requirements. Variability-aware program analysis techniques have been proposed for analyzing the space of program variants. Such techniques are highly beneficial, e.g., to determine the potential impact of changes during maintenance. This paper presents an interprocedural and configuration-aware change impact analysis (CIA) approach for determining possibly impacted products when changing source code of a product family. The approach further supports engineers, who are adapting specific product variants after an initial pre-configuration. The approach can be adapted to work with different variability mechanism, it provides more precise results than existing CIA approaches, and it can be implemented using standard control flow and data flow analysis. Using an industrial product line we report evaluation results on the benefit and performance of the approach.

Software engineering methods for analyzing and managing variable software systems rely on accurate feature-to-code mappings to relate high-level variability abstractions, such as features or decisions, to locations in the code where variability occurs. Due to the continuous and long-term evolution of many systems such mappings need to be extracted and updated automatically. However, current approaches have limitations regarding the analysis of highly-configurable systems that rely on different variability mechanisms. We present a novel approach that exploits the synergies between program analysis and doffing techniques to reveal feature-to-code mappings for highly-configurable systems. We demonstrate the feasibility of our approach with a set of products from a real-world product line in the domain of industrial automation.

In software ecosystems (SECOs) both internal and external developers build software solutions for specific market segments based on common technological platforms. Despite a significant body of research on SECOs there is still a need to empirically investigate the characteristics of SECOs in specific industrial environments to understand and improve development processes. In particular, when defining software processes understanding the roles of the participants in the SECO is crucial. This paper thus reports results of an exploratory case study in the industrial automation domain. We explore two research questions on SECO characteristics and discuss research issues we derived from our analyses. While our study confirms key SECO characteristics reported in the literature we also identify additional properties relevant for development processes in the domain of industrial automation.

Change impact analysis (CIA) techniques have been applied successfully to determine the effects of modifications when evolving software systems. However, many software systems today use multiple programming languages and they are organized as software product lines (SPLs) to ease their customization to different customer and market needs. Due to the limitations of current CIA approaches regarding variability and cross-language support assessing the impact of changes becomes difficult and arduous. This work aims at developing a CIA approach for multi language SPLs. The approach is based on a multiple conditional system dependency graphs. We will evaluate the approach based on the software product lines of an industry partner in the domain of industrial automation.

Application engineers frequently create customer-specific products in two stages: the required software components are first selected to create an initial product which is then evolved by refining the selected features and adapting the code to meet the customers' requirements. For instance, developers frequently set configuration options in the code to adjust the product. However, given that such changes are often necessary in the entire code base it is hard to know which part of the code is still relevant for the chosen configuration options. This means that engineers need to understand and maintain a lot of code that is potentially inactive in a particular product variant. Existing approaches provide only partial solutions: for instance, feature-to-code mappings do not adequately consider complex code dependencies of the implemented features. Static analysis techniques provide better results but usually do not consider variability aspects. We present an approach to automatically identify inactive code in product variants using a configuration-aware code analysis technique. We demonstrate the flexibility of our approach by customizing it to a product line of an industry partner in the domain of industrial automation. We further evaluate the approach to demonstrate its effectiveness, accuracy, and performance.

A call graph of a program represents the information which executable program element calls which other executable program elements. Based on the call graph, points-to sets can be computed, which represent the memory locations a reference variable can possibly point to. Call graph and points-to sets provide important information for static program analysis. This is especially true for PLC programs which heavily use pointer variables. However, due to the complexity of the algorithms, call graph and points-to analysis methods are not widely available in static analysis. In this paper, we present an approach for call graph and points-to analysis of IEC 61131-3 programs. We present the algorithm for computing call graph and points-to sets and its implementation in a tool environment, show several different application scenarios, and present first results from industrial application.

Static code analysis techniques analyze programs by examining the source code without actually executing them. The main benefits lie in improving software quality by detecting potential defects and problematic code constructs in early development stages. Today, static code analysis is widely used and numerous tools are available for established programming languages like C/C++, Java, C# and others. However, in the domain of PLC programming, static code analysis tools are still rare. In this paper we present an approach and tool support for static code analysis of PLC programs. The paper discusses opportunities static code analysis can offer for PLC programming, it reviews techniques for static analysis, and it describes our tool that implements a rule-based analysis approach for IEC 61131-3 programs.