Chapter 3 Extending the Robot Programming Language The

Chapter 3 Extending the Robot Programming Language

§ The robot programming New Classes of Robots language permits the robot programmer to specify new classes of robots. § These class descriptions provide specifications of new robot instructions. § Karel-Werke will then use the class descriptions to create robots able to interpret the new messages.

§ Karel-Werke builds each robot Dictionary-Like with a dictionary of useful method names and their definitions. § Each definition must be built from simpler instructions that robots already understand. § By doing this, we can build a robot vocabulary that corresponds more closely to our own. § Given this, we can solve our programming problems using whatever instructions are natural to our way of thinking, and then we can provide robots with the definitions of these instructions.

§ Task: Have the robot walk five miles Example (eight blocks = 1 mile). § Old way: karel. move(); karel. move(); // etc //(should have 40 instructions)

§ Better way: § Define a move. Mile instruction as eight move instructions. § Then call move. Mile 5 times. Example § Both programs move the robot the same distance, but the second program will be much easier to read and understand. § In complicated programs, the ability to extend a robot’s vocabulary makes the difference between understandable programs and unintelligible ones.

§To build a new class of robots, we include a class specification in a new file of our program. §The general form of this Defining New Classes of Robots specification: public class <new-class-name> extends <old-class-name> { <list-of-new-methods> }

§ Reserved Words and symbols: Specification Details § public § class § extends § braces { } § We must replace the elements in angle brackets < > appropriately. <new-class-name>what do we call this new type of robot? <old-class-name>what old robot is used to add features to? <list-of-new-methods> list of instructions

public void <instructionname> ( ) This is a { “block” <list-of-instructions> of code } Defining New Methods §The instruction name should specify what the method is intended to do. §The list of instructions should accomplish what its name implies.

