A behavioral notion of subtyping

@article{Liskov1994ABN,
  title={A behavioral notion of subtyping},
  author={Barbara H. Liskov and Jeannette M. Wing},
  journal={ACM Trans. Program. Lang. Syst.},
  year={1994},
  volume={16},
  pages={1811-1841}
}
The use of hierarchy is an important component of object-oriented design. Hierarchy allows the use of type families, in which higher level supertypes capture the behavior that all of their subtypes have in common. For this methodology to be effective, it is necessary to have a clear understanding of how subtypes and supertypes are related. This paper takes the position that the relationship should ensure that any property proved about supertype objects also holds for its subtype objects. It… 

Behavioral Subtyping Relations for Active Objects

  • H. Wehrheim
  • Biology, Computer Science
    Formal Methods Syst. Des.
  • 2003
This paper investigates the object-oriented notion of subtyping in the context of behavioral formalisms, which provides alternative characterizations for theSubtyping relations, which are taxonomically ordered in a hierarchy.

Behavioural Subtyping Relations for Object-Oriented Formalisms

This paper investigates the object-oriented notion of subtyping in the context of behavioural formalisms, and formalises the concept of "usability" via testing scenarios, which provide alternative characterisations for the subtyped relations.

An Approach to Behavioral Subtyping Based on Static Analysis

  • F. Logozzo
  • Computer Science
    Electron. Notes Theor. Comput. Sci.
  • 2005

Behavioral Subtyping Using Invariants and Constraints

A way of defining the subtype relation that ensures that subtype objects preserve behavioral properties of their supertypes is presented, and the ramifications of the approach of subtyping the design of type families are discussed.

Concepts of behavioral subtyping and a sketch of their extension to component-based systems

This work sketches a notion of behavioral subtyping for objects in component-based systems, where reasoning about the events that a component can raise is important.

Forcing behavioral subtyping through specification inheritance

  • K. DharaG. Leavens
  • Computer Science
    Proceedings of IEEE 18th International Conference on Software Engineering
  • 1996
This paper presents a specification technique that uses inheritance of specifications to force the appropriate behavior on the subtype objects to avoid reverification of unchanged code.

Behavioral subtyping in object-oriented languages

This dissertation proposes two notions of behavioral subtyping that allow sound modular reasoning based on the static types of variables in programs and proves that both these behavioral subtype notions are sufficient for sound modular Reason.

6 Concepts of Behavioral Subtyping and a Sketch of their Extension to Component-Based Systems

This work sketches a notion of behavioral subtyping for objects in component-based systems, where reasoning about the events that a component can raise is important.

Support for subtyping and code re-use in Timor

The separation of types and implementations simplifies a separation of subtyping and subclassing, facilitating the re-use of implementations of one type to implement other, unrelated types.

Enriching Behavioral Subtyping

This work proposes a formal system that allows us to establish stronger properties of the client code on the basis of the richer behavior provided by the appropriate derived classes.
...

References

SHOWING 1-10 OF 51 REFERENCES

Family Values: A Semantic Notion of Subtyping

This paper takes the position that the relationship should ensure that any property proved about supertype objects also holds for its subtype objects, and presents two ways of defining the subtype relation.

Modular specification and verification of object-oriented programs

A method for modular specification and verification using the ideas of subtype and normal type, which corresponds to informal techniques used by object-oriented programmers, and a formal model of abstract type specifications is used.

A Semantics of Multiple Inheritance

Programming with taxonomically organized data is often called objectoriented programming, and has been advocated as an effective way of structuring programming environments, data bases, and large systems in general.

Designing an Object-Oriented Programming Language with Behavioural Subtyping

POOL-I is the first language the authors know of that includes subtyping and inheritance as completely separate language mechanisms, and by decoupling these two, a much cleaner language design can be obtained and a much more flexible use of both mechanisms can be made in actual programs.

A parallel object-oriented language with inheritance and subtyping

This paper shows that inheritance and subtyping can be introduced advantageously into a parallel object-oriented language, POOL-I, and several problems traditionally adhering to inheritance can be solved.

An object-oriented refinement calculus with modular reasoning

This thesis gives the first formal definition of modular reasoning for object-oriented languages, which allows programs to make arbitrary observations about objects, such as testing the type of an object.

TOWARDS A THEORY FOR ABSTRACT DATA TYPES

A rigorous framework for studying immutable data types having nondeterministic operations and operations exhibiting exceptional behavior is developed. The framework embodies the view of a data type

Reasoning about object-oriented programs that use subtypes

Formal specification and verification techniques for such programs that mimic informal ideas about object-oriented programs by using subtype relationships to classify the behavior of objects of different types are described.

Modular Reasoning in an Object-Oriented Refinement Calculus

A simple model of procedure invocation for object-oriented languages based on the refinement calculus is developed and the minimum requirements for a system to support modular reasoning are defined.

Subtyping for Mutable Types in Object-Oriented Programming Languages

This work defines what it means for one abstract data type to be a subtype of another in object-oriented programming languages, and allows for both mutation and aliasing.
...