1. Introduction to Computer Science
Unit 1
Programs as Interacting Objects
Classes, Instances, and Messages
The Robot World
Primitive Instructions and Simple Programs

2. Course Mechanics
Lectures: Monday/Tuesday, 12:00 – 13:45 and 14:00 – 15:45, Chimia 7
Sections (Dan and Moshe): On Tuesdays (17:00), Wednesdays (12:00, 14:00, and 18:00) and Thursdays (8:00), Sprinzak 29 / 26 / 214 / 217 / 214
Extra Help
Problem Sets, Final Exam, Office Hours

3. Extra Help
Course for first year students – learning the basics of Unix on HU computers
3 Fridays: , ,
8:00 to 12noon
Rothberg Hall (used to be Kaplan A)
From 11:00 to 12noon you will have “face-to-face” time with computers in another room

4. Resources
Slides, can be bought in the Acadamon, and viewed online
Books
An Introduction to Computer Science with Java, Kamin, Mickunas, and Reingold
(“Karel++” and “Karel”, Bergin, Stehlik, Roberts, Pattis)

6. Course Mission Statement
“To give the student the tools to develop correct, efficient, well-structured, and stylish programs, and to build a foundation for further studies in Computer Science.”
-An Introduction to Computer Science with Java Kamin, Mickunas, and Reingold

7. Entering Students’ Prior Knowledge in Computer Science
Number of Students
Amount of Background

8. Entering Students’ Prior Knowledge in Computer Science
Course is aimed here
Number of Students
Amount of Background

9. Entering Students’ Prior Knowledge in Computer Science
Course is aimed here
Number of Students
Amount of Background
Will get less out of course

10. Entering Students’ Prior Knowledge in Computer Science
Course is aimed here
Number of Students
Amount of Background
Have to invest more time, but all material is presented
Will get less out of course

11. Today: Object Oriented Programming Basics
We start with the fundamentals of Object Oriented Programming
Then, we apply these principles to a particular (robot) programming environment
In two weeks, we move on to programming in Java

12. Anything we can put a thumb on
The World of Objects
The World consists of Objects
Objects are Nouns
A System of Objects is usually what we want to simulate or implement with a program on a computer
Anything we can put a thumb on

13. Example 1 Traffic System Simulate traffic flow, traffic jams
Objects include:
Cars
Trucks
Pedestrians
Traffic Lights
The Road itself!

14. Example 2 Checkout Counter System Simulate throughput at grocery store
Objects include:
Customers
Cashiers
Groceries

15. Example 3 Class Scheduling System Assign students to classes
Objects include:
Students
Classes
Time slots
Rooms

16. Example 4 Graphical Drawing System
Allow user to draw shapes and manipulate them on the screen
Objects include:
Circles
Rectangles
Lines
Polygons

17. Objects have a State — Attributes
An attribute is any characteristic of an object

18. Objects Can Do Things — Methods
An object has operations it can perform — built right into it

19. Objects Can be Sent Messages
One object can ask another object for a service, by sending it a message
One object asks another to use a particular method

20. Basic Objects Objects Attributes Methods Message
Nouns, things in the world
Attributes
Properties each of those things have
Methods
Actions that each of those things can do
Message
Communication from one object to another, asking for a method to be used; the way methods are “triggered”

21. Let’s Consider Shapes Shapes have a state — attributes
Shapes can do things — methods
Attributes of a shape:
Filled, line width, line color, fill color, location
Methods of a shape:
Fill, Empty, Move, Grow

22. Fun with Shapes Each Shape is an Object
Properties of a shape:
filled
line width
line color
fill color
location
Methods of a shape:
Fill
Empty
Move
Grow

23. There is a Structure Here
There are certain shapes of a related kind
This prototype is called a Class
Each circle is different, but they are all instances of the class Circle

24. Each Object is an Instance of a Class
An Instance of the Class “Circle”
Two Instances of the Class “Square”
An Instance of the Class “Line”

