Logo des Repositoriums

Auflistung nach Autor:in "Lochau, Malte"

1 - 10 von 10
  • Zeitschriftenartikel
    Evolving Adaptable Systems: Potential and Challenges
    (Softwaretechnik-Trends Band 30, Heft 2, 2010) Schmid, Klaus; Eichelberger, Holger; Goltz, Ursula; Lochau, Malte
  • Konferenzbeitrag
    On Automated Anomaly Detection for Potentially Unbounded Cardinality-based Feature Models
    (Software Engineering 2017, 2017) Weckesser, Markus; Lochau, Malte; Schnabel, Thomas; Richerzhagen, Björn; Schürr, Andy
    In this work, we report about our research results on analysis of cardinality-based fea- ture models with potentially unbounded feature multiplicities, initially published in [We16]. Feature models are frequently used for specifying variability of user-configurable software systems, e.g., software product lines. Numerous approaches have been developed for automating feature model validation concerning constraint consistency and absence of anomalies. As a crucial extension to feature models, cardinality annotations allow for multiple, and even potentially unbounded occur- rences of feature instances within configurations. This is of particular relevance for user-adjustable application resources as prevalent, e.g., in cloud-based systems where not only the type, but also the amount of available resources is explicitly configurable. However, a precise semantic characteriza- tion and tool support for automated and scalable validation of cardinality-based feature models is still an open issue. We present a comprehensive formalization of cardinality-based feature models with potentially unbounded feature multiplicities. We apply a combination of ILP and SMT solvers to automate consistency checking and anomaly detection, including novel anomalies, e.g., interval gaps. Furthermore, we show evaluation results gained from our tool implementation showing appli- cability and scalability of our approach to larger-scale models.
  • Konferenzbeitrag
    On Automated N-way Program Merging for Facilitating Family-based Analyses of Variant-rich Software
    (Software Engineering 2020, 2020) Reuling, Dennis; Kelter, Udo; Bürdek, Johannes; Lochau, Malte
    In this work, we report about research results initially published in ACM Transactions on Software Engineering and Methodology (TOSEM), volume 28 Issue 3, 2019. Nowadays software comes in many different, yet similar variants, often derived from common code via clone-and-own. Family-based-analysis strategies show promising potentials for improving efficiency of quality assurance for variant-rich programs, as compared to variant-by-variant approaches. Unfortunately, these strategies require one superimposed program representation containing all program variants in a syntactically well-formed, semantically sound, and variant-preserving manner, which is hard to obtain manually in practice. In this talk, we present our methodology SiMPOSE for generating superimpositions of program variants to facilitate family-based analyses of variant-rich software. We utilize a novel N-way model-merging methodology for control-flow automaton (CFA) representations of C programs, an abstraction used by many recent software-analysis tools. To cope with the complexity of N-way merging, we use similarity-propagation to reduce the number of N-way matches and enable incremental merging of arbitrary subsets of variants. We apply our SiMPOSE tool to realistic C programs and investigate applicability and efficiency/effectiveness trade-offs of family-based program analyses. Our results reveal efficiency improvements by a factor of up to 2.6 for unit-test generation and 2.4 for model-checking under stable effectiveness, as compared to variant-by-variant.
  • Konferenzbeitrag
    On Continuous Detection of Design Flaws in Evolving Object-Oriented Programs using Incremental Multi-Pattern Matching
    (Software Engineering und Software Management 2018, 2018) Peldszus, Sven; Kulcsár, Géza; Lochau, Malte; Schulze, Sandro
    This work has been initially presented at the International Conference on Automated Software Engineering (ASE) 2016. Design flaws in object-oriented programs may seriously corrupt code quality thus increasing the risk for introducing subtle errors during software maintenance and evolution. Most recent approaches identify design flaws in an ad-hoc manner, either focusing on software metrics, locally restricted code smells, or on coarse-grained architectural anti-patterns. In this work, we utilize an abstract program model capturing high-level object-oriented code entities, further augmented with qualitative and quantitative design-related information such as coupling/cohesion. Based on this model, we propose a comprehensive methodology for specifying object-oriented design flaws by means of compound rules integrating code metrics, code smells and anti-patterns in a modular way. This approach allows for efficient, automated design-flaw detection through incremental multi-pattern matching, by facilitating systematic information reuse among multiple detection rules as well as between subsequent detection runs on continuously evolving programs. Our tool implementation comprises well-known anti-patterns for Java programs. The results of our experimental evaluation show high detection precision, scalability to real-size programs, as well as a remarkable gain in efficiency due to information reuse.
  • Konferenzbeitrag
    On Controlling the Attack Surface of Object-Oriented Refactorings
    (Software Engineering 2020, 2020) Ruland, Sebastian; Kulcsár, Géza; Leblebici, Erhan; Peldszus, Sven; Lochau, Malte
    The results of this work have originally been published in. Refactorings constitute an effective means to improve quality and maintainability of evolving object-oriented programs. Search-based techniques have shown promising results in finding near-optimal sequences of behavior-preserving program transformations that (1) maximize code-quality metrics and (2) minimize the number of code changes. However, the impact of refactorings on non-functional properties like security has received little attention so far. To this end, we propose, as a further objective, to minimize the attack surface of object-oriented programs (i.e., to maximize strictness of declared accessibility of class members). Minimizing the attack surface naturally competes with applicability of established refactorings like MoveMethod, frequently used for improving code quality in terms of coupling/cohesion measures. Our tool implementation is based on an EMF meta-model for Java-like programs and utilizes MOMoT, a search-based model-transformation and optimization framework. Our experimental results gained from applying different accessibility-control strategies to a collection of real-world Java programs show the impact of attack surface minimization on design-improving refactorings. We further compare the results to those of existing refactoring tools.
  • Konferenzbeitrag
    On facilitating reuse in multi-goal test-suite generation for software product lines
    (Software Engineering 2016, 2016) Lochau, Malte; Bürdek, Johannes; Bauregger, Stefan; Holzer, Andreas; Rhein, Alexander Von; Apel, Sven; Beyer, Dirk
    Software testing is still the most established and scalable quality-assurance technique in practice today. However, generating effective test suites remains computationally expensive, consisting of repetitive reachability analyses for multiple test goals according to a coverage criterion. This situation is even worse when it comes to testing of entire software product lines (SPL). An SPL consists of a family of similar program variants, thus testing an SPL requires a sufficient coverage of all derivable program variants. Instead of considering every product variant one-by-one, family-based approaches are variability-aware analysis techniques in that they systematically explore similarities among the different variants. Based on this principle, we propose a novel approach for automated product-line test-suite generation incorporating extensive reuse of reachability information among test cases derived for different test goals and/or program variants. The developed tool implementation is built on top of CPA/TIGER which is based on CPACHECKER. We further present experimental evaluation results, revealing a considerable increase in efficiency compared to existing test-case generation techniques. Software product line (SPL) engineering aims at developing families of similar, yet welldistinguished software products built upon a common core platform. The commonality and variability among the family members (product variants) of an SPL are specified as features. In this regard, a feature corresponds to user-configurable product characteristics within the problem domain, as well as implementation artifacts being automatically composeable into implementation variants. The resulting extensive reuse of common feature artifacts among product variants facilitates development efficiency as well as product quality compared to one-by-one variant development. However, for SPLs to become fully accepted in practice, software-quality assurance techniques have to become variabilityaware, too, in order to benefit from SPL reuse principles. In practice, systematic software testing constitutes the most elaborated and wide-spread assurance technique, being directly applicable to software systems at any level of abstraction. In addition, testing enables a controllable trade-off between effectiveness and efficiency. In particular, white-box test generation consists of (automatically) deriving input vectors for a program under test with respect to predefined test goals. The derivation of sufficiently large test suites is, therefore, guided by test selection metrics, e.g., structural coverage criteria like basic block coverage and condition coverage [Be13]. These criteria impose multiple test goals, thus requiring sets of test input vectors for their complete coverage [Be13]. In case of mission-/safety- 1 This is a summary of a full article on this topic that appeared in Proc. FASE 2015 [Bü15]. 2 This work was partially supported by the DFG (German Research Foundation) under the Priority Programme SPP1593: Design For Future - Managed Software Evolution. 3 TU Darmstadt, Germany 4 TU Wien, Austria 5 University of Passau, Germany critical systems, it is imperative, or even enforced by industrial standards to guarantee a particular degree of code coverage for every delivered product. Technically, automated test input generation requires expensive reachability analyses of the program state space. Symbolic model checking is promising approach for fully automated white-box test generation using counterexamples as test inputs [Be04]. Nevertheless, concerning large sets of complex test goals, scalability issues still obstruct efficient test case generation when being performed for every test goal in separate. This problem becomes even worse while generating test inputs for covering entire product line implementations. To avoid a variantby-variant (re-)generation of test cases potentially leading to many redundant generation runs, an SPL test-suite generation approach must enhance existing techniques. In [Bü15], we presented a novel technique for efficient white-box test-suite generation for multi-goal test coverage of product-line implementations. The approach systematically exploits reuse potentials among reachability analysis results by means of similarity among test cases (1) derived for different test goals [Be13], and/or (2) derived for different product variants [Ci11]. The combination of both techniques allows for an incremental, coveragedriven exploration of the state space of entire product lines under test implemented in C enriched with feature parameters. We implemented an SPL test-suite generator for arbitrary coverage criteria on top of the symbolic software model checker CPACHECKER [Be13]. We evaluated our technique considering sample SPL implementations of varying size. Our experiments revealed the applicability of the tool to real-world SPL implementations, as well as a remarkable gain in efficiency obtained from the reuse of reachability analysis results. compared to test suite generation approaches without systematic reuse. As a future work, we plan to improve reuse capabilities by applying multi-property model-checking techniques of CPACHECKER which allows for reachability analyses of multiple test goals in a single run. Literaturverzeichnis [Be04] Beyer, Dirk; Chlipala, Adam J.; Henzinger, Thomas A.; Jhala, Ranjit; Majumdar, Rupak: Generating Tests from Counterexamples. In: ICSE. pp. 326-335, 2004. [Be13] Beyer, Dirk; Holzer, Andreas; Tautschnig, Michael; Veith, Helmut: Information Reuse for Multi-goal Reachability Analyses. In: ESOP, pp. 472-491. Springer, 2013. [Bü15] Bürdek, Johannes; Lochau, Malte; Bauregger, Stefan; Holzer, Andreas; von Rhein, Alexander; Apel, Sven; Beyer, Dirk: Facilitating Reuse in Multi-Goal Test-Suite Generation for Software Product Lines. In: FASE. Springer, 2015. [Ci11] Cichos, Harald; Oster, Sebastian; Lochau, Malte; Schürr, Andy: Model-based Coverage- Driven Test Suite Generation for Software Product Lines. In: MoDELS. Springer, pp. 425-439, 2011.
  • Konferenzbeitrag
    On modularizing triple graph grammars with rule refinement
    (Software-engineering and management 2015, 2015) Anjorin, Anthony; Saller, Karsten; Lochau, Malte; Schürr, Andy
    A Triple Graph Grammar (TGG) is a set of declarative rules describing how consistent triples of graph structures in a source, target, and correspondence domain are to be generated. This generative and high-level specification of consistency can be automatically operationalized and used to derive model generators for test case generation, forward and backward translators, and incremental model synchronizers. As with any domain specific language, a means to modularize TGG specifications is an important requirement, especially for practical applications. We formalized an extended concept of rule refinement for TGGs in previous work and now report on our experience from using rule refinements intensively in a recent industrial project.
  • Konferenzbeitrag
    Precomputing Reconfiguration Strategies based on Stochastic Timed Game Automata
    (Software Engineering 2023, 2023) Göttmann, Hendrik; Caesar, Birte; Beers, Lasse; Lochau, Malte; Schürr, Andy; Fay, Alexander
    We summarize our paper Precomputing Reconfiguration Strategies based on Stochastic Timed Game Automata which has been published in the proceedings of the 25th International Conference on Model Driven Engineering Languages and Systems (MODELS 2022).
  • Konferenzbeitrag
    Reasoning about Product-Line Evolution using Complex Feature Model Differences
    (Software Engineering 2017, 2017) Bürdek, Johannes; Kehrer, Timo; Lochau, Malte; Reuling, Dennis; Kelter, Udo; Schürr, Andy
    In this work, we report about research results on the Reasoning about Product-Line Evo- lution using Complex Feature Model Differences, published in [Bu ̈15]. A (software) product-line constitutes a long-term investment and, therefore, has to undergo continuous evolution to meet con- stantly changing requirements. Initially, product-line evolution leads to changes of the variability model, typically a feature model, due to its central role in the product-line paradigm. Thus, product- line engineers are often faced with the problems that (1) feature models are changed ad-hoc without proper documentation, and (2) the semantic impact of changes is unclear. We propose a comprehen- sive approach to tackle both challenges. For (1), our approach compares the old and new version of the diagram representation of a feature model and specifies the changes using edit operations on feature diagrams. For (2), we propose a novel approach for reasoning about the semantic impact of diagram changes. We present a set of edit operations on feature diagrams, where complex operations are primarily derived from evolution scenarios observed in a real-world case study. We demonstrate the applicability of our approach with respect to the case study, and evaluate its scalability concern- ing experimental data sets.
  • Konferenzbeitrag
    Reduktion von Testsuiten für Software-Produktlinien
    (Software Engineering 2012, 2012) Cichos, Harald; Lochau, Malte; Oster, Sebastian; Schürr, Andy
    Eine Software-Produktlinie (SPL) bezeichnet eine Menge ähnlicher Produktvarianten, die bei entsprechend großer Anzahl einen erheblichen Testaufwand verursachen können. Viele modellbasierte SPL-Testansätze versuchen diesen Testaufwand zu verringern, indem Testfälle und Testmodelle aus vorangegangenen Testprozessen ähnlicher Produkte, wenn möglich, wiederverwendet werden. Eine weitere Möglichkeit den Testaufwand zu senken besteht darin, die Anzahl der auf den einzelnen Produkten auszuführenden Testfälle (Testsuite) mittels Testsuite-Reduktionstechniken zu reduzieren. Bisher existierende Verfahren wurden jedoch nicht für den Einsatz im SPL-Kontext entworfen und können daher nicht für jedes Produkt den Erhalt der erreichten Testabdeckung bzgl. eines Überdeckungskriteriums garantieren, wenn Testfälle produktübergreifend wiederverwendet werden. In dieser Arbeit wird diese aus der allgemeinen Testsuite-Reduktion bekannte Anforderung erstmals in erweiterter Form auf den SPL-Kontext übertragen. Darauf aufbauend werden zwei für SPLs ausgelegte Testsuite-Reduktionsansätze vorgestellt, die trotz Reduktion die erreichte Testabdeckung auf jedem Produkt beibehalten. Die Implementierung dieser Ansätze wird auf ein Anwendungsbeispiel angewendet und die Ergebnisse diskutiert.