This document discusses the implications of substitution in object-oriented programming. It explores issues like memory allocation, the meaning of assignment, and differences between equality and identity testing. Key challenges include not knowing object sizes until runtime, which leads to complex semantics or dynamic objects and garbage collection. Dynamic semantics also tend toward pointer semantics for assignment and non-guarantees for equality. The programmer must be able to redefine equality as needed but this can introduce paradoxes.

1. Implications of
Substitution
Muhammad Adil
Raja
Introduction
The is-a
Relationship
Summary
References
IMPLICATIONS OF SUBSTITUTION
Muhammad Adil Raja
Roaming Researchers, Inc.
cbna
April 19, 2015

2. Implications of
Substitution
Muhammad Adil
Raja
Introduction
The is-a
Relationship
Summary
References
OUTLINE I
INTRODUCTION
THE IS-A RELATIONSHIP
SUMMARY
REFERENCES

3. Implications of
Substitution
Muhammad Adil
Raja
Introduction
The is-a
Relationship
Summary
References
INTRODUCTION
We will investigate some of the implications of the
principle of substitution in statically typed
object-oriented programming languages.
In particular, we will consider:
The impact on memory management
The meaning of assignment
The distinction between testing for identity and
testing for equality

4. Implications of
Substitution
Muhammad Adil
Raja
Introduction
The is-a
Relationship
Summary
References
THE IDEALIZATION OF IS-A RELATIONSHIP
MESSAGE SYNTAX
A TextWindow is-a Window.
Because TextWindow is subclassed from Window, all
behavior associated with Windows is also manifest
by instances of TextWindow.
Therefore, a variable declared as maintaining an
instance of Window should be able to hold a value of
type TextWindow.
Unfortunately, practical programming language
implementation issues complicate this idealized
picture.

5. Implications of
Substitution
Muhammad Adil
Raja
Introduction
The is-a
Relationship
Summary
References
MEMORY ALLOCATION – STACK AND HEAP
BASED
Generally, programming languages use two different
techniques for allocation of memory.
Stack-based allocation.
Amount of space required is determined at compile
time, based on static types of variables.
Memory allocation and release is tied to procedure
entry/exit.
Can be performed very efficiently.
Heap-based allocation.
Amount of space used can be determined at
run-time, based upon dynamic considerations.
Memory allocation and release is not tied to
procedure entry/exit, and either must be handled by
user or by a run-time library (garbage collection).
Generally considered to be somewhat less efficient.

6. Implications of
Substitution
Muhammad Adil
Raja
Introduction
The is-a
Relationship
Summary
References
THE PROBLEM WITH SUBSTITUTION
SUBSTITUTION
class Window {
public : Window x ; / / how much space to set aside?
virtual void oops ( ) ; TextWindow y ;
private : x = y ; / / what should happen here?
int height ;
int width ;
} ;
class TextWindow : public Window {
public :
virtual void oops ( ) ;
private :
char ∗ contents ;
int cursorLocation ;
} ;

7. Implications of
Substitution
Muhammad Adil
Raja
Introduction
The is-a
Relationship
Summary
References
HOW MUCH MEMORY TO SET ASIDE
How much memory should be set aside for the variable x
?
1. (Minimum Static Space Allocation) Allocate the
amount of space necessary for the base class only.
(C++)
2. (Maximum Static Space Allocation) Allocate the
amount of space for the largest subclass.
3. (Dynamic Space Allocation) Allocate for x only the
amount of space required to hold a pointer.
(Smalltalk, Java)

8. Implications of
Substitution
Muhammad Adil
Raja
Introduction
The is-a
Relationship
Summary
References
MINIMUM STATIC SPACE ALLOCATION
The language C++ uses the minimum static space
allocation approach.
This is very efficient, but leads to some subtle
difficulties.
What happens in the following assignment?
ASSIGNMENT
Window x ;
TextWindow y ;
x = y ;