25. Classes
A Class is an abstract description of objects having the same attributes and methods
A specific Object is an instance of a Class
A Class is the cookie cutter — An Object is the cookie
Person
bill
Attributes: Age Height Weight
Methods: Move
Attributes: Age = Height = 177cm Weight = 68 kg
Methods: Move
Class
Instance

26. Many Different Objects from a Single Class
Person
bill
Attributes: Age = Height = 177 cm Weight = 68 kg
Methods: Move
Attributes: Age Height Weight
Methods: Move
Class
steve
Attributes: Age = Height = 180 cm Weight = 71 kg
Methods: Move
larry
Attributes: Age = Height = 179 cm Weight = 67 kg
Methods: Move
scott
Attributes: Age = Height = 182 cm Weight = 75kg
Methods: Move
Instances

27. How Do We Create an Object?
We use a constructor
This takes a Class and creates an Instance of the class, an object, perhaps with certain properties
“Construct an Instance of the Class Person, give it the name “bill”, and make its Age be 41, its height be 177 cm, and its weight be 68 kg.”

28. How Do We Create an Object?
Person
bill
Attributes: Age = Height = 177 cm Weight = 68 kg
Methods: Move
Attributes: Age Height Weight
Methods: Move
Presto! We now have an object “bill”, with certain attributes, and with the method Move
The object “bill” can now be sent the message “Move”

29. Object Vocabulary Classes — Prototypes for objects
Objects — Nouns, things in the world
Constructor — Given a Class, the way to create an Object (that is, an Instance of the Class) and initialize it
Attributes — Properties an object has
Methods — Actions that an object can do
Messages — Communication from one object to another, asking for a method to be used

30. The Robot World N Robot (facing East) wall beeper W E 8 S t r e s S 76 5 4 3 2 1 1 2 3 4 5 6 7 8 9 10 11 12 13
Origin
Avenues

31. Robot Capabilities Any mobile robot Can move forward Can turn in place
Can pick up and put down beepers into his “beeper bag”

32. Programs
When we want a Robot to do something, we send it a detailed sequence of messages — how to do it
There exists a Controller that receives, memorizes, and follows instructions
These instructions are called a program

33. Programming Language Instructions are given in a special language
It has a vocabulary, punctuation marks, and rules of grammar
The language allows us to write brief and unambiguous programs

34. Tasks and Situations
A task is something we want a Robot to do — move to a particular corner, escape from a maze, find a beeper and deposit it on the origin
A situation is an exact description of the Robot’s world
What corner are Robots on?
What directions are they facing?
What is the location and size of each wall section in the world?
What is the location of each beeper (including the number of beepers in robots’ beeper bags)?

35. Initial and Final Situation
The initial situation is the starting state of the world: 8 7 6 5 4 3 2 1 1 2 3 4 5 6 7 8 9 10 11 12 13

36. Initial and Final Situation
The initial situation is the starting state of the world (unless told otherwise, assume beeper bag starts empty): 8 7 6 5 4 3 2 1 1 2 3 4 5 6 7 8 9 10 11 12 13
5 Beepers in the Beeper Bag

37. Initial and Final Situation
The final situation is the ending state of the world (Robot turns itself off): 8 7 6 5 4 3 2 1 1 2 3 4 5 6 7 8 9 10 11 12 13
2 Beepers in the Beeper Bag

38. The BasicRobot Class
This is the class that can be used to create instances of actual Robots in the robot world
It has five methods:
move
turnLeft
pickBeeper
putBeeper
turnOff
Let’s look at each of them
BasicRobot
move
turnLeft
pickBeeper
putBeeper
turnOff

39. move
When a robot executes a move instruction, it moves forward one block
It continues to face the same direction
The robot will not move forward if there is a wall section or boundary wall between himself and the corner he would move to; instead, he executes the move by turning himself off — performing an error shutoff

40. Successful move After move Before move S t r e s 5 S t r e s 5 4 4 3 32 2 1 1 1 2 3 4 5 1 2 3 4 5
Avenues
Avenues
Before move
After move

