Results 1  10
of
10
Proving Correctness Of Refinement And Implementation
, 1996
"... The notions of state and observable behaviour are fundamental to many areas of computer science. Hidden sorted algebra, an extension of many sorted algebra, captures these notions through hidden sorts and the behavioural satisfaction of equations. This makes it a powerful formalisation of abstract m ..."
Abstract

Cited by 29 (4 self)
 Add to MetaCart
The notions of state and observable behaviour are fundamental to many areas of computer science. Hidden sorted algebra, an extension of many sorted algebra, captures these notions through hidden sorts and the behavioural satisfaction of equations. This makes it a powerful formalisation of abstract machines, and many results suggest that it is also suitable for the semantics of the object paradigm. Another extension of many sorted algebra, namely order sorted algebra, has proved useful in system specification and prototyping because of the way it handles subtypes and errors. The combination of these two algebraic approaches, hidden order sorted algebra, has also been proposed as a foundation for object paradigm, and has much promise as a foundation for Software Engineering. This paper extends recent work on hidden order sorted algebra by investigating the refinement and implementation of hidden order sorted specifications. We present definitions of refinement and implementation for suc...
Proof of Correctness of Object Representations
"... This paper presents an algebraic account of implementation that is applicable to the object paradigm. The key to its applicability is the notion of state: objects have local states that are observable only through their outputs. That is, objects may be viewed as abstract machines with hidden local s ..."
Abstract

Cited by 27 (14 self)
 Add to MetaCart
