An Object-Oriented Refinement Calculus (original) (raw)

ERC ? An object-oriented refinement calculus for Eiffel

Formal Aspects of Computing, 2004

We present a refinement calculus for transforming object-oriented (OO) specifications (or 'contracts') of classes into executable Eiffel programs. The calculus includes the usual collection of algorithmic refinement rules for assignments, if-statements, and loops. However, the calculus also deals with some of the specific challenges of OO, namely rules for introducing feature calls and reference types (involving aliasing). The refinement process is compositional in the sense that a class specification is refined to code based only on the specifications (not the implementations) of the classes that the specification depends upon. We discuss how automated support for such a process can be developed based on existing tools. This work is done in the context of a larger project involving methods for the seamless design of OO software in the graphical design notation BON (akin to UML). The goal is to maintain model and source code integrity, i.e., the software developer can work on either the model or the code, where (ideally) changes in one view are reflected instantaneously and automatically in all views.

A Seamless Eiffel-Based Refinement Calculus for Object-Oriented Systems

2002

The Eiffel language [4] can be used throughout the object-oriented software development process, for both specification and implementation. We outline work-in-progress on developing a refinement calculus for producing provably correct Eiffel programs from Eiffel specifications. We propose extensions to the calculus by integrating abstract data types as a front-end language that can be used for avoiding implementation bias.

A Seamless Eiffel-Based Refinement Calculus for Object-Oriented Systems (Extended Abstract)

2002

The Eiffel language can be used throughout the object-oriented software development process, for both specification and implementation. We outline work-in-progress on developing a refinement calculus for producing provably correct Eiffel programs from Eiffel specifications. We propose extensions to the calculus by integrating abstract data types as a front-end language that can be used for avoiding implementation bias.

A Refinement Algebra for Object-Oriented Programming

Lecture Notes in Computer Science, 2003

In this article we introduce a comprehensive set of algebraic laws for rool, a language similar to sequential Java but with a copy semantics. We present a few laws of commands, but focus on the objectoriented features of the language. We show that this set of laws is complete in the sense that it is sufficient to reduce an arbitrary rool program to a normal form expressed in a restricted subset of the rool operators. We also propose a law for data refinement that generalises the technique from traditional modules to class hierarchies. Together, these laws are expressive enough to derive more elaborate rules that can be useful, for example, to formalize object-oriented design practices; this is illustrated through the systematic derivation of a refactoring from the proposed laws.

Object-oriented specification and stepwise refinement

1991

A basic concept in object-oriented approaches is the notion of object as integrated unit of structure and behavior. Conceptually, objects are modeled as processes of which certain dynamic characteristics of their internal state can be observed using attributes. Objects are the basic units of design. Systems are composed from objects that interact to provide the desired services. In the semantics domain, concepts related to the object-oriented paradigm like interaction, inheritance and object aggregation can be uniformily modelled by object morphisms.

Specification refinements: Calculi, tools, and applications

Science of Computer Programming

We propose and study a framework for systematic development of software systems (or models) from their formal specifications. We introduce a language for formal development by refinement and decomposition, as an extension to CASL. We complement it with a notion of refinement tree and present proof calculi for checking correctness of refinements as well as their consistency. Both calculi have been implemented in the Heterogeneous Tool Set (Hets), and have been integrated with other tools like model finders and conservativity checkers.

Semantics, calculi, and analysis for object-oriented specifications

Acta Informatica, 2009

We present a formal semantics for an object-oriented specification language. The formal semantics is presented as a conservative shallow embedding in Isabelle/HOL and the language is oriented towards OCL formulae in the context of UML class diagrams. On this basis, we formally derive several equational and tableaux calculi, which form the basis of an integrated proof environment including automatic proof support and support for the analysis of this type of specifications. We show applications of our proof environment to data refinement based on an adapted standard refinement notion. Thus, we provide an integrated formal method for refinement-based object-oriented development.

Unifying program construction and modification

Logic Journal of IGPL, 1998

We propose a method which integrates program modification to the refinement calculus style of program development. Given a program developed through stepwise refinement of a specification, we propose an approach to specify modifications and to derive a new program from the existing refinement steps. This approach is based on the refinement lattice operator meet. A modification to a specification is represented by taking the meet of the old specification and the new feature to add. A solution to the new specification is constructed by coercing the new feature to match the structure of the existing refinement steps. The method fosters reuse of refinement steps and their proofs. We also show that program construction is streamlined by using coercion 1 .

Class Refinement and Interface Refinement in Object-Oriented Programs

FME '97: Industrial Applications and Strengthened Foundations of Formal Methods, 1997

Constructing new classes from existing ones by inheritance or subclassing is a characteristic feature of object-oriented development. Imposing semantic constraints on subclassing allows us to ensure that the behaviour of superclasses is preserved or refined in their subclasses. This paper defines a class refinement relation which captures these semantic constraints. The class refinement relation is based on algorithmic and data refinement supported by Refinement Calculus. Class refinement is generalized to interface refinement, which takes place when a change in user requirements causes interface changes of classes designed as refinements of other classes. We formalize the interface refinement relation and present rules for refinement of clients of the classes involved in this relation.

Object-oriented model refinement technique in software reengineering

Proceedings. The Twenty-Second Annual International Computer Software and Applications Conference (Compsac '98) (Cat. No.98CB 36241), 1998

Software reengineering for object-oriented rearchitecturing offers an exciting opportunity in migrating old legacy systems to evolvable systems in a disciplined manner. In the twofold-strategy software reengineering for object-oriented rearchitecturing, one of the problems to be solved is to derive a proper object-oriented model from the output of reverse engineering and the output of forward engineering. In general, the outputs of forward and reverse engineering can be inconsistent in their abstract levels, the amount of design information, naming conventions, and structures. In this paper, we present an Object-oriented model Refinement Technique(ORT) to build a final object model in the twofold-strategy software reengineering. We first organize the information gained from reverse engineering into specification information tree, and then compare the entities in the specification information tree with the information from forward engineering using tree-structured data dictionary to produce the final model. We demonstrate the usability of ORT by an example.