Live Logic Programming

Abstract-Logic programming languages are today used to build applications accessing large database systems. This raises the possibility of building live development environments for them. Of particular interest is how specific language features such as level of abstraction, transactions, etc. affect the design of such an environment. In this paper, we explore this question for a specific logic language, Datalog, contrast traditional and live approaches for its tooling and discuss issues that arise

The detection and extraction of interleaved code segments

This project is concerned with a specific difficulty that arises when trying to understand and modify computer programs. In particular, it is concerned with the phenomenon of 'interleaving' in which one section of a program accomplishes several purposes, and disentangling the code responsible for each purposes is difficult. Unraveling interleaved code involves discovering the purpose of each strand of computation, as well as understanding why the programmer decided to interleave the strands. Increased understanding improve the productivity and quality of software maintenance, enhancement, and documentation activities. It is the goal of the project to characterize the phenomenon of interleaving as a prerequisite for building tools to detect and extract interleaved code fragments

The MASTERMIND User Interface Generation Project

Graphical user interfaces are difficult to construct and, consequently, suffer from high development and maintenance costs. Automatic generation from declarative descriptions can reduce costs and enforce design principles. MASTERMIND is a model based approach to user interface generation. Designers model different aspects of an interface using declarative modeling languages, and tools synthesize these models into run-time code. The design process begins with user task and application modeling. These models are then refined into dialogue, presentation, and interaction models and an application API. These latter models drive the synthesis of run-time code. A design tool called Dukas is employed to support the refinement of task models into dialogue models

Formal Models of MasterMind Tasks

Numerous attempts at codifying examples have shown that there is no consensus on the semantics of the MasterMind Task Model. To fix this, we are formalizing the semantics of the Task Model and recording assumptions this model places on the other models in the MM architecture. At the outset, we had to choose a formalism in which to express the semantics. Two candidates seemed logical: Petri-Nets[6] and State-Charts [2]. We chose Petri-Nets. This document explains our choice and records the decisions that led up to it. 1 Introduction MasterMind encourages task-centered system design. An artifact of this design is a stored representation of the task hierarchy. Task hierarchies sequence user events with application and presentation method invocation and i/o. The intention is that: 1. we can build a task interpreter that executes the task hierarchy so that designers can prototype their designs, and 2. we can reason about properties of the task hierarchy to implement design critics and cons..

Dissertation: Automatic Generation of Interactive Systems from Declarative Models

This dissertation applies formal methods to the automatic generation of interactive systems from multiple declarative models. We are interested in two kinds of models: user-task and presentation. The MASTERMIND Dialogue Language (MDL) is presented. MDL is a notation for describing interactive system behavior in terms of user tasks. MDL task models are expressed independently of other models, like presentation, but are later composed with the behavior of these other models. Such separation is important for preserving the integrity of models over the lifetime of a system. The technical challenge in this approach is to generate code that combines the functionality of task and presentation models without violating that integrity. To meet this challenge we implement MDL task models as run-time dialogue constraints that synchronize with presentation components. The constraint engine is implemented as a virtual machine that simulates the execution of tasks and resolves the dependencies that arise as a result of task and presentation model composition. To simplify the generation process, a toolkit of reusable run-time components is provided. Each component in this toolkit implements an MDL operator, and components aggregate into trees whose structure corresponds one-to-one with the abstract syntax tree of a corresponding MDL model. Thus implementations can be generated through a simple syntactic transformation of the MDL source code. The design correctness of these components is validated by a novel application of symbolic model checking. The run-time attributes of systems generated using this approach are measured, and we conclude that this strategy of model composition is feasible for use with real interactive systems

Automatic generation of interactive systems from declarative models

Ph.D.Spencer Rugabe