Richard Potter

Software model checking for distributed systems with selector-based, non-blocking communication

Many modern software systems are implemented as client/server architectures, where a server handles multiple clients concurrently. Testing does not cover the outcomes of all possible thread and communication schedules reliably. Software model checking, on the other hand, covers all possible outcomes but is often limited to subsets of commonly used protocols and libraries. Earlier work in cache-based software model checking handles implementations using socket-based TCP/IP networking, with one thread per client connection using blocking input/output. Recently, servers using non-blocking, selector-based input/output have become prevalent. This paper describes our work extending the Java PathFinder extension net-iocache to such software, and the application of our tool to modern server software.

Fuzzy rewriting: soft program semantics for children

Rewriting systems are popular in end-user programming because complex behavior can be described with few or no abstractions or variables. However, rewriting systems have been limited to manipulating non-rotatable objects on a grid, such as in Agentsheets or Stagecast Creator. Systems that allow free-form movement of objects must use other techniques, such as the sequential programming by demonstration in Squeak. Viscuit is a new rewriting system that introduces fuzzy rewriting, which allows freely positioned and rotated objects to interact using only rewriting rules. The result is a system that allows users to specify animations in a highly interactive way, without textual language or menu selections.

UML Scrapbook and Realization of Snapshot Programming Environment

We have developed SBUML (Scrapbook for UML), an extension of UML (User-Mode Linux), by adding checkpointing functionality to UML. In this paper, we first describe the design and implementation of SBUML, and then propose a new snapshot programming environment, which is realized by the SBUML programming interfaces. The intended applications of SBUML include intrusion detection and sandboxing for network security, and software model checking for verifying multi-threaded programs. In particular, using snapshot programming, one can enumerate state spaces of programs actually running under Linux.

Using Checkpointing and Virtualization for Fault Injection

The program monitoring and control mechanisms of virtualization tools are becoming increasingly standardized and advanced. Together with check pointing, these can be used for general program analysis tools. We explore this idea with an architecture we call Checkpoint-based Fault Injection (CFI), and two concrete implementations using different existing virtualization tools: DMTCP and SBUML. The implementations show interesting trade-offs in versatility and performance as well as the generality of the architecture.

Additional context for gentle-slope systems

Interpreting general purpose programming constructs can be difficult because it requires context, such as knowledge of language syntax or idioms, which users may not have readily available. In such cases other source of context may complement or substitute. This paper proposes annotating program comments with hyperlinks that the user can select to restore the complete runtime state of the program, a technique we call snapshot documentation. The generality of snapshot documentation across user skill and system complexity suggests that it may be useful for gentle-slope systems, i.e. systems that are designed to allow users to acquire a full range of programming skills in an incremental yet continually useful way.

CCC: User-Defined Object Structure in C

Traditional object-oriented programming languages do not support user-level object structure definition, so it is impossible to treat external or low-level data structures (like an integer, an array and a pointer) as actual objects. To overcome this, we apply Predicate Dispatching to arbitrary data of C to create CCC. CCC is a simple language extension of C and features user-level object structure definitions, conditional-style dispatching, multi-methods, and class scoped macros.

A Knoppix-based demonstration environment for JPF

This paper explores how a KVM virtual machine booted with a Knoppix Live DVD can provide a simple and reliable system for sharing demonstrations of JPF, and in particular, for running regression tests in a repeatable way before changes are committed to shared repositories. To make the system easy to automate, we integrated host file system access and a server for script execution. To make it practical for an interactive workow, checkpointing was added to avoid booting and configuration delays. As an unexpected benefit, the isolation provided by the virtual machines allows multiple tests to run in parallel without risk of clashes over resources such as server ports.