1,102 research outputs found
User support for software development technologies
The adoption of software development technologies is very closely related to the topic
of user support. This is especially true in early phases, when the users are not familiar
with the modification or the build processes of the software that has to be developed nor
with the technology used for software development. This work introduces an approach
to improve the usability of software development technologies represented by the Combinatory
Logic Synthesizer (CL)S Framework. (CL)S is based on a type inhabitation
algorithm for the combinatory logic with intersection types and aims to automatically
create software components from a domain-specified repository. The framework yields
a complete enumeration of all inhabitants. The inhabitation results are computed in
the form of tree grammars. Unfortunately, the underlying type system allows limited
application of domain-specific knowledge. To compensate for this limit, this work provides
a framework for debugging intersection type specifications and filtering inhabitation
results using domain-specific constraints as main aspects. The aim of the debugger is
to make potentially incomplete or erroneous input specifications and decisions of the
inhabitation algorithm understandable for those who are not experts in the field of type
theory. The combination of tree grammars and graph theory forms the foundation of a
clear representation of the computed results that informs users about the search process
of the algorithm. The graphical representations are based on hypergraphs that illustrate
the inhabitation in a step-wise fashion. Within the scope of this work, three filtering algorithms
were implemented and investigated. The filtering algorithm integrated into the
framework for user support and used for the restriction of inhabitation results is practically
feasible and represents a clear improvement compared to existing approaches. It is
based on modifying the tree grammars resulting from the (CL)S Framework. Additionally,
the usability of the (CL)S Framework is supported by eight perspectives included in a
web-based integrated development environment (IDE) that provides detailed graphical
and textual information about the synthesis
Parameterized Construction of Program Representations for Sparse Dataflow Analyses
Data-flow analyses usually associate information with control flow regions.
Informally, if these regions are too small, like a point between two
consecutive statements, we call the analysis dense. On the other hand, if these
regions include many such points, then we call it sparse. This paper presents a
systematic method to build program representations that support sparse
analyses. To pave the way to this framework we clarify the bibliography about
well-known intermediate program representations. We show that our approach, up
to parameter choice, subsumes many of these representations, such as the SSA,
SSI and e-SSA forms. In particular, our algorithms are faster, simpler and more
frugal than the previous techniques used to construct SSI - Static Single
Information - form programs. We produce intermediate representations isomorphic
to Choi et al.'s Sparse Evaluation Graphs (SEG) for the family of data-flow
problems that can be partitioned per variables. However, contrary to SEGs, we
can handle - sparsely - problems that are not in this family
Formalizing Termination Proofs under Polynomial Quasi-interpretations
Usual termination proofs for a functional program require to check all the
possible reduction paths. Due to an exponential gap between the height and size
of such the reduction tree, no naive formalization of termination proofs yields
a connection to the polynomial complexity of the given program. We solve this
problem employing the notion of minimal function graph, a set of pairs of a
term and its normal form, which is defined as the least fixed point of a
monotone operator. We show that termination proofs for programs reducing under
lexicographic path orders (LPOs for short) and polynomially quasi-interpretable
can be optimally performed in a weak fragment of Peano arithmetic. This yields
an alternative proof of the fact that every function computed by an
LPO-terminating, polynomially quasi-interpretable program is computable in
polynomial space. The formalization is indeed optimal since every
polynomial-space computable function can be computed by such a program. The
crucial observation is that inductive definitions of minimal function graphs
under LPO-terminating programs can be approximated with transfinite induction
along LPOs.Comment: In Proceedings FICS 2015, arXiv:1509.0282
A Programming System for End-user Functional Programming
This research involves the construction of a programming system, HASKEU,
to support end-user programming in a purely functional programming language.
An end-user programmer is someone who may program a computer
to get their job done, but has no interest in becoming a computer programmer.
A purely functional programming language is one that does not require
the expression of statement sequencing or variable updating. The end-user is
offered two views of their functional program. The primary view is a visual
one, in which the program is presented as a collection of boxes (representing
processes) and lines (representing data
flow). The secondary view is a textual
one, in which the program is presented as a collection of written function definitions. It is expected that the end-user programmer will begin with the visual
view, perhaps later moving on to the textual view. The task of the programming
system is to ensure that the visual and textual views are kept consistent
as the program is constructed. The foundation of the programming system
is a implementation of the Model-View-Controller (MVC) design pattern as a
reactive program using the elegant Functional Reactive Programming (FRP)
framework. Human-Computer Interaction (HCI) principles and methods are
considered in all design decisions. A usabilty study was made to find out the
effectiveness of the new system
Synthesizing stream control
For the management of reactive systems, controllers must coordinate time, data streams, and data transformations, all joint by the high level perspective of their control flow. This control flow is required to drive the system correctly and continuously, which turns the development into a challenge. The process is error-prone, time consuming, unintuitive, and costly. An attractive alternative is to synthesize the system instead, where the developer only needs to specify the desired behavior. The synthesis engine then automatically takes care of all the technical details. However, while current algorithms for the synthesis of reactive systems are well-suited to handle control, they fail on complex data transformations due to the complexity of the comparably large data space. Thus, to overcome the challenge of explicitly handling the data we must separate data and control.
We introduce Temporal Stream Logic (TSL), a logic which exclusively argues about the control of the controller, while treating data and functional transformations as interchangeable black-boxes. In TSL it is possible to specify control flow properties independently of the complexity of the handled data. Furthermore, with TSL at hand a synthesis engine can check for realizability, even without a concrete implementation of the data transformations. We present a modular development framework that first uses synthesis to identify the high level control flow of a program. If successful, the created control flow then is extended with concrete data transformations in order to be compiled into a final executable.
Our results also show that the current synthesis approaches cannot replace existing manual development work flows immediately. During the development of a reactive system, the developer still may use incomplete or faulty specifications at first, that need the be refined after a subsequent inspection. In the worst case, constraints are contradictory or miss important assumptions, which leads to unrealizable specifications. In both scenarios, the developer needs additional feedback from the synthesis engine to debug errors for finally improving the system specification. To this end, we explore two further possible improvements. On the one hand, we consider output sensitive synthesis metrics, which allow to synthesize simple and well structured solutions that help the developer to understand and verify the underlying behavior quickly. On the other hand, we consider the extension of delay, whose requirement is a frequent reason for unrealizability. With both methods at hand, we resolve the aforementioned problems and therefore help the developer in the development phase with the effective creation of a safe and correct reactive system.Um reaktive Systeme zu regeln müssen Steuergeräte Zeit, Datenströme und Datentransformationen koordinieren, die durch den übergeordneten Kontrollfluss zusammengefasst werden. Die Aufgabe des Kontrollflusses ist es das System korrekt und dauerhaft zu betreiben. Die Entwicklung solcher Systeme wird dadurch zu einer Herausforderung, denn der Prozess ist fehleranfällig, zeitraubend, unintuitiv und kostspielig. Eine attraktive Alternative ist es stattdessen das System zu synthetisieren, wobei der Entwickler nur das gewünschte Verhalten des Systems festlegt. Der Syntheseapparat kümmert sich dann automatisch um alle technischen Details. Während aktuelle Algorithmen für die Synthese von reaktiven Systemen erfolgreich mit dem Kontrollanteil umgehen können, versagen sie jedoch, sobald komplexe Datentransformationen hinzukommen, aufgrund der Komplexität des vergleichsweise großen Datenraums. Daten und Kontrolle müssen demnach getrennt behandelt werden, um auch große Datenräumen effizient handhaben zu können. Wir präsentieren Temporal Stream Logic (TSL), eine Logik die ausschließlich die Kontrolle einer Steuerung betrachtet, wohingegen Daten und funktionale Datentransformationen als austauschbare Blackboxen gehandhabt werden. In TSL ist es möglich Kontrollflusseigenschaften unabhängig von der Komplexität der zugrunde liegenden Daten zu beschreiben. Des Weiteren kann ein auf TSL beruhender Syntheseapparat die Realisierbarkeit einer Spezifikation prüfen, selbst ohne die konkreten Implementierungen der Datentransformationen zu kennen. Wir präsentieren ein modulares Grundgerüst für die Entwicklung. Es verwendet zunächst den Syntheseapparat um den übergeordneten Kontrollfluss zu erzeugen. Ist dies erfolgreich, so wird der resultierende Kontrollfluss um die konkreten Implementierungen der Datentransformationen erweitert und anschließend zu einer ausführbare Anwendung kompiliert. Wir zeigen auch auf, dass bisherige Syntheseverfahren bereits existierende manuelle Entwicklungsprozesse noch nicht instantan ersetzen können. Im Verlauf der Entwicklung ist es auch weiterhin möglich, dass der Entwickler zunächst unvollständige oder fehlerhafte Spezifikationen erstellt, welche dann erst nach genauerer Betrachtung des synthetisierten Systems weiter verbessert werden können. Im schlimmsten Fall sind Anforderungen inkonsistent oder wichtige Annahmen über das Verhalten fehlen, was zu unrealisierbaren Spezifikationen führt. In beiden Fällen benötigt der Entwickler zusätzliche Rückmeldungen vom Syntheseapparat, um Fehler zu identifizieren und die Spezifikation schlussendlich zu verbessern. In diesem Zusammenhang untersuchen wir zwei mögliche Erweiterungen. Zum einen betrachten wir ausgabeabhängige Metriken, die es dem Entwickler erlauben einfache und wohlstrukturierte Lösungen zu synthetisieren die verständlich sind und deren Verhalten einfach zu verifizieren ist. Zum anderen betrachten wir die Erweiterung um Verzögerungen, welche eine der Hauptursachen für Unrealisierbarkeit darstellen. Mit beiden Methoden beheben wir die jeweils zuvor genannten Probleme und helfen damit dem Entwickler während der Entwicklungsphase auch wirklich das reaktive System zu kreieren, dass er sich auch tatsächlich vorstellt
- …