This paper presents an algebraic account of implementation that is applicable to the object paradigm. The key to its applicability is the notion of state: objects have local states that are observable only through their outputs. That is, objects may be viewed as abstract machines with hidden local state (as in [9]). Consequently, a correct implementation need only have the required visible behaviour. We use hidden order sorted algebra to formalise the object paradigm [4, 5, 8]. Advantages of an algebraic approach include a high level of intellectual rigour, a large body of supporting mathematics, and simple, efficient proofs using only equational logic. A wide variety of extensions to equational logic have been developed to treat various programming features, while preserving its essential simplicity. For example, order sorted equational logic uses a notion of subsort to treat computations that may raise exceptions or fail to terminate. Hidden sorted logic extends standard equational logic to capture an important distinction between immutable data types, such as booleans and integers, and mutable objects, such as program variables and database entities. The terms abstract data types and abstract object classes refer to these two kinds of entity. The former represent `visible' data values; the latter represent data stored in a hidden state. In hidden sorted equational logic, an equation of hidden sort need not be satisfied in the usual sense, but only up to observability, in that only its visible consequences need hold. Thus, hidden sorted logic allows greater freedom in implementations. The simplicity of the underlying logic is important, because we want a tractable
Introducing FOOPS
, 1992
"... This document describes FOOPS, an objectoriented specification language with an executable subset. The main distinguishing aspect of FOOPS is its advanced facilities for defining and interconnecting modules, which go beyond what other objectoriented languages offer. We present all the language fea ..."
Abstract

Cited by 19 (0 self)
 Add to MetaCart
This document describes FOOPS, an objectoriented specification language with an executable subset. The main distinguishing aspect of FOOPS is its advanced facilities for defining and interconnecting modules, which go beyond what other objectoriented languages offer. We present all the language features, explain their formal semantics, and provide a guide to its current implementation at Oxford.
Invariants, Bisimulations and the Correctness of Coalgebraic Refinements
 Techn. Rep. CSIR9704, Comput. Sci. Inst., Univ. of Nijmegen
, 1997
"... . Coalgebraic specifications are used to formally describe the behaviour of classes in objectoriented languages. In this paper, a general notion of refinement between two such coalgebraic specifications is defined, capturing the idea that one "concrete" class specification realises the behaviour of ..."
Abstract

Cited by 12 (4 self)
 Add to MetaCart
. Coalgebraic specifications are used to formally describe the behaviour of classes in objectoriented languages. In this paper, a general notion of refinement between two such coalgebraic specifications is defined, capturing the idea that one "concrete" class specification realises the behaviour of the other, "abstract" class specification. Two (complete) prooftechniques are given to establish such refinements: one involving an invariant (a predicate that is closed under transitions) on the concrete class, and one involving a bisimulation (a relation that is closed under transitions) between the concrete and the abstract class. The latter can only be used if the abstract class is what we call totally specified. Parts of the underlying theory of invariants and bisimulations in a coalgebraic setting are included, involving least and greatest invariants and connections between invariants and bisimulations. Also, the proofprinciples are illustrated in examples (which are fully formalise...
BehaviourRefinement of Coalgebraic Specifications with Coinductive Correctness Proofs
 Proofs, Proc. TAPSOFT '97, Springer LNCS 1214
, 1997
"... . A notion of refinement is defined in the context of coalgebraic specification of classes in objectoriented languages. It tells us when objects in a "concrete" class behave exactly like (or: simulate) objects in an "abstract" class. The definition of refinement involves certain selection functions ..."
Abstract

Cited by 8 (2 self)
 Add to MetaCart
. A notion of refinement is defined in the context of coalgebraic specification of classes in objectoriented languages. It tells us when objects in a "concrete" class behave exactly like (or: simulate) objects in an "abstract" class. The definition of refinement involves certain selection functions between procedureinputs and attributeoutputs, which gives this notion considerable flexibility. The coalgebraic approach allows us to use coinductive proof methods in establishing refinements (via (bi)simulations). This is illustrated in several examples. 1 Introduction Refinement is an important notion in the stepwise construction of reliable software. It is used to express that an abstract description is realised by a concrete one, typically by fillingin some implementation details. This paper concentrates on refinement in an objectoriented setting. What is typical there is reuse of classes 1 : one tries to refine towards existing classes (available in some library). There are two ...
Formal Specifications in Software Maintenance: From code to Z++ and back again
 INFORMATION AND SOFTWARE TECHNOLOGY
, 1993
"... This paper presents a number of techniques that have been developed as components of the software maintenance process as part of the ESPRIT REDO project. These techniques are all based on formal methods, and the work described has provided the mathematical underpinning to a large collaborative proje ..."
Abstract

Cited by 7 (1 self)
 Add to MetaCart
This paper presents a number of techniques that have been developed as components of the software maintenance process as part of the ESPRIT REDO project. These techniques are all based on formal methods, and the work described has provided the mathematical underpinning to a large collaborative project that has been investigating various aspects of software maintenance. The focus of the project has been on reverse engineering, and methods for this part of the maintenance process are reported on here, along with techniques for subsequent reengineering. A proposal for specificationoriented software maintenance is presented, in which specifications in an objectoriented extension of the formal notation Z are maintained in step with the
Tossing Algebraic Flowers down the Great Divide
 In People and Ideas in Theoretical Computer Science
, 1999
"... 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 l ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
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...
On Refinement and Foops
, 1994
"... FOOPS is a concurrent objectoriented language. Based on FOOPS operational semantics, we define a notion of refinement, and an associated proof technique. The use of refinement for stepwise formal development of programs in FOOPS is illustrated by examples involving memory cells, and different imple ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
FOOPS is a concurrent objectoriented language. Based on FOOPS operational semantics, we define a notion of refinement, and an associated proof technique. The use of refinement for stepwise formal development of programs in FOOPS is illustrated by examples involving memory cells, and different implementations of buffers. 1 Introduction FOOPS is a concurrent objectoriented specification language with an executable subset [8, 23]. FOOPS includes a functional language derived from OBJ [10], 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 objectoriented programming and specification using (conditional) equations. It supports classes of objects with associated methods and attributes, object identity, dynamic object creation and deletion, overloading, polymorphism, inheritance with overriding, and many additiona...
An Algebraic Approach to Refinement of KBS Specification
, 1995
"... This paper reports on an ongoing experiment whose main purpose is to investigate to what extent object orientation might solve the existing or potential problems inherent in the verification and validation of KBSs, when these investigations are carried out at a level higher than the implementation l ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
This paper reports on an ongoing experiment whose main purpose is to investigate to what extent object orientation might solve the existing or potential problems inherent in the verification and validation of KBSs, when these investigations are carried out at a level higher than the implementation level. Techniques for specifying and reasoning about properties of KBSs have been described in previous literature. The main contribution of this paper consists of applying recent work on algebraic theory of objectoriented programming to the specification and design of KBSs. We argue that algebraic specification as a hybrid knowledge specification formalism together with the objectoriented design method provide the properties that can support formal reasoning for KBSs. We refer to the class of KBSs whose development start from an explicit model of expertise. We describe a framework where the explicit model can be formalized and then refined. Refinement proceeds from a highlevel to a lowle...
On Refinement in Rewriting Logic
, 1998
"... Rewriting logic [Mes92] is a logic of action, whose models are concurrent systems and whose deduction is concurrent computation. Refinement is the process of moving from one specification to another, more concrete, specification which displays the same behaviour. In this paper we investigate what th ..."
Abstract
 Add to MetaCart
Rewriting logic [Mes92] is a logic of action, whose models are concurrent systems and whose deduction is concurrent computation. Refinement is the process of moving from one specification to another, more concrete, specification which displays the same behaviour. In this paper we investigate what this process is when we deal with rewrite specifications. 1 Introduction Rewriting logic (RWL) [Mes92, Mes93, MFW92] differs from the standard logics, as first or higherorder logics, by the fact that it is a logic of change whose models are concurrent systems, and whose deduction is concurrent computation in such systems. A concurrent system  as model of the rewriting logic  is formalized as a category with algebraic structure whose objects are states of the system and whose morphisms are transitions in the system. In [Mes92] it is shown that diverse models of concurrency can be expressed and unified within rewriting logic. Following [MG96, GM97], refinement is the process of moving from ...