Using Graph Transformations and Graph Abstractions for Software Verification

In this paper we describe our intended approach for the verification of software written in imperative programming languages. We base our approach on model checking of graph transition systems, where each state is a graph and the transitions are specified by graph transformation rules. We believe that graph transformation is a very suitable technique to model the execution semantics of languages with dynamic memory allocation. Furthermore, such representation allows us to investigate the use of graph abstractions, which can mitigate the combinatorial explosion inherent to model checking. In addition to presenting our planned approach, we reason about its feasibility, and, by providing a brief comparison to other existing methods, we highlight the benefits and drawbacks that are expected

Using Graph Transformations and Graph Abstractions for Software Verification

In this paper we describe our intended approach for the verification of software written in imperative programming languages. We base our approach on model checking of graph transition systems, where each state is a graph and the transitions are specified by graph transformation rules. We believe that graph transformation is a very suitable technique to model the execution semantics of languages with dynamic memory allocation. Furthermore, such representation allows us to investigate the use of graph abstractions, which can mitigate the combinatorial explosion inherent to model checking. In addition to presenting our planned approach, we reason about its feasibility, and, by providing a brief comparison to other existing methods, we highlight the benefits and drawbacks that are expected

A Graph-Based Semantics Workbench for Concurrent Asynchronous Programs

A number of novel programming languages and libraries have been proposed that offer simpler-to-use models of concurrency than threads. It is challenging, however, to devise execution models that successfully realise their abstractions without forfeiting performance or introducing unintended behaviours. This is exemplified by SCOOP---a concurrent object-oriented message-passing language---which has seen multiple semantics proposed and implemented over its evolution. We propose a "semantics workbench" with fully and semi-automatic tools for SCOOP, that can be used to analyse and compare programs with respect to different execution models. We demonstrate its use in checking the consistency of semantics by applying it to a set of representative programs, and highlighting a deadlock-related discrepancy between the principal execution models of the language. Our workbench is based on a modular and parameterisable graph transformation semantics implemented in the GROOVE tool. We discuss how graph transformations are leveraged to atomically model intricate language abstractions, and how the visual yet algebraic nature of the model can be used to ascertain soundness.Comment: Accepted for publication in the proceedings of FASE 2016 (to appear

STRUCTURAL VALIDATION OF SOFTWARE PRODUCT LINE VARIANTS: A GRAPH TRANSFORMATIONS BASED APPROACH

ABSTRAC

Using Graph Transformations and Graph Abstractions for Software Verification

In this abstract we present an overview of our intended approach for the verification of software written in imperative programming languages. This approach is based on model checking of graph transition systems (GTS), where each program state is modeled as a graph and the exploration engine is specified by graph transformation rules. We believe that graph transformation [13] is a very suitable technique to model the execution semantics of languages with dynamic memory allocation. Furthermore, such representation provides a clean setting to investigate the use of graph abstractions, which can mitigate the space state explosion problem that is inherent to model checking techniques

Adaptivity engineering : Modeling and quality assurance for self-adaptive software systems

Moderne Softwareentwicklung nutzt Techniken der Selbstadaptation, um Wartung von Softwaresystemen zu automatisieren und diese somit flexibler und robuster zu gestalten. Allerdings führt die Einführung solcher Techniken zu größeren und komplizierten Softwareentwürfen. Die Konsequenz sind Fehler im Entwurf. In der Literatur werden konstruktive Methoden wie MDE oder Patterns und analytische Methoden wie Testen oder Model Checking vorgeschlagen, um das Komplexitätsproblem zu verringern. Allerdings werden die Techniken der Selbstadaption von solchen Methoden bisher noch wenig unterstützt, d.h. dass es wenige integrierte Ansätze für die explizite Modellierung und Qualitätssicherung von Selbstadaptation gibt. In dieser Arbeit schlagen wir einen integrierten Modellierungs- und Qualitätssicherungsansatz für den Entwurf selbstadaptiver Softwaresysteme vor. Es werden sowohl konstruktive Methoden (z.B. Sprachen) als auch analytische Methoden (z.B. Model Checking) für die Unterstützung der Entwicklung solcher Systeme vorgeschlagen. Beide Typen von Methoden sind in Standardtechniken und Werkzeuge integriert. Im Ergebnis wird der Entwickler in der Modellierung selbstadaptiver Softwaresysteme durch den Einsatz von adaptionsspezifischen Sprachen unterstützt. Durch die dazu passenden Qualitätssicherungsverfahren erhält der Entwickler unmittelbare Rückmeldung über die Qualität seiner Modelle. Somit wird die Entwicklung selbstadaptiver Systeme bereits in frühen Phasen des Entwicklungsprozesses unterstützt, Entwurfsfehler werden vermieden und somit bessere Software gebaut.Modern software engineering introduces self-adaptivity features to perform automatic maintenance and make software systems more flexible and resilient. Unfortunately, introducing the additional self-adaptivity features makes software design bloated and complicated. As a consequence, software design models are often prone to errors. The literature proposes constructive approaches such as MDE, patterns, etc. as well as analytical approaches such as testing or model checking to solve the problem of complexity in general. However, there is no sufficient adaptivity-specific support throughout the engineering process, i.e. no approaches that support the creation of self-adaptivity specification models and their quality assurance. In this thesis, we will propose an integrated modeling and quality assurance environment for designing self-adaptive software systems. Therefore, we will propose constructive methods (e.g., languages) and analytical methods (e.g., model-checking) to support the engineering of these systems. Both types of methods are integrated into standard software engineering techniques and tools. As a result, the designer is supported in modeling self-adaptive software systems using concern-specific languages and receives immediate feedback about the quality of his models. This way, software engineering for self-adaptive systems is getting supported starting at the early design phase leading to less errors produced, and thus, to better software, overall.Tag der Verteidigung: 26.09.2013Paderborn, Univ., Diss., 201