Mark A. Linton

A performance evaluation of the Intel iAPX 432

We describe art experiment to test the 432 as a high-level language uniprocessor by comparing it with the 8086, 68000, and VAX-11/780 for four integer and character programs written in Ada, C, and Pascal.

Visual abstraction in an interactive programming environment

We are designing a software development system that implements “what you see is what you get” for programming. The system, called OMEGA, allows software to be displayed, processed, and modified, using pictorial representations to convey the structure and levels of abstraction of the program. OMEGA takes advantage of the interactive user interface to provide syntax-free input, user selectable display format, and incremental semantic analysis. By distinguishing input specification from output display, and exploiting interaction in semantic analysis, we are able to unify the different abstraction mechanisms present in traditional programming environments.

The effects of low frequency waves on ion trajectories in the Earth's magnetotail

The trajectories of ions in the Tsyganenko magnetic field model with a convection electric field have been compared to the trajectories when a perturbation electric field based on ISEE-1 and Geotail observations of lower hybrid frequency waves is included. The inclusion of waves dramatically modifies the characteristics of the ion trajectories. For example, initial conditions which result in adiabatic orbits in the absence of waves are often non-adiabatic when waves are included. In addition, both the regions of space accessible to the particles and the energization are changed. Although only individual trajectories were examined in this study, it is argued that the effect of the waves is to mix previously distinct regions of phase space.

A database model of debugging (Preliminary Draft)

Debugging a program can be viewed as performing queries and updates on a database that contains both program source and execution state information. This model of debugging simplifies a “debugger” to a database interface for runtime information and allows the debugger to be easily integrated into a programming environment. We are currently designing a programming environment in which all program information is stored in a relational database system. This system will include debugging capabilities to provide the programmer a simple yet powerful mechanism for describing debugging requests.

A database model of debugging

Debugging a program can be viewed as performing queries and updates on a database that contains program source information as well as the state of the executing program. This approach integrates the facilities of a traditional debugger into a programming environment by providing access to runtime information through normal database query operations. We are building a programming environment in which all program information is stored in a relational database system. This system will include capabilities to provide the programmer a simple yet powerful mechanism for describing debugging requests.

Knowledge-based debugging: session summary

Robert Balzer began the session by presenting an overview of where debugging fits into knowledge-based programming systems. He distinguished between differences in paradigm (the traditional software engineering approach in which the source code is the first formal representation vs. the operational specification approach in which the specification is both formal and executable and from which the implementation is formally derived) and differences in technology (traditional debuggers vs. knowledge-based tools), pointing out that it is possible to use traditional debugging techniques with the operational specification paradigm as well as use knowledge-based tools with the traditional software engineering paradigm. Balzer presented the operational specification paradigm for software development. The basic idea is that an implementation is derived from a specification through transformations chosen by the programmer and applied by the system. Assuming each transformation is correct, the resulting implementation will accurately reflect the intentions of the specification.