931 research outputs found
Optimizing Abstract Abstract Machines
The technique of abstracting abstract machines (AAM) provides a systematic
approach for deriving computable approximations of evaluators that are easily
proved sound. This article contributes a complementary step-by-step process for
subsequently going from a naive analyzer derived under the AAM approach, to an
efficient and correct implementation. The end result of the process is a two to
three order-of-magnitude improvement over the systematically derived analyzer,
making it competitive with hand-optimized implementations that compute
fundamentally less precise results.Comment: Proceedings of the International Conference on Functional Programming
2013 (ICFP 2013). Boston, Massachusetts. September, 201
Recommended from our members
Transformational maintenance by reuse of design histories
This thesis provides theory and procedures for modifying software artifacts implemented by a formal transformation process. Installing modifications requires knowing not only what transformations were applied (a derivation history) to construct the artifact, but also why the application sequence ensures that the artifact meets its specification. The derivation history and the justification are collectively called a design history. A Design Maintenance System (DMS), when provided with a formal change called a maintenance delta, revises a design history to guide construction of a new artifact. A DMS can be used to integrate a stream of deltas into a history, providing implementations as a side effect, leading to an incremental-evolution model for software construction.We provide a broadly applicable formal model of transformation systems in which specifications are performance predicates, subsuming the functional specifications which are traditional for transformation systems. Such performance predicates provide vocabulary used in the design history to describe the effect of applying sets of transformations.A nonprocedural, performance-goal-oriented Transformation Control Language (TCL) is defined to control navigation of the design space for a transformation system. Recording the execution of a TCL metaprogram directly provides a design history.A complete classification of, and representation for, the set of possible maintenance deltas is given in terms of the inputs defined by the transformation system model. Such deltas include not only specification changes, but also changes to implementation support technologies. Delta integration procedures for revising derivation histories given functional or support technology deltas are provided, based on rearranging the order of transformations in the design space. Building on these operations, integration procedures that revise the design history for each type of delta are described. An agenda-oriented TCL execution process dovetails smoothly with the integration procedures.Our DMS is compared to a number of other maintenance systems. By using an explicit delta and verified commutativity, our DMS often reuses transformations correctly when others fail
Low-Code Programming Models
Traditionally, computer programming has been the prerogative of professional
developers using textual programming languages such as C, Java, or Python.
Low-code programming promises an alternative: letting citizen developers create
programs using visual abstractions, demonstrations, or natural language. While
low-code programming is currently getting a lot of attention in industry, the
relevant research literature is scattered, and in fact, rarely uses the term
"low-code". This article brings together low-code literature from various
research fields, explaining how techniques work while providing a unified point
of view. Low-code has the potential to empower more people to automate tasks by
creating computer programs, making them more productive and less dependent on
scarce professional software developers
Recommended from our members
Techniques for Efficient and Effective Mobile Testing
The booming mobile app market attracts a large number of developers. As a result, the competition is extremely tough. This fierce competition leads to high standards required for mobile apps, which mandates efficient and effective testing. Efficient testing requires little effort to use, while effective testing checks that the app under test behaves as expected. Manual testing is highly effective, but it is costly. Automatic testing should come to the rescue, but current automatic methods are either ineffective or inefficient. Methods using implicit specifications – for instance, “an app should not crash” for catching fail-stop errors – are ineffective because they cannot find semantic problems. Methods using explicit specifications such as test scripts are inefficient because they require huge developer effort to create and maintain specifications. In this thesis, we present our two approaches for solving these challenges. We first built the AppDoctor system which efficiently tests mobile apps. It quickly explores an app then slowly but accurately verifies the potential problems to identify bugs without introducing false positives. It uses dependencies discovered between actions to simplify its reports. Our second approach, implemented in the AppFlow system, leverages the ample opportunity of reusing test cases between apps to gain efficiency without losing effectiveness. It allows common UI elements to be used in test scripts then recognizes these UI elements in real apps using a machine learning approach. The system also allows tests to be specified in reusable pieces, and provides a system to synthesize complete test cases from these reusable pieces. It enables robust tests to be created and reused across apps in the same category. The combination of these two approaches enables a developer to quickly test an app on a great number of combinations of actions for fail-stop problems, and effortlessly and efficiently test the app on most common scenarios for semantic problems. This combination covers most of her test requirements and greatly reduces her burden in testing the app
Automated Coevolution of Source Code and Software Architecture Models
Zur Entwicklung komplexer Softwaresysteme, werden neben dem Quelltext zusätzliche Artefakte, wie beispielsweise Architekturmodelle, verwendet. Wenn die verwendeten Architekturmodelle während der Entwicklung und Evolution eines Softwaresystems konsistent mit dem Quelltext sind, können Softwarearchitekten und Softwareentwickler bei der Entwicklung der Systeme besser unterstützt werden. Architekturmodelle, die auf dem aktuellem Stand sind, vereinfachen Entwicklungs- und Evolutionssaufgaben, da einfacher beantwortet werden kann wie und wo neue Funktionen implementiert werden sollen. Außerdem ist es möglich, modellbasierte Analysen mit Hilfe der Softwarearchitekturmodelle vorzunehmen. Beispielsweise können mit dem Palladio Komponentenmodell (PCM) Performanzvorhersagen durchgeführt werden, wenn ein Architekturmodell des Softwaresystems vorhanden ist und dieses Verhaltensspezifikationen beinhaltet.
Wenn Architekturmodelle bei der Softwareentwicklung und Softwareevolution verwendet werden, können die beiden bekannten Probleme Architekturdrift und Architekturverletzung auftreten. Diese Probleme treten für gewöhnlich auf, wenn bei voranschreitender Entwicklung des Quelltextes die Architektur nicht konsistent zu diesem gehalten wird. Dies führt zu veralteten und schlussendlich nutzlosen Architekturmodellen. Viele existierende Ansätze, zur Vermeidung dieser Probleme, zielen darauf ab, Quelltext und UML-Klassendiagramme konsistent zu halten, oder sie zielen darauf ab, Architekturinformationen in den Quelltext einzubetten. In letzterem Fall wird die Notwendigkeit, die Architektur konsistent mit dem Quelltext zu halten, umgangen, da die Architektur integraler Bestandteil des Quelltextes ist. In der vorliegenden Dissertation beschreiben wir einen neuen Ansatz, um komponentenbasierte Architekturmodelle, welche sich auf einer hohen Abstraktionsebene befinden, konsistent mit dem Quelltext zu halten. Wir beschreiben, wie Instanzen des PCMs konsistent mit Java-Quelltext gehalten werden können. Um Konsistenz zu erreichen, werden Architekturelemente erzeugt, gelöscht oder geändert, sobald ihre entsprechende Quelltextelemente geändert wurden, und umgekehrt. Für die Umsetzung der Konsistenzerhaltung stellen wir einen änderungsgetriebenen Ansatz vor. Dieser verwendet benutzerdefinierte, änderungsgetriebene Abbildungsregeln, um die Konsistenz zwischen den beteiligten Modellen sicherzustellen.
In dieser Dissertation stellen wir vier konkrete Mengen von Abbildungsregeln zwischen Architekturmodellen und Quelltext vor. Diese haben wir in einer prototypischen Implementierung des Ansatzes umgesetzt. Wir stellen außerdem einen Mechanismus vor, der mit den Benutzern des Konsistenzerhaltungsansatzes interagiert, wenn die Konsistenz nicht automatisch erhalten werden kann, sondern die Benutzer zuerst ihre Intention, die sie mit einer bestimmten Änderung verfolgen, dem Ansatz mitteilen müssen. In diesem Fall müssen die Benutzer das genaue Vorgehen für die Konsistenzerhaltung spezifizieren. Da der vorgestellte Ansatz änderungsgetrieben funktioniert, ist es notwendig, dass wir alle Änderungen in den beteiligten Architektur- und Quelltexteditoren aufzeichnen können. Um es Benutzern zu erlauben, vorhandene Editoren, mit denen sie sich auskennen, wiederverwenden zu können, haben wir Beobachter für diese Editoren implementiert. Diese Beobachter zeichnen alle Änderungen an einem Modell auf und informieren unseren Ansatz über jede durchgeführte Änderung. Der in dieser Dissertation vorgestellte Ansatz erlaubt es auch, verhaltensbeschreibende Architekturmodelle konsistent mit dem Quelltext zu halten. Um dies zu erreichen, haben wir einen Ansatz implementiert, der es ermöglicht, Service Effect Specifications des PCMs inkrementell aus Methoden zu erstellen, nachdem diese geändert wurden. Die Service Effect Specifications werden innerhalb des PCMs genutzt, um das Verhalten einer Komponente zu spezifizieren. Um bereits bestehende Architekturmodelle und bestehenden Quelltext innerhalb unseres Ansatzes verwenden zu können, stellen wir je eine Integrationsstrategie für die Architektur und den Quelltext vor. Um bestehende Architekturmodelle zu integrieren, simulieren wir deren Erstellung. Während dieses Erstellvorgangs zeichnen wir die Änderungen auf, die nötig sind, um das Architekturmodell zu erstellen. Diese Änderungen werden als Eingabe für den Konsistenzerhaltungsprozess verwendet, um daraus den entsprechenden Quelltext zu erzeugen. Um vorhandenen Quelltext einzubinden, stellen wir einen Ansatz vor, der auf Architekturrekonstruktionsverfahren basiert, d.h., zuerst wird die Architektur eines bestehenden Softwaresystems rekonstruiert. Die erstellte Architektur wird anschließend zusammen mit dem bestehenden Quelltext in unseren Coevolutionsansatz integriert. Oftmals ist bestehender Quelltext jedoch nicht so aufgebaut, wie es die Abbildungsregeln vorschreiben. Innerhalb der Integrationsstrategie für Quelltext stellen wir deshalb einen Ansatz vor, der in der Lage ist, solche Quelltexte dennoch zu integrieren. Dieser Ansatz ermöglicht es, nicht nur diese Art von Quelltext zu integrieren, sondern diesen auch mit speziell definierten Abbildungsregeln automatisch konsistent zu halten.
Wir haben unseren Ansatz in verschiedenen Fallstudien evaluiert. Dabei haben wir zunächst gezeigt, dass es möglich ist vorhandene Architekturmodelle zu integrieren, indem ihr Aufbau simuliert wird. In der durchgeführten Fallstudie ist es mit unserem Ansatz und den vorgestellten Abbildungsregeln möglich, zwischen 98% und 100% der unterstützten Elemente zu integrieren. Als nächstes haben wir gezeigt, dass unser Ansatz in der Lage ist, existierenden Quelltext zu integrieren und Änderungen am integrierten Quelltext konsistent mit der Architektur zu halten. Für diese Fallstudie haben wir zunächst den Quelltext von vier quelloffenen Projekten in den Ansatz integriert. Als nächstes haben wir gezeigt, dass es möglich ist, Änderungen am Quelltext konsistent mit der Architektur zu halten. Dazu haben wir eine alte Version des Quelltextes integriert und Änderungen die zwischen einer alten und neueren Version durchgeführt wurden, aus einem Versionskontrollsystem extrahiert und erneut auf den Quelltext angewendet. Im Rahmen dieser Evaluation haben wir auch gezeigt, dass es möglich ist Änderungen, die innerhalb von Methoden durchgeführt werden, mit einem Verhaltensmodell konsistent zu halten. Wir haben außerdem eine Evaluation der Leistungsfähigkeit unseres Ansatzes durchgeführt und gezeigt, dass unser Ansatz in den meisten Fällen in der Lage ist, die Architektur in einer Zeit zwischen einer und fünf Sekunden konsistent zu halten, nachdem eine Änderung am Quelltext durchgeführt wurde. Als letztes haben wir gezeigt, dass es möglich ist, coevolvierte Modelle für die Performanzvorhersage zu verwenden. Dazu haben wir zuerst die Modelle in einem Parametrisierungsschritt mit den nötigen Ressourcenverbräuchen angereichert. Als nächstes konnten wir die Performanzvorhersage durchführen. In unserer Fallstudie zeigte sich, dass der Vorhersagefehler für die Antwortzeit eines Systems bei ca. 10% liegt, und damit die coevolvierten Modelle für die Abschätzung der Performanz eines realen Systems verwendet werden können
Systematic Testing for Detecting Concurrency Errors in Erlang Programs
We present the techniques used in Concuerror, a systematic testing tool able to find and reproduce a wide class of concurrency errors in Erlang programs. We describe how we take advantage of the characteristics of Erlang's actor model of concurrency to selectively instrument the program under test and how we subsequently employ a stateless search strategy to systematically explore the state space of process interleaving sequences triggered by unit tests. To ameliorate the problem of combinatorial explosion, we propose a novel technique for avoiding process blocks and describe how we can effectively combine it with preemption bounding, a heuristic algorithm for reducing the number of explored interleaving sequences. We also briefly discuss issues related to soundness, completeness and effectiveness of techniques used by Concuerror
Doctor of Philosophy
dissertationAlmost all high performance computing applications are written in MPI, which will continue to be the case for at least the next several years. Given the huge and growing importance of MPI, and the size and sophistication of MPI codes, scalable and incisive MPI debugging tools are essential. Existing MPI debugging tools have, despite their strengths, many glaring de ficiencies, especially when it comes to debugging under the presence of nondeterminism related bugs, which are bugs that do not always show up during testing. These bugs usually become manifest when the systems are ported to di fferent platforms for production runs. This dissertation focuses on the problem of developing scalable dynamic verifi cation tools for MPI programs that can provide a coverage guarantee over the space of MPI nondeterminism. That is, the tools should be able to detect diff erent outcomes of nondeterministic events in an MPI program and enforce all those di fferent outcomes through repeated executions of the program with the same test harness. We propose to achieve the coverage guarantee by introducing efficient distributed causality tracking protocols that are based on the matches-before order. The matches-before order is introduced to address the shortcomings of the Lamport happens-before order [40], which is not sufficient to capture causality for MPI program executions due to the complexity of the MPI semantics. The two protocols we propose are the Lazy Lamport Clocks Protocol (LLCP) and the Lazy Vector Clocks Protocol (LVCP). LLCP provides good scalability with a small possibility of missing potential outcomes of nondeterministic events while LVCP provides full coverage guarantee with a scalability tradeoff . In practice, we show through our experiments that LLCP provides the same coverage as LVCP. This thesis makes the following contributions: •The MPI matches-before order that captures the causality between MPI events in an MPI execution. • Two distributed causality tracking protocols for MPI programs that rely on the matches-before order. • A Distributed Analyzer for MPI programs (DAMPI), which implements the two aforementioned protocols to provide scalable and modular dynamic verifi cation for MPI programs. • Scalability enhancement through algorithmic improvements for ISP, a dynamic verifi er for MPI programs
Automated Coevolution of Source Code and Software Architecture Models
This work introduces a novel approach to keep high-level component-based architecture models consistent with source code during software development and software evolution. The approach helps to avoid architecture drift and architecture erosion, which are two well-known problems that can arise during development and maintenance of a software system. In particular, the presented approach can be used to keep instances of the Palladio Component Model (PCM) consistent with Java source code
- …