Behavioural Subtyping Relations for Object-Oriented Formalisms

Fischer, Clemens; Wehrheim, Heike

doi:10.1007/3-540-45499-3_33

Cited by 30 publications

(27 citation statements)

References 17 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Wehrheim and Fischer [12,23] investigate behavioural subtyping in the context of concurrency and the CSP process algebra. They studied how extra subclass operations may interfere with the behaviour of the superclass as observed from the environment, and under which conditions are safety and liveness properties preserved by the subclasses.…”

Section: Related Workmentioning

confidence: 99%

Relaxing Behavioural Inheritance

Amálio

2013

Electron. Proc. Theor. Comput. Sci.

View full text Add to dashboard Cite

Object-oriented (OO) inheritance allows the definition of families of classes in a hierarchical way. In behavioural inheritance, a strong version, it should be possible to substitute an object of a subclass for an object of its superclass without any observable effect on the system. Behavioural inheritance is related to formal refinement, but, as observed in the literature, the refinement constraints are too restrictive, ruling out many useful OO subclassings. This paper studies behavioural inheritance in the context of ZOO, an object-oriented style for Z. To overcome refinement's restrictions, this paper proposes relaxations to the behavioural inheritance refinement rules. The work is presented for Z, but the results are applicable to any OO language that supports design-by-contract.

show abstract

Section: Related Workmentioning

confidence: 99%

Relaxing Behavioural Inheritance

Amálio

2013

Electron. Proc. Theor. Comput. Sci.

View full text Add to dashboard Cite

show abstract

“…In this case, the sequences of internal communication distinguishes the classes in Figure 1 and Figure 2. Fischer and Wehrheim [28] further investigate behavioral subtyping based on histories for object-oriented languages.…”

Section: Fig 4 Multi-threaded Programsmentioning

confidence: 99%

Combining Monitoring with Run-Time Assertion Checking

Boer

Gouw

2014

Lecture Notes in Computer Science

View full text Add to dashboard Cite

Abstract. According to a study in 2002 commisioned by a US Department, software bugs annually costs the US economy an estimated $59 billion 1 . A more recent study in 2013 by Cambridge University estimated that the global cost has risen to $312 billion globally 2 .There exists various ways to prevent, isolate and fix software bugs, ranging from lightweight methods that are (semi)-automatic, to heavyweight methods that require significant user interaction. Our own method described in this tutorial is based on automated run-time checking of a combination of protocol-and data-oriented properties of object-oriented programs. Run-Time Checking of Object-Oriented ProgramsGiven a program and a specification, a run-time verifier inserts checks in the code that determine whether the specification is satisfied. The checks are triggered during an actual execution of the program. In contrast to static verification, where properties are checked with respect to all executions (possibly there are infinitely many), run-time checkers only consider a single execution of the program. There is a wide range of specification languages used in run-time verification. They can be partitioned into two categories: languages that focus on the control-flow (these approaches are also called "monitoring"), and those focussing on data-flow.As an example, one can use regular expressions to specify the order in which functions or methods in a program should be called [18]. Such specifications describe the control-flow of the program. Other formalisms for specifying controlflow are temporal logics, various kinds of automata and context-free grammars. For these formalisms, checking whether a given property holds of the current execution involves parsing a word (where the word is some representation of the trace of method calls in the current execution) in an automata. Generally only formalisms are chosen with a decidable parsing problem (in particular, this is the case for regular expressions, context-free grammars and most automata), so Approaches that specify data-flow usually do so by annotating the source code with assertions: logical formulas that must be true whenever control passes them. The formulas constrain the values of the program variables. If assertions are expressed in first-order logic with arithmetic, it is in general undecidable due to unbounded quantification (i.e. ranging over an infinite number of values) whether the assertion is true, thus usually the assertions are restricted in some way. For instance, Java contains an assert-statement which restricts to quantifier-free formulas (i.e. Boolean expressions). Design by Contract [53] provides a systematic way of using assertions to specify classes, interfaces and methods with respectively class invariants and pre-and postconditions. It was first used in the programming language Eiffel, and subsequently has also been applied to many other programming languages. For example, JML [14] is one of the most popular specification languages for Java and supports Design by Contract. JML...

show abstract

“…Formal approaches to inheritance tend to favor the first interpretation and understand inheritance in terms of behavioral reuse, obeying the substitutability principle: As a subclass is a specialization of a superclass, an object of the subclass may masquerade as an object of the superclass. This interpretation of inheritance has led to an active field of research on behavioral subtyping [2,14,27], identifying conditions for safe substitutability. A type describes a collection of objects which share the same externally observable behavior.…”

Section: Inheritance: Reuse Of Behavior and Reuse Of Codementioning

confidence: 99%

A Dynamic Binding Strategy for Multiple Inheritance and Asynchronously Communicating Objects

Johnsen

Owe

2005

Formal Methods for Components and Objects

View full text Add to dashboard Cite

This paper considers an integration of asynchronous communication, virtual binding, and multiple inheritance. Object orientation is the leading paradigm for concurrent and distributed systems, but the tightly synchronized RPC communication model seems unsatisfactory in the distributed setting. Asynchronous messages are better suited, but lack the structure and discipline of traditional object-oriented methods. The integration of messages in the object-oriented paradigm is unsettled, especially with respect to inheritance and redefinition. Asynchronous method calls have been proposed in the Creol language, reducing the cost of waiting for replies in the distributed environment while avoiding lowlevel synchronization constructs such as explicit signaling. A lack of reply to a method call need not lead to deadlock in the calling object. Creol has an operational semantics defined in rewriting logic. This paper considers a formal operational model of multiple inheritance, virtual binding, and asynchronous communication between concurrent objects, extending the semantics of Creol.

show abstract

Behavioural Subtyping Relations for Object-Oriented Formalisms

Cited by 30 publications

References 17 publications

Relaxing Behavioural Inheritance

Relaxing Behavioural Inheritance

Combining Monitoring with Run-Time Assertion Checking

A Dynamic Binding Strategy for Multiple Inheritance and Asynchronously Communicating Objects

Contact Info

Product

Resources

About