9. Implications of
Substitution
Muhammad Adil
Raja
Introduction
The is-a
Relationship
Summary
References
ASSIGNING A LARGER VALUE TO A SMALLER
BOX
FIGURE : Assignment

10. Implications of
Substitution
Muhammad Adil
Raja
Introduction
The is-a
Relationship
Summary
References
THE SLICING PROBLEM
The problem is you are trying to take a large box and
squeeze it into a small space. Clearly this won’t
work. Thus, the extra fields are simply sliced off.
Question: Does this matter?
Answer: Only if somebody notices.
Solution: Design a language to make it difficult to
notice.

11. Implications of
Substitution
Muhammad Adil
Raja
Introduction
The is-a
Relationship
Summary
References
RULES FOR MEMBER FUNCTION BINDING IN
C++
The rules for deciding what member function to execute
are complicated because of the slicing problem.
1. With variables that are declared normally, the binding
of member function name to function body is based
on the static type of the argument (regardless
whether the function is declared virtual or not).
2. With variables that are declared as references or
pointers, the binding of the member function name to
function body is based on the dynamic type if the
function is declared as virtual, and the static type if
not.

12. Implications of
Substitution
Muhammad Adil
Raja
Introduction
The is-a
Relationship
Summary
References
ILLUSTRATION
ILLUSTRATION
void Window : : oops ( )
{ p r i n t f ( "Window oops n" ) ; }
void TextWindow : : oops ( )
{ p r i n t f ( " TextWindow oops %d n" , cursorLocation ) ;
TextWindow x ;
Window a ;
Window ∗ b ;
TextWindow ∗ c ;
a = x ; a . oops ( ) ; / / executes Window version
b = &x ; b−>oops ( ) ; / / executes TextWindow or Window version ;
c = &x ; c−>oops ( ) ; / / executes TextWindow version

13. Implications of
Substitution
Muhammad Adil
Raja
Introduction
The is-a
Relationship
Summary
References
MINIMUM STATIC SPACE ALLOCATION
A different approach would be to allocate the
Maximum amount of space you would ever need.
Would nicely solve the slicing problem.
Would often allocate unused space.
Maximum amount of space not known until all
classes have been seen.
For this reason, not used in practice.

14. Implications of
Substitution
Muhammad Adil
Raja
Introduction
The is-a
Relationship
Summary
References
DYNAMIC MEMORY ALLOCATION
In the third approach, all objects are actually
pointers.
Only enough space for a pointer is allocated at
compile time.
Actual data storage is allocated on the heap at
run-time.
Used in Smalltalk, Object Pascal, and Objective-C,
Java.
Requires user to explicitly allocate new objects and,
in some languages, explicitly free no longer used
storage.
May also lead to pointer semantics for assignment
and equality testing.

15. Implications of
Substitution
Muhammad Adil
Raja
Introduction
The is-a
Relationship
Summary
References
MEANING OF ASSIGNMENT
What does it mean when an instance of a class is
assigned to another variable?
ASSIGNMENT
class Box {
public int value ;
}
Box x = new Box ( ) ;
x . value = 7;
Box y = x ;
y . value = 12; / / what i s x . value?
Two possibilities:
Copy semantics. x and y are independent of each
other, a change in one has no effect on the other.
Pointer semantcs. x and y refer to the same object,
and hence a change in one will alter the other.

16. Implications of
Substitution
Muhammad Adil
Raja
Introduction
The is-a
Relationship
Summary
References
COPY SEMANTICS VS POINTER SEMANTICS
If a value is indirectly accessed through a pointer,
when an assignment is performed (or equality test is
made) is the quantity assigned simply the pointer or
is it the actual value?

17. Implications of
Substitution
Muhammad Adil
Raja
Introduction
The is-a
Relationship
Summary
References
PROBLEMS WITH POINTER SEMANTICS
If x is assigned to y and then changes are made to x,
are these changes reflected in y?
If x is explicitly freed, what happens if the user tries
to access memory through y?
In C++, programmer can make assignment (equality
testing) mean anything they want.
Object Pascal, Java uses pointer semantics, no
built-in provision for copies.
Smalltalk and Objective-C use pointer semantics,
have several techniques for making copies.

18. Implications of
Substitution
Muhammad Adil
Raja
Introduction
The is-a
Relationship
Summary
References
AN OLD JOKE CONCERNING EQUALITY
There is an old joke that goes something like this: A
man walks into a pizza parlor and sits down.
A waiter comes to the table and asks the man what
he would like to order. The man looks around the
room, then points to the woman sitting at the next
table, and says “I’ll have what she is eating”.
The waiter thereupon walks to the womans table,
picks up the half-eaten pizza from in front of her, and
places it before the startled customer.
A classic confusion between equality and identity.

19. Implications of
Substitution
Muhammad Adil
Raja
Introduction
The is-a
Relationship
Summary
References
EQUALITY AND IDENTITY
A test for identity asks whether two variables refer to
exactly the same object.
A test for equality asks whether two variables refer to
values that are equivalent.
Of course, the meaning of equivalent is inheritently
domain specific.
Object-oriented languages allow the programmer to
control the meaning of the equality test by allowing
the redefinition of a standard method. (for example,
equals in Java).

20. Implications of
Substitution
Muhammad Adil
Raja
Introduction
The is-a
Relationship
Summary
References
PARADOXES OF EQUALITY I
But child classes cannot change the type signature
of overridden methods.
This means the argument must often be more
general than one would like:
EQUALITY
class Object {
public boolean equals ( Object r i g h t ) {
. . .
}
}
class PlayingCard extends Object {
public boolean equals ( Object r i g h t ) {
. . . / / r i g h t must be object even i f we are only
. . . / / interested in comparing cards to cards
}
}
And if you add inheritance into the mix, the possibilities
for paradoxical behavior increase even more.

21. Implications of
Substitution
Muhammad Adil
Raja
Introduction
The is-a
Relationship
Summary
References
PARADOXES OF EQUALITY II
EQUALITY
class Foo {
boolean equals ( Object r i g h t ) { . . . }
}
Foo a , b ;
i f ( a . equals ( b ) ) / / even i f t h i s i s true
i f ( b . equals ( a ) ) / / no guarantee that t h i s i s true

22. Implications of
Substitution
Muhammad Adil
Raja
Introduction
The is-a
Relationship
Summary
References
PARADOXES OF EQUALITY III
And if you add inheritance into the mix, the possibilities
for paradoxical behavior increase even more.
EQUALITY
class Parent {
boolean equals ( Object x ) { . . . }
}
class Child extends Parent {
boolean equals ( Object x ) { . . . }
}
Parent p ;
Child c ;
i f ( p . equals ( c ) ) / / w i l l execute using the parent method
i f ( c . equals ( p ) ) / / w i l l execute using the childs method

23. Implications of
Substitution
Muhammad Adil
Raja
Introduction
The is-a
Relationship
Summary
References
SUMMARY I
We have explored the implications that result from
the inclusion of the principle of substitution in an
object oriented programming language.
Because values are not known until run time, you
either have complex semantics (as in C++) or objects
are dynamic (as in Java and most other languages).
Because objects are dynamic, most object-oriented
languages end up using a garbage collection system.
Dynamic semantics naturally lean to pointer
semantics for assignment
Pointer semantics mean that equality and identity are
two different concepts
Since equality is domain specific, the programmer
must be free to redefine the meaning as appropriate.

24. Implications of
Substitution
Muhammad Adil
Raja
Introduction
The is-a
Relationship
Summary
References
SUMMARY II
Because the programmer can redefine equality
arbitrarily, there is no guarantee that semantics of
equals is preserved.

25. Implications of
Substitution
Muhammad Adil
Raja
Introduction
The is-a
Relationship
Summary
References
REFERENCES I
Images and content for developing these slides have
been taken from the follwoing book with the
permission of the author.
An Introduction to Object Oriented Programming,
Timothy Budd.
This presentation is developed using Beamer:
CambridgeUS, dove.