Controlling Karel

Jed Rembold & Fred Agbo

January 22, 2024

Announcements

Problem Set 1 is posted and due on Monday night, 29 January
Sections start hopefully this week. If you have not yet filled out your availability, please do that now here!
Polling starts today! Use this link
- I don’t need your full official name, but include enough that I can identify you!
- The multiple choice options will not show until I start the poll.

Commands

As we mentioned before, Karel is a simple robot, and can really only do 4 potential actions

Command	Action
`move()`	Moves Karel forward one corner in whatever direction they are facing
`turn_left()`	Rotates Karel 90 deg counter-clockwise
`pick_beeper()`	Picks up a beeper on the ground
`put_beeper()`	Places a beeper on the ground

Our commands are just sequences of these actions

Example

Suppose we had the situation to the right and wanted to navigate to the beeper, pick it up, and then drop it at the corner of 1st avenue and 1st street.
Take a moment to write out your instructions.
- Remember you can only move, rotate left, and pick up or drop the beeper
Note that there are multiple ways to do this! Which is better?

One Solution

def main():
    move()
    turn_left()
    turn_left()
    turn_left()
    move()
    turn_left()
    move()
    turn_left()
    turn_left()
    turn_left()
    move()
    pick_beeper()
    turn_left()
    turn_left()
    turn_left()
    move()
    move()
    put_beeper()

Review Question

Suppose you had Karel starting in the world shown to the right. If Karel then executed the commands shown to the far right, what intersection would they end up at?

move()
turn_left()
turn_left()
move()
move()
turn_left()
turn_left()
turn_left()
move()

2nd avenue and 1st street
4th avenue and 2nd street
3rd avenue and 4th street
Karel would hit a wall and error

Watching Karel Work

In Python, we can run Karel programs by including import karel near the top of the program
- The file karel.py also needs to be in the same directory as your program

Karel Interface

Functional Programs

Recall that we had to execute 3 left turns whenever we wanted to turn right
Functions give us a way to “bundle-up” this code in a form that is easier to use!
- This is largely a convenience
- Especially useful when the same sequence of commands is used repeatedly
Using functions takes place in two parts:

Where you define what is in the bundle

Syntactically, it looks like:

def your_function_name():
    any_commands_to_be_bundled

Note that bundled commands need to be tabbed in!

Where you use the earlier defined bundle (the function)
Commonly referred to as calling the function
Use matched parentheses after the function name:
```
your_function_name()
```

Turn Right Round

We can define a convenience function to turn right!

def turn_right():
    turn_left()
    turn_left()
    turn_left()

Then we can just type turn_right() whenever we want to turn right
Internally, this is no different from what we had before (Karel still turns left 3 times), it is just easier to read and write

def main():
    turn_left()
    turn_left()
    turn_left()
    move()
    turn_left()
    move()
    move()
    turn_left()
    turn_left()
    turn_left()
    move()
    pick_beeper()
    turn_left()
    turn_left()
    turn_left()
    move()
    move()
    put_beeper()

Turn Right Round

We can define a convenience function to turn right!

def turn_right():
    turn_left()
    turn_left()
    turn_left()

Then we can just type turn_right() whenever we want to turn right
Internally, this is no different from what we had before (Karel still turns left 3 times), it is just easier to read and write

def main():
    turn_right()
    move()
    turn_left()
    move()
    move()
    turn_right()
    move()
    pick_beeper()
    turn_right()
    move()
    move()
    put_beeper()

def turn_right():
    turn_left()
    turn_left()
    turn_left()

Pothole Decomposition

Functions can also be a very effective way to break a larger problem into smaller, more managable pieces
Suppose we wanted Karel to fill all the “holes” in the below world with a beeper

Breaking down Potholes

From a big picture perspective, we might break this down something like:
- Moving between potholes
- Filling a pothole
Wherever one of those actions is simple and routine enough to write a function, we probably should!
- Moving between potholes: this is not currently routine as the amount we need to move changes
- Filling a pothole: this would be the same every time!

def main():
    move()
    fill_pothole()
    move()
    move()
    fill_pothole()
    move()

def fill_pothole():
    turn_right()
    move()
    put_beeper()
    turn_around()
    move()
    turn_right()

def turn_right():
    turn_left()
    turn_left()
    turn_left()

