Chapter 16:

Topics in Computer Science: ObjectOriented Programming

History of Objects:
Where
they
came
from

Start of the Story: Late 60's and

Early 70's
Windows are made of glass, mice are

undesirable rodents
Good programming = Procedural
Abstraction

Verb-oriented

Procedural
Abstractions
Define tasks to be performed
Break tasks into smaller and smaller

pieces

Until you reach an implementable size

Define the data to be manipulated

Design how functions interact
What's the input
What's the output
Group functions into components

(modules" or "classes")
Write the code

Object-oriented
programming
First goal: Model the objects of the world
Noun-oriented
Focus on the domain of the program

Phases
Object-oriented analysis: Understand the

domain

Define an object-based model of it

Object-oriented design: Define an

implementation

Design the solution

Object-oriented programming: Build it

Howd we get from there

to
here?

Key ideas

Master-drawings in Sketchpad
Simulation objects in Simula

Alan Kay and a desire to make software

better
More robust, more maintainable, more

scalable

Birth of Objects, 1
of
Ivan2Sutherland's Sketchpad, 1963

Sketchpad
First object-oriented drawing program
Master and instance drawings
Draw a house
Make an instance
Add a chimney to the master
Poof! The instance grows a chimney
Other interesting features
1/3 Mile Square Canvas
Invention of rubber band lines
Simple animations

Birth of Objects, 2
of
2
Simula
Simulation programming language from

Norway, 1966
Define an activity which can be
instantiated as processes
Each process has it own data and
behavior

In real world, objects don't mess with each

others' internals directly

(Simulated) Multi-processing

No Universal Scheduler in the Real World

Alan Kay
U. Utah PhD student in 1966
Read Sketchpad, Ported Simula
Saw objects as the future of

computer science
His dissertation: Flex, an objectoriented personal computer
A personal computer was a radical idea

then

"A Personal Computer

for
Children
of
All
Flex, an objectoriented personal
Ages"
computer
Enabled by Moore's Law
Imagining personal
computing in 1969
Computer as meta-

medium
The first medium to

encompass other media

A 1970s depiction of
students
using an objectoriented system based
on Flex

Kays Insights
Computer as collection of Networked

Computers
All software is simulating the real world
Biology as model for objects
Bacterium has 120M of info, 1/500th of a

Cell, and we have 1013 of these in us.

Talk about processing power! Talk about

managing complexity!

What man-made things can scale like that?

Stick a million dog houses together to get the

Empire State Building?

Birth of Objects
Objects as models of real world entities
Objects as Cells
Independent, indivisible, interactingin

standard ways
Scales well
Complexity: Distributed responsibility
Robustness: Independent
Supporting growth: Same mechanism everywhere
Reuse: Provide services, just like in real
world

Alan Kays Dynabook

(1972)
Alan Kay sees the Computer as Mans first
metamedium

A medium that can represent any other media:

Animation, graphics, sound, photography, etc.

Programming is yet another medium

The Dynabook is a (yet mythical) computer

for creative metamedia exploration and

reading

Handheld, wireless network connection

Writing (typing), drawing and painting, sound

recording, music composition and synthesis

End-user programming

A Dynabook is for
Learning
The Dynabook offers a new way to learn
new kinds of things
Dynamic systems (like evolution)

Especially decentralized ones (Resnick, 1992)

Knowledge representation (Papert, 1980)

Programming (Kay & Goldberg, 1977)

But need a system for creative expression

In a time when windows were made of
glass, and mice were undesirable rodents

Smalltalk was

the programming
language
invented for
the Dynabook.
For the
Dynabook, WIMP
was invented:
overlapping Windows
Icons
Menus
mouse Pointer

Challenge
If you interacted with a computer

through a terminal (as opposed to

punched cards) before Smalltalk-72,
what do you think you did to get the
computer to do something for you?

A first Object: Logo

Turtle
Dr. Seymour Papert at MIT invented the
Turtle as a graphical and mathematical
object to think with for the childrens
programming language, Logo
A turtle is an object.
Every turtle understands the same methods.
Every turtle has the same fields or instance

variables.
Heading, body color, pen color, X and Y position.
Yet each turtle can have its own values for these
fields.

Using Turtles in
Python
>>> makeWorld()

Adding a Turtle to
our
World
>>> earth
= makeWorld ()
>>> tina = makeTurtle(earth)
>>> print tina
No name turtle at 320, 240
heading 0.0.

Things turtles can

do: Try it!
>>> turtleX.penUp ()
>>> turtleX.moveTo (0,0)
>>> turtleX.penDown ()
>>> turtleX.moveTo (639 ,479)
>>> worldX = makeWorld ()
>>> turtleX =
makeTurtle(worldX)
>>> turtleX.setVisible(false)
#dont draw the turtle
>>> turtleX.penUp () # dont
draw the path
>>> turtleX.moveTo (0 ,240)
>>> turtleX.penDown () # draw
the path

>>> turtleX.setPenWidth
(100) # width of pen
>>> turtleX.setColor(blue)
>>> turtleX.turnRight ()
>>> turtleX.forward (300)
>>> turtleX.penUp () # dont
draw the path
>>> turtleX.setColor(red)
>>> turtleX.moveTo (400 ,0)
>>> turtleX.turnRight ()
>>> turtleX.setPenWidth
(160)
>>> turtleX.penDown () #
draw the path
>>> turtleX.forward (400)

Talking to turtles as
functions
or
We can tell a turtle to go forward by
calling a function (telling the function
messages/methods
to act on the turtle):

Or we can ask Tina to go forward, a

certain amount. We are sending a message

to Tina, asking her to execute a function
that only turtles know: A method

Challenge: What do
these
>>> earth = draw? >>> for steps
makeWorld()
>>> carol =
makeTurtle(earth)
>>> for steps in
range(4):
...
forward(carol,100)
...
turn(carol,90)
...

in

range(5):
...
forward(carol,100)
...
turn(carol,72)
...

Challenge
How would you draw a triangle?

Sending multiple
turtles messages
>>> sue =
makeTurtle(earth)
>>> tina.forward ()
>>> tina.turnRight ()
>>> tina.forward ()

Sue stays put

while Tina
moves.
These are
objects on
which we
execute
methods.

Each turtle knows the

same
things,
has
the
Each turtle knows how to go forward
same
state
and turn.
Each knows a heading and an X and Y

position.
But each turtle has its own X and Y and

heading values.

Using
multipl
e
turtles
at once

def chase():
# Set up the four turtles
earth = World()
al = Turtle(earth)
bo = Turtle(earth)
cy = Turtle(earth)
di = Turtle(earth)

al.penUp()
al.moveTo(10,10)
al.penDown()
bo.penUp()
bo.moveTo(10,400)
bo.penDown()
cy.penUp()
cy.moveTo(400,10)
cy.penDown()
di.penUp()
di.moveTo(400,400)
di.penDown()
# Now, chase for 300 steps
for i in range(0,300):
chaseTurtle(al,cy)
chaseTurtle(cy,di)
chaseTurtle(di,bo)
chaseTurtle(bo,al)

Chasing
def
chaseTurtle(t1,t2):
t1.turnToFace(t2)
t1.forward(4)

Dropping pictures
from turtles
>>> # I chose Barbara.jpg
for this
>>>
p=makePicture(pickAFile()
)
>>> # Notice that we make
the World and Turtle here
>>> earth=World()
>>> turtle=Turtle(earth)
>>> turtle.drop(p)

Spinning and dropping a

turtle on a canvas

def spinAPicture(apic):
canvas =
makeEmptyPicture(640,480)
ted = Turtle(canvas)
for i in range(0,360):
ted.drop(apic)
ted.forward(10)
ted.turn(20)
return canvas

Teaching Turtles new

Tricks
class SmartTurtle(Turtle
):
def drawSquare(self ):
for i in range (0 ,
4):
self.turnRight
()
self.forward ()

The class Turtle

exists.
Here, we create a new
kind of Turtle, a
specialization called
SmartTurtle, that
knows how to draw
squares.
drawSquare is a method
that SmartTurtle
instances understand.
All Python methods
must accept self as
the first parameter
self is the object
receiving the message.

Trying our new method

>>> earth = World ()
>>> smarty =
SmartTurtle(earth)
>>> smarty.drawSquare ()

More than one method

class SmartTurtle(Turtle ):
def drawSquare(self ):
for i in range (0 ,4):
self.turnRight ()
self.forward ()
def drawSquare(self , width
):
for i in range (0 ,4):
self.turnRight ()
self.forward(width)

Now SmartTurtle
instances understand
both how to
drawSquare() and
drawSquare(someWidth
)

Trying the new

methods
>>> mars = World ()
>>> tina =
SmartTurtle(mars)
>>> tina.drawSquare (30)
>>> tina.drawSquare (150)
>>> tina.drawSquare (100)

Challenge
Write the method drawPolygon which

takes a size and number of sides.

Inheritance and
Overriding
We can create a version of Turtle
thats confused.
Turns a random amount.
Goes forward a random amount.

This class is a subclass of Turtle.

That means it inherits everything from

Turtle.
It will override how to turn and go
forward.

ConfusedTurtle
import random
class ConfusedTurtle(Turtle):
def forward(self,num):
Turtle.forward(self,int(num*random.random
()))
def turn(self,num):
Turtle.turn(self,int(num*random.random())
)

Works the same,

performs different
>>> pluto = World()
>>> goofy =
ConfusedTurtle(pluto)
>>> goofy.forward(100)
>>> goofy.turn(90)

Example on Making a
Class
from
Scratch:
Lets build a program to show a
SlideShow
show.

slide

It shows a picture.
Then plays a corresponding sound.

Well use the introduced-but-never-used

blockingPlay() to make the execution wait
until the sound is done.

Slideshow
def playslideshow():
pic = makePicture(getMediaPath("barbara.jpg"))
snd = makeSound(getMediaPath("bassoon-c4.wav"))
show(pic)
blockingPlay(snd)
pic = makePicture(getMediaPath("beach.jpg"))
snd = makeSound(getMediaPath("bassoon-e4.wav"))
show(pic)
blockingPlay(snd)
pic = makePicture(getMediaPath("santa.jpg"))
snd = makeSound(getMediaPath("bassoon-g4.wav"))
show(pic)
blockingPlay(snd)
pic = makePicture(getMediaPath("jungle2.jpg"))
snd = makeSound(getMediaPath("bassoon-c4.wav"))
show(pic)
blockingPlay(snd)

Whats wrong with

this?
From Procedural Abstraction:
We have duplicated code.
We should get rid of it.

From Object-Oriented Programming:

We have an object: A slide.

Defining an object
Objects know things.
Data that is internal to the object.
We often call those instance variables.
Objects can do things.
Behavior that is internal to the object.
We call functions that are specific to an

object methods.

But you knew that one already.

We access both of these using dot notation

object.variable
object.method()

The Slide Object

What does a slide know?
It has a picture.
It has a sound
What can a slide do?
Show itself.

Show its picture.

(Blocking) Play its sound.

Classes
Objects are instances of classes in

many object-oriented languages.

Including Smalltalk, Java, JavaScript,

and Python.

A class defines the data and behavior

of an object.
A class defines what all instances of

that class know and can do.

We need to define a
slide
class
Easy enough:
class slide:
That wasnt so hard was it?
What comes next?
Some method for creating new slides.
Some method for playing slides.

Creating new
instances
We are going to create

new instances
by calling the class name as if it
were a function.
That will automatically create a new

instance of the class.

Creating a slide

Lets create a slide and

give it a picture and
sound instance variables.

>>> slide1=slide()
>>> slide1.picture =
makePicture(getMediaPath("barbara.jpg")
)
>>> slide1.sound =
makeSound(getMediaPath("bassoonc4.wav"))

Defining a show()
method
To show a slide, we want to show()

the
picture and blockingPlay() the sound.
We define the function as part of the
class block.
So this is a def that gets indented.

Defining the method

show()
Why self?
class slide:
When we say

object.method(),
Python finds the
method in the
objects class,
then calls it with
the object as an
input.
Python style is to
call that self.

Its the object

itself.

def show(self):
show(self.picture)
blockingPlay(self.sound
)

Now we can show our

slide
>>> slide1.show()
We execute the method using the same

dot notation weve seen previously.

Does just what youd expect it to do.
Shows the picture.
Plays the sound.

Making it simpler
Can we get rid of those picture and

sound assignments?
What if we could call slide as if it
were a real function, with inputs?
Then we could pass in the picture and

sound filenames as inputs.

We can do this, by defining what Java

calls a constructor.
A method that builds your object for

you.

Making instances more

flexibly
To create new instances with inputs, we
must define a function named __init__
Thats underscore-underscore-i-n-i-t-

underscore-underscore.
Its the predefined name for a method that
initializes new objects.

Our __init__ function will take three

inputs:

self, because all methods take that.

And a picture and sound filename.
Well create the pictures and sounds in the
method.

Our whole slide class

class slide:
def __init__(self,
pictureFile,soundFile):
self.picture =
makePicture(pictureFile)
self.sound = makeSound(soundFile)
def show(self):
show(self.picture)
blockingPlay(self.sound)

The playslideshow()
def playslideshow():
slide1 = slide(getMediaPath("barbara.jpg"),
getMediaPath("bassoon-c4.wav"))
slide2 =
slide(getMediaPath("beach.jpg"),getMediaPath("bassoon
-e4.wav"))
slide3 =
slide(getMediaPath("santa.jpg"),getMediaPath("bassoon
-g4.wav"))
slide4 =
slide(getMediaPath("jungle2.jpg"),getMediaPath("basso
on-c4.wav"))
slide1.show()
slide2.show()
slide3.show()
slide4.show()

Using map with slides

Slides are now just objects, like

any other kind of object in Python.

They can be in lists, for example.
Which means that we can use map.
We need a function:
def
showSlide(aslide):
aslide.show()

PlaySlideShow with
Map

def playslideshow():
slide1 = slide(getMediaPath("barbara.jpg"), getMediaPath("bassoonc4.wav"))
slide2 = slide(getMediaPath("beach.jpg"),getMediaPath("bassoone4.wav"))
slide3 = slide(getMediaPath("santa.jpg"),getMediaPath("bassoong4.wav"))
slide4 = slide(getMediaPath("jungle2.jpg"),getMediaPath("bassoonc4.wav"))
map(showSlide,[slide1,slide2,slide3,slide4])

But not very objectoriented

This version of the slide object is not very
object oriented.
We set the picture and sound by directly

touching the instance variables.

Adele Goldberg, who helped invent the first
programming language Smalltalk, said that a
key rule of object-oriented programming is,
Ask, dont touch.

How do we let users ask to access

instance variables?
By creating methods for getting (getters)

and setting (setters) instance variables.

class slide:
def __init__(self,
pictureFile,soundFile):

Class
with
getters
and
setters

self.setPicture(makePicture(pictureFile))
self.setSound(makeSound(soundFile))
def getPicture(self):
return self.picture
def getSound(self):
return self.sound
def setPicture(self,newPicture):
self.picture = newPicture
def setSound(self,newSound):
self.sound = newSound
def show(self):
show(self.getPicture())
blockingPlay(self.getSound())

Challenge
Write a version of this function where

you also change the sounds and

pictures in the objects (using setters
and getters), then replay the slide
def playslideshow():
show.
slide1 = slide(getMediaPath("barbara.jpg"),
getMediaPath("bassoon-c4.wav"))
slide2 =
slide(getMediaPath("beach.jpg"),getMediaPath("bassoone4.wav"))
slide3 =
slide(getMediaPath("santa.jpg"),getMediaPath("bassoong4.wav"))
slide4 =
slide(getMediaPath("jungle2.jpg"),getMediaPath("bassoon-

The value of objects

Is this program easier to write?
It certainly has less replication of code.
It does combine the data and behavior of slides
in one place.

If we want to change how slides work, we change them in

the definition of slides.
We call that encapsulation: Combining data and behavior
related to that data.

Being able to use other objects with our objects

is powerful.

Being able to make lists of objects, to be able to use

objects (like picture and sound) in our objects.
We call that aggregation: Combining objects, so that
there are objects in other objects.

Weve been doing this

already, of course.

Youve been using objects already,

everywhere.
Pictures, sounds, samples, colors
these are all objects.
Weve been doing aggregation.
Weve worked with or talked about lists

of pictures, sounds, pixels, and samples

The functions that weve been

providing merely cover up the

underlying objects.

Using picture as an
object
>>> pic=makePicture(getMediaPath("barbara.jpg"))
>>> pic.show()

Slides and pictures

both
Did you show()
notice that we can say
slide1.show() and pic.show()?
Show() generally means, in both
contexts, show the object.
But whats really happening is
different in each context!
Slides show pictures and play sounds.
Pictures just show themselves.

Another powerful aspect

of
objects:
When the same method name can be applied
to more than one object, we call that
Polymorphism
method polymorphic

From the Greek many shaped

A polymorphic method is very powerful for

the programmer.
You dont need to know exactly what method

is being executed.
You dont even need to know exactly what
object it is that youre telling to show()
You just know your goal: Show this object!

Uncovering the
objects
This is how the show() function

is

defined in JES:
You can ignore the raise and if
The key point is that the function is

simply executing the method.

def show(picture):
if not picture.__class__ ==
Picture:
print "show(picture): Input is
not a picture"
raise ValueError
picture.show()

Pictures and Colors

have
polymorphic
>>>
pic=makePicture(getMediaPath("barbara.jpg
methods,
too
"))
>>> pic.show()
>>> pixel = getPixel(pic,100,200)
>>> print pixel.getRed()
73
>>> color = pixel.getColor()
>>> print color.getRed()
73

We can get/set
components
at
either
getRed, getBlue, getGreen, setRed,
setBlue, setGreen
level
Are all defined for both colors and pixels

Why didnt we define the functions to

work with either?

Its somewhat confusing to have a

globally-available function take two kinds

of things as input: Colors or pixels.
But its completely reasonable to have a
method of the same name in more than one
object.

More methods than

functions
In general, there are many more methods
defined in JES than there are functions.
Most specifically, there are a whole
bunch of methods for drawing onto a
picture that arent defined as functions.
We simply ran out of time/energy to

convert them all into functions.

And we rationalized that it was easier to
deal with the complexity at the level of
methods than functions.

Overview of graphics
methods
pic.addRect(color,x,y,width,height)
pic.addRectFilled(color,x,y,width,heig

ht)
pic.addOval(color,x,y,width,height)
pic.addOvalFilled(color,x,y,width,heig
ht)

Arcs
pic.addArc(color,x,y,width,height,startang

le,arcangle)
pic.addArcFilled(color,x,y,width,height,st
artangle,arcangle)
Make an arc for arcangle degrees, where

startangle is the starting point. 0 = 3

oclock.

Positive arc is counter-clockwise, negative is

clockwise

Center of the circle is middle of the

rectangle (x,y) with given height and width

Text
Text can have style, but only limited.
Java limits it for cross-platform
compatibility.
pic.addText(color,x,y,string)
pic.addTextWithStyle(color,x,y,string,style

)
Style is made by makeStyle(font,emph,size)
Font is sansSerif, serf, or mono
Emph is italic, bold, or plain.

You can get italic, bold by italic+bold

Size is a point size

Rectangles: Coloring
lines and fills
>>> pic=makePicture
(getMediaPath("640x480.jpg"
))
>>> pic.addRectFilled
(orange,10,10,100,100)
>>> pic.addRect
(blue,200,200,50,50)
>>> pic.show()
>>>
pic.writeTo("newrects.jpg")

writeTo() is polymorphic for both

sounds and pictures.

Ovals
>>> pic=makePicture
(getMediaPath("640x480.
jpg"))
>>> pic.addOval
(green,200,200,50,50)
>>> pic.addOvalFilled
(magenta,10,10,100,100)
>>> pic.show()
>>>
pic.writeTo("ovals.jpg"
)

Arcs and colored

lines

>>> pic=makePicture
(getMediaPath("640x480.jpg"))
>>>
pic.addArc(red,10,10,100,100,
5,45)
>>> pic.show()
>>> pic.addArcFilled
(green,200,100,200,100,1,90)
>>> pic.repaint()
>>>
pic.addLine(blue,400,400,600,
400)
>>> pic.repaint()
>>> pic.writeTo("arcslines.jpg")

Text examples
>>> pic=makePicture
(getMediaPath("640x480.jpg"))
>>>
pic.addText(red,10,100,"This
is a red string!")
>>> pic.addTextWithStyle
(green,10,200,"This is a
bold, italic, green, large
string",
makeStyle(sansSerif,bold+ital
ic,18))
>>> pic.addTextWithStyle
(blue,10,300,"This is a blue,
larger, italic-only, serif
string",
makeStyle(serif,italic,24))
>>> pic.writeTo("text.jpg")

Sunset using methods

Any of our older

functions will work

just fine with
methods.
def makeSunset(picture):
for p in
getPixels(picture):
p.setBlue(p.getBlue()*0.7
)
p.setGreen(p.getGreen()*0
.7)

Backwards using
methods
def backwards(filename):
source = makeSound(filename)
target = makeSound(filename)

To get the sample object,

sourceIndex = source.getLength()
snd.getSampleObjectAt(index
for targetIndex in range(1,target.getLength()+1):
)
# The method is getSampleValue, not
getSampleValueAt
sourceValue =source.getSampleValue(sourceIndex)
# The method is setSampleValue, not
setSampleValueAt
target.setSampleValue(targetIndex,sourceValue)
sourceIndex = sourceIndex - 1

return target

Why objects?
An important role for objects is to reduce the

number of names that you have to remember.

writeSoundTo() and writePictureTo() vs.

sound.writeTo() and picture.writeTo()

They also make it easier to change data and

behavior together.
Think about changing the name of an instance

variable. What functions do you need to change?

Odds are good that theyre the ones right next
to where youre changing the variable.

Most significant power is in aggregation:

Combining objects

Python objects vs.

other
objects
One of the key ideas for objects

was not

messing with the innards.

Not true in Python.
We can always get at instance variables of

objects.

It is true in other object-oriented

languages.
In Java or Smalltalk, instance variables

are only accessible through methods

(getPixel) or through special declarations
(This variable is public!)

Inheritance
We can declare one class to be inherited by

another class.
It provides instant polymorphism.
The child class immediately gets all the data

and behavior of the parent class.

The child can then add more than the parent

class had.
This is called making the child a

specialization of the parent.

A 3-D rectangle might know/do all that a
rectangle does, plus some more:

class rectangle3D(rectangle):

Inheritance is a
tradeoff
Inheritance is talked about a

lot in

the object-oriented world.

It does reduce even further duplication

of code.
If you have two classes that will have
many the same methods, then set up
inheritance.

But in actual practice, inheritance

doesnt get used all that much, and

can be confusing.

When should you use

objects?
Define your own objects when you have:
Data in groups, like both pictures and

sounds.
Behavior that you want to define over
that group.

Use existing objects:

Alwaystheyre very powerful!
Unless youre not comfortable with dot
notation and the idea of methods.

Then functions work just fine.