41. Execution of move causes Error Shutoff5 S t r e s 5 4 4 3 3 2 2 1 1 1 2 3 4 5 1 2 3 4 5
Avenues
Avenues
Before move
After move:
Error Shutoff

42. turnLeft A robot executes turnLeft by pivoting 90 degrees to the left
A robot stays on the same street corner
No wall section can block a robot’s turn, so turnLeft cannot cause an error shutoff

43. turnLeft After turnLeft Before turnLeft S t r e s 5 S t r e s 5 4 4 32 2 1 1 1 2 3 4 5 1 2 3 4 5
Avenues
Avenues
Before turnLeft
After turnLeft

44. move and turnLeft
A robot always starts on a corner, facing north, south, east or west
He can’t move fractions of a block or turn other than 90 degrees, so after move or turnLeft he is still on a corner and still facing north, south, east or west
What about “turnRight”, which doesn’t exist as a primitive instruction?

45. pickBeeper
A robot executes a pickBeeper by picking up a beeper from the corner he is on and putting it in his bag
If there is no beeper there, he performs an error shutoff
If there is more than one beeper, he randomly picks up one and puts it in the bag
beepers are small; they never block movement

46. successful pickBeepert r e s 5 S t r e s 5 4 4 3 3 2 2 1 1 1 2 3 4 5 1 2 3 4 5
Avenues
Avenues
2 beepers in bag
3 beepers in bag
Before pickBeeper
After pickBeeper

47. putBeeper
A robot executes putBeeper by taking out beeper from bag and putting it on current street corner
If beeper bag is empty, a robot executes putBeeper by performing an error shutoff

48. successful putBeeper Before putBeeper After putBeeper S t r e s 5 S t4 4 3 3 2 2 1 1 1 2 3 4 5 1 2 3 4 5
Avenues
Avenues
2 beepers in bag
1 beeper in bag
Before putBeeper
After putBeeper

49. turnOff
When a robot executes a turnOff, he turns himself off and does not execute any more instructions until he is restarted on another task
The last message in every robot program must be a turnOff message

50. The BasicRobot Class
This class has not only five methods, but also four attributes
x-location
y-location
direction
num-beepers
Each has the obvious meaning
BasicRobot
x-location y-location direction num-beepers
move
turnLeft
pickBeeper
putBeeper
turnOff

51. None of these Attributes or Methods Exist in Isolation
We use the Class BasicRobot to create an instance of a robot
The instance is created using a constructor; that gives the robot a name and sets it up in an initial situation (that is, with initial attributes)
We send messages to the instance, telling it what to do

52. Creating an Instance x-location y-location direction num-beepers move
BasicRobot
bill
x-location y-location direction num-beepers
x-location = ... y-location = ... direction = ... num-beepers = ...
Class
Instance
move
turnLeft
pickBeeper
putBeeper
turnOff
move
turnLeft
pickBeeper
putBeeper
turnOff
Constructor

53. An Instance of BasicRobot
So let’s say we want to create an instance of BasicRobot, called bill, standing at Avenue 2, Street 6, facing East, with 1 beeper in his bag
We write BasicRobot bill = new BasicRobot(2, 6, East, 1)
Now, to get bill to move, we would write bill.move That is, we send bill a “move” message, and he moves

54. BasicRobot bill = new BasicRobot(2, 6, East, 1)
x-location = 2 y-location = 6 direction = East num-beepers = 1 8 7 6 5
move
turnLeft
pickBeeper
putBeeper
turnOff 4 3 2 1 1 2 3
1 Beeper in the Beeper Bag

55. Primitive Instructions and Simple Programs
We get a robot to execute an instruction by sending it a message with the associated action
We execute a program by executing each instruction in the program

56. A Complete Program
We pose a task and exhibit a complete, correct program
We initialize bill, a BasicRobot instance, to start on 2nd Street and 2nd Avenue, and transport a beeper from 2nd Street and 4th Avenue to 4th Street and 5th Avenue
After depositing the beeper, bill moves one block farther north and turns himself off

