Aaron G. Cass

Little-JIL/Juliette: a process definition language and interpreter

Little-JIL, a language for programming coordination in processes is an executable, high-level language with a formal (yet graphical) syntax and rigorously defined operational semantics. The central abstraction in Little-JIL is the step, which is the focal point for coordination, providing a scoping mechanism for control, data and exception flow and for agent and resource assignment. Steps are organized into a static hierarchy, but can have a highly dynamic execution structure including the possibility of recursion and concurrency. Little-JIL is based on two main hypotheses. The first is that coordination structure is separable from other process language issues. Little-JIL provides rich control structures while relying on separate systems for resource, artifact and agenda management. The second hypothesis is that processes are executed by agents that know how to perform their tasks but benefit from coordination support. Accordingly, each Little-JIL step has an execution agent (human or automated) that is responsible for performing the work of the step. This approach has proven effective in supporting the clear and concise expression of agent coordination for a wide variety of software, workflow and other processes.

Using Little-JIL to coordinate agents in software engineering

Little-JIL, a new language for programming the coordination of agents, is an executable, high-level process programming language with a formal (yet graphical) syntax and rigorously defined operational semantics. Little-JIL is based on two main hypotheses. The first is that the specification of coordination control structures is separable from other process programming language issues. Little-JIL provides a rich set of control structures while relying on separate systems for support in areas such as resource, artifact and agenda management. The second hypothesis is that processes can be executed by agents who know how to perform their tasks but can benefit from coordination support. Accordingly, each step in Little-JIl is assigned to an execution agent (human or automated). These agents are responsible for initiating steps and performing the work associated with them. This approach has so far proven effective in allowing us to clearly and concisely express the agent coordination aspects of a wide variety of software, workflow and other processes.

Formalizing rework in software processes

This paper indicates how effective software-process programming languages can lead to improved understandings of critical software processes, as well as improved process performance. In this paper we study the commonly mentioned, but seldom defined, rework process. We note that rework is generally understood to be a major software development activity, but note that it is poorly defined and understood. In this paper we use the vehicle of software-process programming to elucidate the nature of this type of process. In doing so we demonstrate that an effective language (i.e. one incorporating appropriate semantic features) can help explain the nature of rework, and also raise hopes that this type of process can be expedited through execution of the defined process. The paper demonstrates the key role played in effective rework definition by such semantic features as procedure invocation, scoping, exception management, and resource management, which are commonly found in programming languages. A more ambitious program of research into the most useful process-programming language semantic features is then suggested. The goal of this work is improved languages, for improved understandings of software processes, and improved support for software development.

Process support to help novices design software faster and better

In earlier work we have argued that formal process definitions can be useful in improving our understanding and performance of software development processes. There has, however, been considerable sentiment that formalized processes cannot capture the creative process of software design. This paper describes our experimentation with the hypothesis that both design speed and design quality can be improved through the use of formalized process definitions. Our experimentation supports this hypothesis.

Using task models for cascading selective undo

Many studies have shown that selective undo, a variant of the widely-implemented linear undo, has many advantages over the prevailing model. In this paper, we define a task model for implementing selective undo in the face of dependencies that may exist between the undone action and other subsequent user actions. Our model accounts for these dependencies by identifying other actions besides the undone one that should also be undone to keep the application in a stable state. Our approach, which we call cascading selective undo, is built upon a process-programming language originally designed in the software engineering community. The result is a formal analytical framework by which the semantics of selective undo can be represented separately from the application itself. We present our task model, the selective undo algorithm, and discuss extensions that account for differing kinds of inter-action dependencies.

Testing a safety-critical application

The system operates by manipulating a small permanent magnet (known as a “seed”) within the brain using an externally applied magnetic field. By varying the magnitude and gradient of the external magnetic field, the seed can be moved along a non-linear path and positioned at a site requiring therapy, e.g., a tumor. The magnetic field required for movement through brain tissue is extremely high, and is generated by a set of six superconducting magnets located in a housing surrounding the patient’s head.

Design Guidance through the Controlled Application of Constraints

Seeks to facilitate the development of high-quality software designs and architectures by using rigorous process definitions to guide the application of the complex structure of relations and constraints that define well-formedness. We identify various types of constraints and demonstrate specific instances of these types. We endorse the value of maintaining the integrity of these constraints by reacting to their violation with diagnostics and remedies. The sheer number and diversity of these constraints, however, indicates the desirability of a mechanism for controlling the scope and effect of their enforcement. Thus, we propose to use proactive process specifications to control the enforcement of and reaction to the various constraints. This results in a process-driven system that supports designers and architects by guiding them through orderly development and rework processes, disciplined by the application of constraint enforcement at the right times and in the right ways. This work entails research in defining both types and instances of constraints with programmable enforcement strategies, in embedding such constraints in processes, and in appropriate process definition formalisms.

A Pattern for Modeling Rework in Software Development Processes

It is usual for work completed at one point in a software development process to be revisited, or reworked, at a later point. Such rework is informally understood, but if we hope to support reasoning about, and partial automation of, software development processes, rework be more formally understood. In our experience in designing formalized processes in software development and other domains, we have noticed a recurring process pattern that can be used to model rework quite successfully. This paper presents that pattern, which models rework as procedure invocation in a context that is carefully constructed and managed. We present some scenarios drawn from software engineering in which rework occurs. The paper presents rigorously defined models of these scenarios, and demonstrates the applicability of the pattern in constructing these models.

Simulated Conference submissions: A technique to improve student attitudes about writing

While many models have been suggested for improving the writing skills of students in technical fields, we contend that improving attitudes about writing is equally important. We present an approach that seeks to improve both skills and attitudes through the use of simulated conference submissions. In this model, students are asked to write and present as if they are submitting to a technical research conference, complete with a review panel. By giving students this audience, we aim to focus their efforts on communication, rather than simply completing assignment requirements. In this paper, we present our results after having implemented this approach twice. The results show that student skills and appreciation of those skills both improve. In particular, student appreciation of the value of a literature review increases over the course of a term.

Applying Real-Time Scheduling Techniques to Software Processes: A Position Paper

Process and workflow technology have traditionally not allowed for the specification of, nor run-time enforcement of, real-time requirements, despite the fact that time-to-market and other real-time constraints are more stringent than ever. Without specification of timing constraints, process designers cannot effectively reason about real-time constraints on process programs and the efficacy of their process programs in satisfying those constraints. Furthermore, without executable semantics for those timing specifications, such reasoning might not be applicable to the process as actually executed. We seek to support reasoning about the real-time requirements of software processes. In this paper, we describe work in which we have added real-time specifications to a process programming language, and in which we have added deadline timers and task scheduling to enforce the real-time requirements of processes.