Toward Formal Verification of Rule-Based Systems: A Shared Dataspace Perspective

Rule-based programs used in mission- and safety-critical applications need to be shown to be free of hazards. This paper discusses formal proof-techniques which promise to assist designers in this task. In this paper we show that the shared dataspace language Swarm has many key features in common with rule-based languages. We outline an assertional programming logic for Swarm programs and use the logic to reason about the correctness of a simple program. This logic is a suitable foundation for the development of techniques specific to present and future rule-based languages

A UNITY-Style Programming Logic for a Shared Dataspace Language

The term shared dataspace refers to the general class of programming languages in which the principal means of communication among the concurrent components of programs is a common, content-addressable data structure called a dataspace. In the programming language and artificial intelligence communities, there is considerable interest in such languages, e.g., logic-based languages, production rule systems, and the Linda language. However, these languages have not been the subject extensive program verification research. This paper specifies a proof system for the shared dataspace language Swarm - a proof system similar in style to that of UNITY. The paper then uses the proof system to reason about two different solutions to the problem of labelling the connection equal-intensity regions of the digital image

A Shared Dataspace Model of Concurrency -- Language and Programming Implications

The term shared dataspace refers to the general class of models and languages in which the principal means of communication is a common, content-addressable data structure called a dataspace. Swarm is a simple language we have used as a vehicle for the investigation of the shared dataspace approach to concurrent computation. This paper reports on the progress we have made toward the development of a formal operational model for Swarm and a few of the language and programming implications of the model. The paper has four parts: an overview of the Swarm language, a presentation of a formal operational model, an examination of Swarm programming strategies via a series of related example programs, and a discussion of the distinctive features of the shared dataspace model

Unity-Style Proofs for Shared Dataspace Programs Using Dynamic Statements

The term shared dataspace refers to the general class of programming languages in which the principal means of communication among the concurrent components of programs is a common, content-addressable data structure called a dataspace. In the programming language and artificial intelligence communities, there is considerable interest in such languages, e.g. logic-based languages, production rule systems, and the Linda language. However, these languages have not been the subject of extensive program verification research. This paper specifies a proof system for a shared dataspace programming notation called Swarm-- a program logic similar in style to that of UNITY. The paper then uses the logic to reason about a solution to the problem of labeling the connected equal-intensity regions of a digital image

The Synchronic Group: A Concurrent Programming Concept and Its Proof Logic

Swarm is a computational model which extends UNITY in three important ways: (1) UNITY\u27s fixed set of variables is replaced by an unbounded set of tuples which are addressed by content rather than by name; (2) UNITY\u27s static set of statements is replaced by a dynamic set of transactions; and (3) UNITY\u27s static II-composition is augmented by dynamic coupling of transactions into synchronic groups. This paper overviews the Swarm model, introduced the synchronic group concept, and illustrates their use in the expression of dynamically structured programs. A UNITY-style programming logic is given for SWARM, the first axiomatic proof system for a shared database language

The Synchronic Group: A Concurrent Programming Concept and its Proof Logic

Swarm is a computational model which extends the UNITY-model in three important ways: (1) UNITY\u27s fixed set of variables is replaced by an unbounded set of tuples which are addressed by content rather than by name; (2) UNITY\u27s static set of statements is replaced by a dynamic set of transactions; and (3) UNITY\u27s static ||-composition is augmented by dynamic coupling of transactions into synchronic groups. Taking advantage of the similarities of the Swarm and UNITY computational models, we have developed a programming logic for Swarm and UNITY computational models, we have developed a programming logic for Swarm which is similar in style to that UNITY. The Swarm logic uses the same logical relations as UNITY, but the definitions of the relations have been generalized to handle the dynamic nature of Swarm, i.e. dynamically created transactions and the synchrony relations. The Swarm programming logic is the first axiomatic proof system for a shared dataspace language, i.e. a language in which communication is accomplished via a shared content-addressable data structure. To our knowledge, no axiomatic-style proof systems have been published for Linda, a production rule language, or any other shared dataspace language

Mixed Programming Metaphors in a Shared Dataspace Model of Concurrency

The term shared dataspace refers to the general class of models and languages in which the principal means of communication is a common, content-addressable data structure called a dataspace. Swarm is a simple language we have used as a vehicle for the investigation of the shared dataspace approach to concurrent computation. It is the first shared dataspace language to have an associated assertional-style proof system. An important feature of Swarm is its ability to bring a variety of programming paradigms under a single, unified model. In a series of related examples we explore Swarm\u27s capacity to express shared-variable, message-passing, and rule-based computations; to specify synchronous and asynchronous processing models; and to accommodate highly dynamic program and data structures. Several illustrations make use of a programming construct unique to Swarm, the synchrony relation, and explain how this feature can be used to construct dynamically structured, partially synchronous computation. The paper has three parts: an overview the Swarm programming notation, an examination of Swarm programming strategies via a series of related example programs, and a discussion of the distinctive features of the shared dataspace model. A formal operational model for Swarm is presented in an appendix

A Shared Dataspace Language Supporting Larger-Scale Concurrency

Our ultimate goal is to develop the software support needed for the design, analysis, understanding, and testing of programs involving many thousands of concurrent processes running on a highly parallel multiprocessor. We are currently evaluating the use of a shared dataspace paradigm as the basis for a new programming language supporting large-scale concurrency. The language is called SDL (Shared Dataspace Language). In SDL, a content-addressable dataspace is examined and altered by concurrent processes using atomic transactions much like those in a traditional database. Associated with each process is a programmer-defined view. The view is a mechanism which allows processes to interrogate the dataspace at a level of abstraction convenient for the task they are pursuing. This paper provides an overview of the key SDL features. Small examples are used to illustrate the power and flexibility of the language. They also serve as a backdrop against which we discuss programming style implications of the shared dataspace paradigm

CTIX Message System User\u27s Manual Version 1.0

This manual describes how to use the CTIX Message System for interprocess communication in a distributed application program. The CTIX Message System is a package of message-passing facilities developed by the Concurrent Systems Group of the Department of Computer Science at Washington University, It provides a process-to-process asynchronous, buffered communication medium. The package is implemented on a network of Convergent Technologies (CT) MiniFrame workstations. These workstations support the CTIX (the Ct\u27s version of UNIX System V) operating system and the TCP/IP network protocols

Toward Comprehensive Specification of Distributed Systems

A new approach to modelling distributed systems is presented. It uses sequential processes and event synchronization as building blocks to construct a cohesive picture of the interdependent requirements for the functionality, architecture, scheduling policies, and performance attributes of a distributed system. A language called CSPS (an extension of Hoare\u27s CSP) is used in the illustration of the approach. Employing CSP as a base allows modelled systems to be verified using techniques already developed for verifying CSP programs and leads to the emergence of a uniform incremental strategy for verifying both logical and performance properties of distributed systems. Several small distributed systems have been modelled using this approach. These exercises enabled us to evaluate the notation system and to gain some expertise on how to approach the specification of distributed systems. This paper describes one of the models and the modelling strategy that has emerged from these exercises