57. Initial and Final Situations5 S t r e s 5 4 4 3 3 2 2 1 1 1 2 3 4 5 1 2 3 4 5
Avenues
Avenues
Initial Situation
Final Situation

58. A Robot Program for the Task
main {
BasicRobot bill = new BasicRobot(2, 2, East, 0);
bill.move;
bill.pickBeeper;
bill.turnLeft;
bill.putBeeper;
bill.turnOff; }
The actual program you will enter for the targil will be written in Java and have a few minor differences…

59. A Robot Program for the Task
import intro2cs.utils.*; class MoveRobot { public static void main(String[ ] args) {
BasicRobot bill = new BasicRobot(2, 2, East, 0);
bill.move( );
bill.pickBeeper( );
bill.turnLeft( );
bill.putBeeper( );
bill.turnOff( ); }
The actual program you will enter for the targil will be written in Java and have a few minor differences…

60. A Robot Program for the Task
import intro2cs.utils.*; class MoveRobot { public static void main(String[ ] args) {
BasicRobot bill = new BasicRobot(2, 2, East, 0);
bill.move( );
bill.pickBeeper( );
bill.turnLeft( );
bill.putBeeper( );
bill.turnOff( ); }
The actual program you will enter for the targil will be written in Java and have a few minor differences…

61. Steps to Nirvana
Type the program into a file named MoveRobot.java (case matters; really)
Compile it (you’ll learn how in the tirgul)
Execute it (you’ll learn how in the tirgul)
The program runs

62. Compilation Program Source code Compilation
Machine code for some specific machine

63. Executing a (Theoretical) Karel Program
Turn the Controller on
Read in the program, including each word and punctuation mark (the indentation is only for our benefit — the Controller doesn’t hear it) — BUT CASE MATTERS!!!
The Controller memorizes the program
We set up the initial situation (walls and beepers)
Push Controller’s “execute-program” button

64. Executing a Karel program
The Controller executes the program
Finds the main method
Sequentially executes each instruction in the main method, in strict top to bottom order
The Controller continues executing instructions until all robots either execute turnOff methods or someone performs an error shutoff

65. Simulating a Robot Program
Simulating a robot program means that we execute the program exactly as the Controller would have, recording each action that takes place
We can hand-simulate a robot program on paper
We can use a computer simulator
The ability to simulate robot behavior is an important skill we must acquire.

66. Simulating our Programe s 5 4 3 2 1 1 2 3 4 5
Avenues
0 beepers in bag
After Constructor Is Called

67. Simulating our Program (1)2 3 4 5 S t r e s
main {
BasicRobot bill =
new BasicRobot(2, 2, East, 0);
bill.move;
bill.pickBeeper;
bill.turnLeft;
bill.putBeeper;
bill.turnOff; } 1 2 3 4 5
Avenues
0 beepers in bag

68. Simulating our Program (2)e s 5 4 3 2 1 1 2 3 4 5
Avenues
0 beepers in bag

69. Simulating our Program (3)e s 5 4 3 2 1 1 2 3 4 5
Avenues
1 beeper in bag

70. Simulating our Program (4)e s 5 4 3 2 1 1 2 3 4 5
Avenues
1 beeper in bag

71. Simulating our Program (5)e s 5 4 3 2 1 1 2 3 4 5
Avenues
1 beeper in bag

72. Simulating our Program (6)e s 5 4 3 2 1 1 2 3 4 5
Avenues
1 beeper in bag

73. Simulating our Program (7)e s 5 4 3 2 1 1 2 3 4 5
Avenues
1 beeper in bag

74. Simulating our Program (8)e s 5 4 3 2 1 1 2 3 4 5
Avenues
0 beepers in bag

75. Simulating our Program (9)e s 5 4 3 2 1 1 2 3 4 5
Avenues
0 beepers in bag

76. Simulating our Program (10)e s 5 4 3 2 1 1 2 3 4 5
Avenues
0 beepers in bag
Final Situation
The program is verified.

77. The Form of Robot Programs
The Grammar Rules of Robot Programs
The Controller cares a lot about grammar and punctuation rules
The symbols the Controller understands are divided into three classes:
Punctuation Marks (the semicolon — ; )
Messages (we’ve seen those)
Reserved Words

78. Reserved Words
Used to structure and organize the primitive instructions in the robot language
We have already seen reserved words in our program — main and new
main {
BasicRobot bill = new BasicRobot(2, 2, East, 0);
bill.move;
bill.move; ...

79. Delimiters Matching pairs of { and } are called delimiters
The first { tells the Controller where to start execution
The matching } marks the end of the instructions the Controller will execute, but it does not tell the Controller to stop execution — the final message turnOff does that
If the Controller reaches the final }, and not all robots have received turnOff messages, then the Controller executes an error shutoff (the wrong way to finish executing a program)

80. Semicolons Semicolons terminate messages (instructions) main {
BasicRobot bill = new BasicRobot(2, 2, East, 0);
bill.move;
bill.pickBeeper;
bill.turnLeft;
bill.putBeeper;
bill.turnOff; }

81. Indentation
Indentation makes programs easier to read, so get in the habit.
Delimiters and the part they delimit are indented

82. Error Shutoffs
Executing an error shutoff is equivalent to executing a turnOff; it is used rather than let a robot continue carrying out tasks after an unexpected situation arose.
Error shutoffs can occur after
a move message
a pickBeeper message
a putBeeper message

83. Error Shutoffs To avoid error shutoffs:
Send a robot a move message only when his path is clear
Send a robot a pickBeeper message only when he is on the same corner as at least one beeper
Send a robot a putBeeper only when his beeper-bag is not empty
Send a robot a turnOff message as the last instruction of the program

84. Programming Errors
Programming errors can be classified into four broad categories:
Lexical Errors
Syntactic Errors
Execution Errors
Intent Errors

85. Lexical Errors
A lexical error occurs whenever we read the Controller a word not in the vocabulary:
main {
BasicRobot bill = new BasicRobot(2, 2, East, 0);
bill.move;
bill.pickBeeper;
bill.turngqxLeft;
bill.putBeeper;
bill.turnOff; }
Lexical Error

86. Syntactic Errors
A syntactic error occurs when we use incorrect grammar or punctuation:
main
BasicRobot bill = new BasicRobot(2, 2, East, 0);
bill.move;
bill.pickBeeper;
bill.turnLeft;
bill.putBeeper;
bill.turnOff; }
Syntactic Error,
missing first {

87. Execution Errors
Execution errors occur when the Controller or a robot is unable to execute a method successfully and an error shutoff occurs:
main {
BasicRobot bill = new BasicRobot(2, 2, East, 0);
bill.move;
bill.pickBeeper;
bill.turnLeft;
bill.putBeeper; }
An Execution Error
will occur (no turnoff message)

88. Intent Errors
The worst of all. The robot successfully completes his program, but not his task.
An intent error may occur early in a program and lead to an execution error later on. Then, we must trace backward from the instruction that caused an error shutoff, to find the instruction that started the robot in the wrong direction.

89. Intent Error A simple intent error: main {
BasicRobot bill = new BasicRobot(2, 2, East, 0);
bill.move;
bill.pickBeeper;
bill.turnLeft;
bill.putBeeper;
bill.turnOff; }
The final move message was
forgotten; the task was not completed.

90. Bugs and Debugging All types of errors are known as “bugs”
Debugging means removing errors from a program
We’ll learn a lot about debugging…

91. An Example of Simulation
main {
BasicRobot scott = new BasicRobot(4, 2, West, 0);
scott.move;
scott.turnLeft;
scott.pickBeeper;
scott.turnOff; }
Initial Situation S t r e s 5 4 3 2 1 1 2 3 4 5
Avenues
Task is to find beeper, pick it up,
and turn himself off.
What happens? How do we fix it?

92. Another Example of Simulation8 7
Initial Situation 6 5 4 3 2 1 1 2 3 4 5 6 7 8
Task is to find beeper, pick it up, and bring robot back to starting position
(the paper retrieving task). How do we do it?