def turn_around():
    turn_left()
    turn_left()

A Quick Comment

It is always a good idea to document and leave notes to yourself (or future readers of your code)
Comments are pieces of text in your program that are ignored when the program is run
Python has two methods to make a comment:
- Hashtag method: Everything following a hashtag (#) on the same line is ignored
```
# This is a short comment!
```
  - Commonly used to make quick explanatory or labeling comments
- Triple quote method: Every inside triple quotes (“““) is ignored
```
""" This is also a comment! """
```
  - Commonly used to describe what functions do
  - Can span multiple lines

Commenting Example

def main():
    """
    Main function to fill 2 potholes 
    at known locations.
    """
    move()
    fill_pothole()
    move()
    move()
    fill_pothole()
    move()

def fill_pothole():
    """
    Fills a single pothole and returns 
    to where it started. 
    """
    turn_right()
    move()
    put_beeper() #assuming infinite beepers available
    turn_around()
    move()
    turn_right()

def turn_right():
    """ Turns Karel 90 to the right. """
    turn_left()
    turn_left()
    turn_left()

def turn_around():
    """ Convenience function to turn Karel 180 around. """
    turn_left()
    turn_left()

Making Choices

To solve more interesting tasks, we need to be able to write programs that can make choices about what they should be doing
Commands that alter the order that a program will run its commands are called control statements, which come in two flavors:
- Conditional statements: Only run portions of the program if a condition is true
- Iterative statements: Repeat portions of the program if certain conditions are met
Conditions are answers to yes or no (or true/false) type questions
- Am I facing a wall?
- Do I have any beepers in my bag?
You can ask these questions of Karel using what are called predicate functions, which are the programming equivalent of yes-or-no questions

Interrogating Karel

Potential questions you can ask Karel include:

`front_is_clear()`	`front_is_blocked()`
`left_is_clear()`	`left_is_blocked()`
`right_is_clear()`	`right_is_blocked()`
`beepers_present()`	`no_beepers_present()`
`beepers_in_bag()`	`no_beepers_in_bag()`
`facing_north()`	`not_facing_north()`
`facing_south()`	`not_facing_south()`
`facing_east()`	`not_facing_east()`
`facing_west()`	`not_facing_west()`

Kinda Iffy

Predicate functions can be used to control a kind of “switch”: running one piece of code if the answer is yes and a different piece of code if the answer is no.

Commonly called if or if-else statements, they take on the syntax of:

if conditional_test:
    # Code to run if test answer is yes
else:
    # Code to run if test answer is no

If you don’t want the code to do anything special if the answer is no, you can ignore the “else” part of the statement:
```
if conditional_test:
    # Code to run if test is true
# Carrying on with code that will always run
```

Karel’s Decisions Example

Suppose we want Karel to move across the bottom of the world and fill in any gaps in the beepers
- We want an even layer of beepers, no stacks
- What questions should we have Karel ask?

Its been a while

Another common use of predicate functions is in controlling a type of iterative function called a while loop

The structure of a while loop looks like:

while some_conditional_test:
    # Code to repeat as long as the answer
    # to the conditional_test is yes (true)
# Code to run once the answer is no

All of our predicate functions give yes-or-no answers though! So we can do something like
```
while front_is_clear():
    move()
```
which will continually move Karel forward as long as there is not a wall in front of them!

Smarty Karel

Combining conditional statements with loops lets us write a program for Karel in which it can react to different situations in different ways, all using the same code
Our pothole code from earlier could only handle two potholes, and they had to be perfectly spaced
With one loop and one if statement, we can make the program fill any number of potholes with any manner of spacing!
Key questions:
- How do we know when we are done?
- How do we know when we reach a pothole?

Smart Potholes

def main():
    """
    Main function to fill any number of
    potholes at any location!
    """
    while front_is_clear():
        if right_is_clear():
            fill_pothole()
        move()

def fill_pothole():
    """
    Fills a single pothole and returns 
    to where it started. 
    """
    turn_right()
    move()
    put_beeper() #assuming infinite beepers available
    turn_around()
    move()
    turn_right()

def turn_right():
    """ Turns Karel 90 deg to the right. """
    turn_left()
    turn_left()
    turn_left()

def turn_around():
    """ Turns Karel 180 deg around. """
    turn_left()
    turn_left()