Mini-Lab: Staying in Bounds and Adding Color

This set of Mini-Lab Exercises is the second in a series in which students build a small program with several fish moving around in an aquarium. The set includes the following exercises:

• Watch Out!   (Patterns: Whether or Not and Positive Condition)
• One Fish, Two Fish, Red Fish, Blue Fish (Pattern: Alternative Action)
• Rainbow Fish   (Pattern: Sequential Choice)

Each section contains an Introduction to a problem or task, (usually) abridged versions of one or more Patterns that will be useful in solving the problem or completing the task, and an Exercise.

In the exercises that precede this one, students will have created three fish, moved them forward one space, and displayed them graphically. Therefore, students should be familiar with constructing objects, using variables, and invoking methods. Some familiarity with logical expressions is also required, since the Selection Patterns use conditions.

Students should read over the patterns that appear in this document before the lab.

Watch Out!

Introduction

Pattern: Whether or Not (Selection) -- Abridged

You are in a situation in which some action may be appropriate or inappropriate depending on some testable condition. There are no other actions to do instead of this one. You don't need to repeat the action, only to decide whether or not it should be done.

Therefore, use an IF statement without an ELSE part, expressing the test as a Positive Condition if possible.

 if (<condition>)
        <action>

Note: Conditions are sometimes called guards. The condition guards the command and only permits it to be executed when the guard is true.

For example: in a power plant simulation, it may be necessary to shut down a generator when it overheats.

if (measuredHeat() > subBoilThreshold)
{       shutDownGenerator();
}

This selection pattern and others are described more fully in the complete Selection Pattern document.

---

Pattern: Positive Condition (Auxiliary)

You are applying Selection or Repetition and are wondering how to express the condition. If you are applying the Alternative Action Selection pattern, you are also determining how to lay out the actions in the IF-ELSE statement.

Most people can read a positive statement more effectively than a negative one. You want your code to be as readable as possible.

Therefore, when writing conditions, express them positively whenever possible.

For example, suppose you have a robot simulation in which the robot must move but must also contend with obstructions in the path. Suppose you have a boolean test as a primitive in a robot language:

boolean frontIsBlocked();

Suppose that you want to move if possible, but turn Left instead if it is impossible to move forward. The following are equivalent:

if (frontIsBlocked()) 
        turnLeft();
else
        move();


if ( ! frontIsBlocked())
        move();
else
        turnLeft();

The first version is more readable and is preferred. It expresses a positive condition.

One Fish, Two Fish, Red Fish, Blue Fish

Introduction

Pattern: Alternative Action (Selection) -- Abridged

You are in a situation in which one of exactly two actions is appropriate depending on some testable condition, which may be true or false. When the condition holds you want to do one action, and when it does not hold you want to do some different action.

Therefore, use a single IF statement with an ELSE part, expressing the test as a Positive Condition if possible.

 if (<condition>)
        <one action>
 else
       <another action>

For example a student may pass or fail an exam depending on the value of the numeric grade.

if ( numericGrade > 60 )
{       output ("passing");
}
else
{       output("failing");
}

If you try to apply Whether or Not (twice) to this case you will find yourself needing to write the negation of the condition.

if ( numericGrade > 60 )
{       output ("passing");
}
if ( numericGrade <= 60)
{       output("failing");
}

This is both wasteful of computer time and very error prone. If the problem changes a bit in the future and you change one of the conditions, it is easy to forget to change the other. Alternative Action makes it unnecessary to repeat the condition for the else part.

This selection pattern and others are described more fully in the complete Selection Pattern document.

Rainbow Fish

Introduction

Pattern: Sequential Choice (Selection) -- Abridged

You are in a situation in which you need to choose exactly one of several possible actions. Each action is guarded by a separate condition, and after you find one condition true you want to execute its associated action and at that point you want to finish.

You want the code layout to be pleasing to both the eye and the mind. You want a structure that is easy to read and understand.

Therefore, write a sequence of IF's, where each IF but the last has an ELSE part that consists entirely of another IF. For example,

int participants = myParty.size();
if (participants > 15000)
{       rentTheSuperdome();
}
else if (participants > 1500)
{       rentTheCivicCenter();
}
else if (participants > 150)
{       rentATent();
}
else
{       rentAMovie(); // default case, no party at all. 
}

The formatting, with else and if on the same line, makes it clear that this is a Sequential Choice and not a sequence of independent Whether or Not applications. Do not indent the subsequent else parts or it will look like Independent Choice (see the complete Selection Pattern) and you will also give up valuable horizontal real estate. Some languages have a special keyword (elsif) to handle this case.