Neil M. Goldman

Informality in Program Specifications

This paper is concerned with the need for computer-based tools which help human designers formulate formal process-oriented specifications. It first determines some attributes of a suitable process-oriented specification language, then examines the reasons why specifications would still be difficult to write in such a language in the absence of formulation tools. The key to overcoming these difficulties seems to be the careful introduction of informality based on partial, rather than complete, descriptions and the use of a computer-based tool that uses context extensively to complete these descnrptions during the process of constructing a well-formed specification. Some results obtained by a running prototype of such a computer-based tool on a few informal example specifications are presented and, finaliy, some of the techniques used by this prototype system are discussed.

“Lazy” consistency: a basis for cooperative software development

One of the major problems in cooperative software development is that of maintaining certain global consistency properties. Broadcasting changes that have already occured, as many programming environments do, will not resolve this problem. We argue in favor of an architecture where the announcements deal with impending or proposed changes as well as changes that have already occurred. One can then formulate consistency requirements on the system that are maintained “lazily” as it evolves. Such an architecture can support a wider range of cooperative processes than traditional software development environments. This paper describes the design and implementation of this architect ure.

Inference and Paraphrase by Computer

~SrRACT. The MARGIE system is a set of three programs that attempt to understand natural language. They are based on the Conceptual Dependency system for meaning representation. The analysis program maps sentences into conceptual structures. The memory program makes inferences from input conceptual structures. The generator codes conceptual structures back into natural language. Together the programs function as a paraphrase and inference system.

Software evolution through iterative prototyping

The process of developing and evolving complex software systems is intrinsically exploratory in nature. Some prototyping activity is therefore inevitable in every stage of that process. Our program development and evolution methodology is predicated upon this observation. In this methodology, a prototype software system is developed as an approximation to an envisioned target system by compromising along one or more of the following dimensions: system performance, system functionality, or user interface. However, the prototype is not the end-product of the pro- cess. Instead, we support iterative evolution of the prototype towards the envisioned system by gradually dealing with the three general areas of compromise. This paper describes the methodology of using this al- ternative lifecycle; to wit, the programming language concepts and related implementation technology that support practice of the suggested methodology. We summarize the lessons we have learned in building and using this technology over the last several years.

Sentence paraphrasing from a conceptual base

A model of natural language generation based on an underlying language-free representation of meaning is described. A program based on this model is able to produce sentence paraphrases which demonstrate understanding with respect to a given context. This generator operates in conjunction with a natural language analyzer and a combined memory and inference model. In generating sentences from meaning structures, the program employs both the information retrieval and deduction capabilities of the memory model. The model encompasses several diverse classes of linguistic knowledge, which include: (1) executable tests of conceptual properties stored in discrimination nets; (2) information relating conceptual to syntactic roles, stored in a word-sense dictionary, and (3) surface grammatical knowledge, stored in a formal grammar.

Ontology-oriented programming: static typing for the inconsistent programmer

Ontologies and object-oriented data models differ little in their declarative characterization of a domain. Differences in the application of these models, however, has led to quite different characteristics of the programming languages used to create and manipulate them - notably in the presence or lack of static typing. Some ontology-reliant applications need to work with models that are inconsistent with the underlying ontologys declarative norms. Object-oriented languages preclude construction of such models. A secondary distinction is that ontologies, at least as used in the description logic community, provide a semantics that requires an implicit interpretation of extensional data, where possible, that retains consistency with the declarative norms, whereas object-oriented languages treat the norms as constraints that must be explicitly satisfied by a model. An ontology compiler, currently targeting the Microsoft .Net language family, produces a traditional object-oriented class library that captures the declarative norms of an ontology. It enhances this library with additional methods that allow construction of models that are inconsistent with these norms. An application, rather than the library itself, determines when an operation should raise exceptions. Annotations to an ontology allow for tradeoffs between the flexibility of the generated library and its performance.

The Briefing Associate: easing authors into the Semantic Web

The Semantic Web has clear benefits for information consumers, but for authors it typically means added work with no immediate payoff. This article describes Briefing Associate (BA), a tool that eases the effort by automating markup within a popular commercial off-the-shelf (COTS) application. The BA is a descendent of the Design Editor, an application for producing visual, domain-specific design environments. Both tools are implemented as extensions of Microsofts PowerPoint, which, as this paper describes, is a key factor in our research.

Operational specification as the basis for rapid prototyping

This paper describes a set of freedoms which both simplify the task of specifing systems and make the resulting specification more comprehensible. These freedoms eliminate the need, in specific areas, to consider: the mechanisims for accomplishing certain capabilities, the careful coordination and integration of separate operations, the costs of those operations, and other detailed concerns which characterize implementation.These freedoms are partitioned into the areas of efficiency, method, and data, and providing them has resulted in a novel formal specification language, Gist. The main features of this language are described in terms of the freedoms it affords. An overview of the language is then presented together with an example of its use to specify the behavior of a real system.

Self-Adaptive Systems for Information Survivability: PMOP and AWDRAT

Information systems form the backbones of the critical infrastructures of modern societies. Unfortunately, these systems are highly vulnerable to attacks that can result in enormous damage. This paper describes two related systems PMOP and AWDRAT that were developed during the DARPA Self Regenerative Systems program. PMOP defends against insider attacks while AWDRAT is intended to detect compromises to software systems. Both rely on self-monitoring, diagnosis and self-adaptation. We describe both systems and show the results of experiments with each.

Smiley - an interactive tool for monitoring inter-module function calls

Applications running under modern operating systems obtain a significant portion of their functionality from code that is distributed in binary modules that are distinct from the applications own executable. This functionality is accessed by load- or run-time linkage from the application executable or by interprocess communication. Examples of such functionality include user interface management, file system access, process and thread creation and synchronization, and network communications. In the Windows NT operating system, an application obtains this functionality through calls on functions exported from shared libraries. Smiley is a monitoring program that can selectively log these calls as they are made by any application. It does so without any modification of the persistent executable images of either the application or the libraries. Logs of library calls provide insight into an applications implementation. By interactively selecting libraries and functions to monitor, an analyst gradually homes in on aspects of an implementation that are relevant to his objectives. Since it requires only the distributed binary form of the application, Smiley can be used as an aid in comprehending the implementation of COTS software.