Defining a Mile. Walker Robot public class Mile. Walker extends Robot { public void move. Mile() { move(); move(); } // on two lines due to lack of space // any other methods that need to be // defined would follow }

§We indicate the Mile. Walker inherits all the capabilities of the Robot class § in other words Mile. Walker Public class Mile. Walker extends Ur. Robot knows all about move(), turn. Left(), pick. Beeper(), put. Beeper(), and turn. Off() §Robot is the base class of Mile. Walker §Mile. Walker is a derived class of Robot §IS-A relationship § Mile. Walker IS A Robot

Mile. Walker. java public class Mile. Walker extends Robot name // note the capital letters for the class { public void move. Mile() { move(); // one line to conserve space move(); } // note the robot name is not used } Mile. Walker. Runner. java task() { Mile. Walker lisa = new Mile. Walker (3, 2, East, 0); // declare a Mile. Walker robot lisa. move. Mile(); // call the new method lisa. pick. Beeper(); // call an old method lisa. turn. Left(); lisa. move(); lisa. pick. Beeper(); lisa. move. Mile(); lisa. turn. Off(); }

§ Remember: A robot is a machine. It has no intelligence. § The robot does not The Meaning and Correctness of New Methods understand what we “mean” when we write a program. § It does exactly what we tell it to. § If we code only 6 move instructions for a mile instead of 8, the robot does not know that we made an error.

Task: Before After § Karel needs to climb the stairs and sweep the beepers off. § What will be the name of our class of robot? § Stair. Sweeper § What new methods will we need to define? § turn. Right() and climb. Stair()

§ We use at least two files in creating new robots and robot methods § The main class file which is where Robot Program Format the robot is constructed and given its task. We will call it Stair. Sweeper. Runner. Java § The main class is defined, the world is accessed, the speed is set § The robot is constructed and receives its task instructions in the task() method § The second file contains the description of the new robot, and the definition of its methods. We will call it Stair. Sweeper. Java § A constructor which describes how we build the robot § And the definitions of the new instructions

Main Class: Stair. Climber. Runner. java public class Stair. Climber. Runner implements Directions { public static void task() { Stair. Sweeper karel = new Stair. Sweeper(1, 1, East, 0); karel. climb. Stair(); karel. pick. Beeper(); // other instructions karel. turn. Off(); } // Main entry point public static void main(String[] args) { World. set. Delay(50); World. read. World("stairs. txt"); World. set. Visible(); task(); } }

public class Stair. Sweeper. Runner implements Directions { // details of the class specification here } § Name of class will be same as the Class Header name of the file, with a. java suffix § This class is contained in the file Stair. Sweeper. Runner. java § Capitalization counts § Directions is an interface that is is implemented by Stair. Sweeper. Runner § In other words Stair. Sweeper. Runner fleshes out the details of Directions § Directions has information that a robot needs to navigate in its world § Main has the remaining details specific to the particular task the robot has to perform

Entry Point // Main entry point public static public void Main(String[] args) { World. set. Delay(20); World. read. World("stairs. txt"); World. set. Visible(); task(); } § Every robot application needs to start somewhere, and they will always start with main() in this way § void is a return-type; we will discuss later § We set up the robot world from a data file (has locations of walls, beepers) § We ask the robot to perform the task § There is only one main() in every Java application

public static void task() { Stair. Sweeper karel = new Stair. Sweeper(1, 1, East, 0); karel. climb. Stair(); karel. pick. Beeper(); // other instructions karel. turn. Off(); } The task §We construct the robot by giving it a name and specifying location, direction it is facing, and number of beepers it is carrying. §We then provide the set of instructions to the robot.

Stair. Sweeper Class: Stair. Sweeper. java public class Stair. Sweeper extends Robot { // constructor public Stair. Sweeper(int street, int avenue, Direction direction, int howmany) { super(street, avenue, direction, howmany); } //methods public void turn. Right() { turn. Left(); } public void climb. Stair() { turn. Left(); move(); turn. Right(); move(); } }

Class header: Stair. Sweeper public class Stair. Sweeper extends Robot { } § Name of class will be same as the name of the file, with a. java suffix § This class is specified in the file Stair. Sweeper. java § The Stair. Sweeper robot inherits information and extends the capabilities of the Robot robot § Everything a Robot can do, a Stair. Sweeper can do § move(), turn. Left(), pick. Beeper(), put. Beeper(), turn. Off() § But a Stair. Sweeper will be able to do more (have more features)

Constructing a new robot public Stair. Sweeper(int street, int avenue, int direction, int how. Many) { super(street, avenue, direction, how. Many); } §This specifies how a robot is to be constructed § Go back and look at the task() § The instruction new Stair. Sweeper(1, 1, 0, 0); is using this method, known as a constructor. § We are specifying location, direction, and number of beepers § A constructor has the same name as the class. § The super keyword is indicating that this object is to be built the same way as its parent, Robot. § Our robot constructors will always look like this at the beginning.

New robot methods § public is a modifier letting us know that we can access this method from outside the class (in task() for example) § Notice that climb. Stair() can use turn. Right() as part of its definition § The method headers are known as signatures § The signatures of a class are known as the class interface public void turn. Right() { turn. Left(); } public void climb. Stair() { turn. Left(); move(); turn. Right(); move(); }

Problem Solving Process: 1. Definition of the Designing and Writing Programs Problem 2. Planning the Solution 3. Implementing the Plan 4. Analyzing the Solution

§ The initial definition of the 1. Definition of the Problem problem is presented when we are provided figures of the initial and final situations. § The problem must be understood completely before beginning to write a program.

2. Planning the Solution Step-Wise Refinement 1. Write the main task block using any robots and instruction names that seem appropriate. 2. Write the definitions of the new instruction names used. 3. Assemble these separate pieces into a complete program.

3. Implementing the Plan §Write the code.

4. Analyzing the Solution §Did the robot complete the problem correctly as given?

Task: Climb Stairs and remove beepers §Did karel climb the stairs correctly? §Did karel remove all of the beepers?

§ It is useful to divide a Advantages of Using New Instructions program into a small set of instructions, even if those instructions are executed only once. § New instructions nicely structure programs, and English words and phrases make programs more understandable; they help convey the intent of the program.

Plan ning m and inte istakes nt e § The (exe r r o cuti se h r s ) : on appe prog n r out p am with when w out a e wr lan. ite a w § Thi e l l thou s ca n ghtprog was te a ram m lot o § Usu ing t f ime. ally Avoiding Errors large segdifficult to have men fix b ecau t s to be o f se the p § Car m o difie rogr eful d am p anal or d lann isca y i rded avoi sis of th ng and t. d pla e pla horo u nnin n g mi can he gh stak es. lp us

Programming mistakes (lexical and syntax errors): § These happen when the program is actually written. § They can be spelling, punctuation, or other similar errors. Avoiding Errors § If we write the entire program without testing it, we will probably have many errors to correct, some of which may be multiple instances of the same mistake. § Writing the program in pieces will both reduce the overall number of errors introduced at any one time and may prevent multiple occurrences of the same mistake.

§ The robot’s world can be readily Future Modifications changed and we must be able to modify existing programs to keep the robot out of trouble. § It can be much simpler and takes less time to modify an existing program to perform a slightly different task than to write a completely new one.

§ Suppose we wanted climb to New Stair. Climber climb 6 stairs instead of 3? How would the program get modified? § Suppose there were 2 beepers on each stair instead of 1? How would the program get modified?

§ Good programmers are Writing Understandable Programs distinguished from bad ones by their ability to write clear and concise programs that someone else can read and quickly understand. § What makes a program easy to understand?

§ A good program is the simple Writing Understandable Programs composition of easily understandable parts. § Each part of the programs we just wrote can be understood by itself. § Even without a detailed understanding of the parts, the plans that the programs use to accomplish their respective tasks are easy to understand.

§ Dividing a program (or large Writing Understandable Programs instruction definition) into small, easy to understand pieces is not enough. § We must also make sure to name our new instructions properly. § These names provide a description of what the instruction does.

§ When writing a program, we New Instructions should hand simulate each instruction immediately after it is written, until we are convinced that it is correct. Then we can forget how it works and just remember what it does. § If new instructions are added to a program one at a time, debugging will be easy. The bug will have to lie with the new instruction. § A good rule of thumb is that definitions should rarely exceed five to ten instructions. If it exceeds this limit, then divide it into a set of smaller instructions.

§ If a new instruction can only be executed New Instructions correctly in a certain situations, then we should include comments in the definition explaining what those conditions are. § Example: An instruction that always picks up a beeper should indicate in a comment where that beeper must appear.

public void step. And. Fetch. It() // requires a beeper on the next corner in front Example { move(); pick. Beeper(); }

1. 3. 12 Problems p. 27(p 59) move. Mile(); move. Backward(); move. Kilo. Mile(); 2. Pin Setter 3. Harvest 4. Baseball game 5. Send greetings 6. #5 with five robots 7. #5 with five robots on streets 8. # 5 with seventeen robots on avenues 9. Display time 10. #9 with two robots 11. Gardening