FOOPS is a concurrent object-oriented language. We give a structural operational semantics for FOOPS, considering features such as classes of objects with associated methods and attributes, object identity, dynamic object creation and deletion, overloading, polymorphism, inheritance with overriding, concurrency, nondeterminism, atomic execution, evaluation of expressions as background processes, and object protection. 1 Introduction FOOPS is a concurrent object-oriented specification language with an executable subset [13, 27]. FOOPS includes a functional language derived from OBJ [16], which is a first order, purely functional language supporting an algebraic style for the specification, rapid prototyping, and implementation of abstract data types. FOOPS extends OBJ by providing a simple declarative style for object-oriented programming and specification using (conditional) equations. It supports classes of objects with associated methods and attributes, object identity, dynami...

. This paper retraces, collects, summarises, and mildly extends the contributions of the authors --- both together and individually --- on the theme of representing the space of computations of Petri nets in its mathematical essence. Introduction Among the semantics proposed for Petri nets [10] (see also [11, 13]), a relevant role is played by the various notions of process, e.g. [12, 5, 1], whose merit is to provide a faithful account of computations involving many different transitions and of the causal connections between the events occurring in computations. Bare process models, however, fail to bring to the foreground the algebraic structure of the space of computations of a net. Our interest, instead, resides on abstract models that capture the mathematical essence of such spaces, possibly axiomatically, roughly in the same way as a prime algebraic domain (or, equivalently, a prime event structure) models the computations of a safe net [9]. The research detailed in [6, 3, 4, 14,...

Abstract not found

: This paper is an introduction to recent research on hidden algebra and its application to software engineering; it is intended to be informal and friendly, but still precise. We first review classical algebraic specification for traditional "Platonic" abstract data types like integers, vectors, matrices, and lists. Software engineering also needs changeable "abstract machines," recently called "objects," that can communicate concurrently with other objects through visible "attributes" and state-changing "methods." Hidden algebra is a new development in algebraic semantics designed to handle such systems. Equational theories are used in both cases, but the notion of satisfaction for hidden algebra is behavioral, in the sense that equations need only appear to be true under all possible experiments; this extra flexibility is needed to accommodate the clever implementations that software engineers often use to conserve space and/or time. The most important results in hidden algebra are ...

Abstract not found

This paper presents axiomatizability results for Inclusive Equational Logic, a categorical generalization of equational logic that further generalizes local equational logic (Cazanescu 1993). The word "inclusive" is motivated by our pervasive use of inclusion systems, invented by Diaconescu, Goguen and Stefaneas (Diaconescu et al. 1993), and further developed in (Hilberdink 1996; Cazanescu and Rosu 1997); these are categories with extra structure to capture the notion of "inclusion". Inclusion systems can be very useful in computing science, e.g., in specification theory (Diaconescu et al. 1993)

Abstract. Using equational logic as a specification language, we investigate the proof theory of behavioral subtyping for object-oriented abstract data types with immutable objects and deterministic methods that can use multiple dispatch. In particular, we investigate a proof technique for correct behavioral subtyping in which each subtype’s specification includes terms that can be used to coerce its objects to objects of each of its supertypes. We show that this technique is sound, using our previous work on the model theory of such abstract data types. We also give an example to show that the technique is not complete, even if the methods do not use multiple dispatch, and even if types specified are term-generated. In preparation for the results on equational subtyping we develop the proof theory of a richer form of equational logic that is suitable for dealing with subtyping and behavioral equivalence. This gives some insight into question of when our proof techniques can be make effectively computable, but in general behavioral consequence is not effectively computable. 1.

: This paper reviews our progress towards a new software paradigm extending the object paradigm, based on hidden order sorted algebra. Our goal is to produce software that is much more adaptable to context, and is also highly reliable and predictable. We find the logic of algebra, which is equational logic, especially convenient because of its simple and efficient mechanisation of reasoning. We show how equational specifications can describe objects, inheritance and modules, and support reasoning about them. Our treatment of modules emphasises the importance of reuse, and the role of the so-called Satisfaction Condition. We then show how to unify the object and logic paradigms by using logical variables that range over objects, and how to connect objects into concurrent systems, using a universal characterisation of parallel connection, and more generally, of parallel connection with synchronisation. We also discuss situated adaptive modules, which extend the power of paramet...

Data Types and Algebraic Semantics The history of programming languages, and to a large extent of software engineering as a whole, can be seen as a succession of ever more powerful abstraction mechanisms. The first stored program computers were programmed in binary, which soon gave way to assembly languages that allowed symbolic codes for operations and addresses. fortran began the spread of "high level" programming languages, though at the time it was strongly opposed by many assembly programmers; important features that developed later include blocks, recursive procedures, flexible types, classes, inheritance, modules, and genericity. Without going into the philosophical problems raised by abstraction (which in view of the discussion of realism in Section 4 may be considerable), it seems clear that the mathematics used to describe programming concepts should in general get more abstract as the programming concepts get more abstract. Nevertheless, there has been great resistance to u...

We present a logical framework in which abstract interpretations can be naturally specified and then verified. Our approach is based on membership equational logic which extends equational logics by membership axioms, asserting that a term has a certain sort. We represent an abstract interpretation as a membership equational logic specification, usually as an overloaded order-sorted signature with membership axioms. It turns out that, for any term, its least sort over this specification corresponds to its most concrete abstract value. Maude implements membership equational logic and provides mechanisms to calculate the least sort of a term efficiently. We first show how Maude can be used to get prototyping of abstract interpretations "for free." Building on the meta-logic facilities of Maude, we further develop a tool that automatically checks an abstract interpretation against a set of user-defined properties. This can be used to select an appropriate abstract interpretation, to characterize the specific loss of information during abstraction, and to compare different abstractions with each other.