## Sequence, Selection and Loop Structures

Learn about structured programming, the sequence structure, the selection structure, the loop structure, and composite structures such as the multiple-choice structure.

Published:  April 7, 2007
Last Updated:  August 27, 2007
By Richard G. Baldwin

Alice Programming Notes # 165

## Preface

This tutorial lesson is part of a series designed to teach you how to program using the Alice programming environment under the assumption that you have no prior programming knowledge or experience.

Have some fun

Because Alice is an interactive graphic 3D programming environment, it is not only useful for learning how to program, Alice makes learning to program fun.  Therefore, you should be sure to explore the many possibilities for being creative provided by Alice while you are learning to program using these tutorials.  And above all, have fun in the process of learning.

### General

In the previous lesson titled "Expressions and Operators" (see Resources), I taught you about expressions, arithmetic operators, and equality operators.

In this lesson, I will teach you about:

• Structured programming.
• The sequence structure.
• The selection structure.
• The loop structure.
• Composite structures such as the multiple-choice structure.

### Viewing tip

I recommend that you open another copy of this document in a separate browser window and use the following links to easily find and view the figures and listings while you are reading about them.

#### Figures

• Figure 1. The sequence structure in pseudocode.
• Figure 2. The selection structure in pseudocode.
• Figure 3. The loop structure in pseudocode.
• Figure 4. User input dialog for program named Alice0165a.
• Figure 5. Program output for even input in program named Alice0165a.
• Figure 6. Program output for odd input in program named Alice0165a.
• Figure 7. Skeleton code for a selection structure.
• Figure 8. Program output for even input to program name Alice0165b.
• Figure 9. Program output for odd input to program named Alice0165b.
• Figure 10. Skeleton code for a loop structure.
• Figure 11. User input dialog for program named Alice0165c.
• Figure 12. Typical output for input in the range of 1 through 3 inclusive for program Alice0165c.
• Figure 13. Output for input outside the range of 1 through 3 inclusive for program Alice0165c.

#### Listings

• Listing 1. Source code for the program named Alice0165a.
• Listing 2. Source code for the program named Alice0165b.
• Listing 3. Source code for the program Alice0165c.

### Supplementary material

Once you have mastered Alice, I recommend that you also study the other lessons in my extensive collection of online programming tutorials.  You will find a consolidated index at www.DickBaldwin.com.

## General background information

In introductory programming courses, you will often hear a lot about something called structured programming.  While I don't claim to be an expert in that area, in comparison with more modern and complex programming concepts such as runtime polymorphism, structured programming seems to be fairly mundane.

However, that's not to say that structured programming isn't important.  It is very important.  But it is just a small bump in the road of learning that leads to an understanding of object-oriented programming.

So, what is structured programming?

Basically, the concept of structured programming says that any programming logic problem can be solved using an appropriate combination of only three programming structures, none of which are complicated.  The three structures are known generally as:

• The sequence structure.
• The selection or decision structure.
• The loop, repetition, or iteration structure.

One door in and one door out

To understand structured programming, you need to think in terms of a section of program code that has only one entry point and one exit point.  It is very important that there cannot be multiple entry points or multiple exit points.

There must be only one way into the section of code and one way out of the section of code.

Nesting of structures is allowed

Another important part of the concept is that structures may be nested inside of other structures provided that every structure meets the basic rules for a structure.

Thus, by nesting simple structures inside of simple structures, large and complex overall structures can be constructed.

 Pseudocode Pseudocode is an outline of a program, written in a form that can easily be converted into real programming statements.

The sequence structure

We have been using the sequence structure since early in the course.  Basically we can describe the sequence structure using the pseudocode shown in Figure 1.

Figure 1. The sequence structure in pseudocode.
 ```Enter Perform one or more actions in sequence Exit ```

Thus, the general requirement for the sequence structure is that one or more actions may be performed in sequence after entry and before exit.

There may not be any branches or loops between the entry and the exit.

All actions must be taken in sequence.

The action elements themselves may be structures

However, it is important to note that one or more of the action elements may themselves be sequence, selection, or loop structures.

If each of the structures that make up the sequence has only one entry point and one exit point, each such structure can be viewed as a single action element in a sequence of actions.

Obviously, the sequence structure is the simplest of the three.

The selection structure

The selection or decision structure can be described as shown in the pseudocode in Figure 2.

Figure 2. The selection structure in pseudocode.
 ```Enter Test a condition for true or false On true Take one or more actions in sequence On false Take none, one, or more actions in sequence Exit ```

Test a condition for true or false

Once again, there is only one entry point and one exit point.

The first thing that happens following entry is that some condition is tested for true or false.

If the condition is true, one or more actions are taken in sequence and control exits the structure.

If the condition is false, none, one or more different actions are taken in sequence and control exits the structure.  (Note the inclusion of the word none here.)

The action elements may themselves be structures

Once again, each of the action elements in the sequence may be another sequence, selection, or loop structure.

Eventually all of the actions for a chosen branch will be completed in sequence and control will exit the structure.

Sometimes no action is required on false

It is often the case that no action is required when the test returns false.  In that case, control simply exits the structure without performing any actions.

The loop structure

The loop or iteration structure can be described as shown in the pseudocode in Figure 3.

Figure 3. The loop structure in pseudocode.
 ```Enter Test a condition for true or false Exit on false On true Perform one or more actions in sequence. Go back and test the condition again ```

As before, there is only one entry point and one exit point.

Perform the test and exit on false

The first thing that happens following entry is that a condition is tested for true or false.

If the test returns false, control simply exits the structure without taking any action at all.

Perform some actions and repeat the test on true

If the test returns true:

• One or more actions are performed in sequence.
• The condition is tested again.

During each iteration, if the test returns false, control exits the structure.  If the test returns true, the entire cycle is repeated.

Each action element may be another structure

Each of the action elements may be implemented by another sequence, selection, or loop structure.

Eventually all of the actions will be completed and the condition will be tested again.

Need to avoid infinite loops

Generally speaking, unless something is done in one of the actions to cause the test to eventually return false, control will never exit the loop.

In this case, the program will be caught in what is commonly referred to as an infinite loop.

Other possible structures

In some programming languages, there are a couple of structures other than sequence, selection, and loop that structured-programming experts are willing to accept for convenience:

• The switch-case structure.
• The do-until structure.

These structures are not required for the solution of programming logic problems.  Also, they are not support by Alice 2.0, so you won't learn about them in this series of tutorial lessons on Alice.

## Preview

In this lesson, I will present and explain three simple programs.  (You may download executable versions of the programs through Resources.)  The first program, named Alice0165a is designed to teach you about sequence and selection structures.

The second program named Alice0165b is designed to teach you about the loop structure.

The third program named Alice0165c is designed to teach you about the multiple choice composite structure.

## Discussion and sample code

### The sequence structure

Almost all of the sample programs that I have presented in the earlier lessons in this series of tutorials have been constructed using the sequence structure.  Therefore, I won't provide another sample program to illustrate that structure alone.  I will simply refer you back to earlier lessons for numerous sample programs.

The sample programs in this lesson will combine the sequence structure with the selection structure and the loop structure.

### The selection structure

The program named Alice0165a illustrates the use of a selection structure as one of the elements in a sequence structure.

The user is asked to enter an integer as shown in Figure 4.

Figure 4. User input dialog for program named Alice0165a.

Making a decision

The selection structure uses the value of the integer provided by the user to make a decision.

The decision is used to display one or the other of two different messages.  The decision is made on the basis of whether the user input is even or odd.

The program output for even input

Figure 5 shows the output produced by the program when the user enters an even integer value.

Figure 5. Program output for even input in program named Alice0165a.

The program output for odd input

Figure 6 shows the output produced by the program when the user enters an odd integer value.

Figure 6. Program output for odd input in program named Alice0165a.

Creating a selection structure in Alice

To create a selection structure in Alice, begin by dragging the if tile from the bottom of the Alice development screen and dropping it at the appropriate location in the edit pane.  You will be required to select a placeholder value of true or false.  This will result in the skeleton code shown in Figure 7 being inserted into the edit pane.

Figure 7. Skeleton code for a selection structure.

The conditional clause

The placeholder value (true in Figure 7) and the parentheses that surround it in the skeleton code is often called the conditional clause.  Once the skeleton appears in your code, you can replace the placeholder value with any expression that will evaluate to a value of type Boolean.

The expression that you place in the conditional clause is the expression that will be evaluated to determine which part of the selection structure to execute.  If the expression in the conditional clause evaluates to true, the code between the curly braces before the else clause will be executed.  If the expression in the conditional clause evaluates to false, the code in the body of the else clause will be executed.

Omitting the else clause

In languages such as Java, C++, and C#, if you don't need the else clause, you can simply omit it.  However, it will always be there in Alice.  You cannot omit it.  If you don't need it, just don't put any code into it, and it will be essentially ignored at runtime.

Source code for the program named Alice0165a

The source code for the program named Alice0165a is presented in Listing 1 near the end of the lesson.  All of the code is contained in the main method.  You can also download an executable version of the program (see Resources).

Create and run the program

To create and run this program, either download the executable version (see Resources) or:

• Create a new world.
• Add a penguin to the world.
• Write the code shown in Listing 1.

Two variables

The code in Listing 1 declares the following two variables:

1. A variable named testResult of type Boolean.
2. A variable named userInputValue of type Number.

The initial values of the variables are immaterial because they are set to current values by program code when the program is run.

Code in the main method

The code in the main method consists of a sequence structure containing three actions:

1. A statement that calls the world method named NumberDialog to get input from the user and to store that input in the variable named userInputValue(See Figure 4.)
2. A statement that calls the world method named Math.IEEERemainder to compute the remainder after dividing the user input by 2.  This statement also tests the remainder to see if it is equal to 0.  (You learned about the == operator in the earlier lesson titled "Expressions and Operators".  See resources.)  The true or false result is stored in the Boolean variable named testResult.
3. A selection structure that uses the result of the test in the second action to determine whether to display the word Even or the word Odd.

 A bug in IEEERemainder function If you call the IEEERemainder function to get the remainder of 7/2, the value returned is -1, which is incorrect. If you call the IEEERemainder function to get the remainder of 8/3, the value returned is -1, which is incorrect. If you call the IEEERemainder function to get the remainder of 5/2, the value returned is 1, which is correct. Sometimes the function returns the correct answer and sometimes it returns the wrong answer. On the basis of a very limited amount of experimentation, it seems to return the correct answer for those cases where the correct answer is 0.

Program rationale

The rationale for the program is that the remainder produced by dividing an even integer by 2 will be zero, and the remainder produced by dividing an odd integer by 2 will not be zero.  Therefore, information about whether or not the value of the remainder is zero can be used to determine if the user input integer is even or odd.  That rationale is used in the selection structure to determine whether to display the word Even, as shown in Figure 5, or the word Odd as shown in Figure 6.

The selection structure

The behavior of the selection structure can be paraphrased as follows:

If the expression in the conditional clause evaluates to true, execute the statements inside the curly braces following the conditional clause.  Else (short for otherwise) execute the statements inside the curly braces following the word else.

In this program, if the value contained in the variable named testResult is the Boolean value true, the method named say is called on the penguin object to display the word Even above the penguin's head as shown in Figure 5.

If the value contained in the variable named testResult is the Boolean value false, the method named say is called on the penguin object to display the word Odd above the penguin's head as shown in Figure 6.

Program can be much longer

This simple program only contains one statement inside each of the two sets of curly braces in the selection structure.  In general, however, any sequence of actions of any length can be included inside the curly braces.  The sequence of actions may consist of a sequence of statements.  There may also be other selection and loop structures nested in that sequence of actions.

### The loop structure

If your program has a number of steps which must be executed multiple times, the most likely approach for accomplishing this is to use a repetition or loop structure.

This program, which is named Alice0165b illustrates the use of a loop structure as one of the elements in a sequence structure.

As in the previous program, the user is asked to enter an integer as shown in Figure 4.  If the user enters an even integer, the program displays the image shown in Figure 8 for two seconds, and then returns to the image shown in Figure 4 to ask the user to enter another integer.

Figure 8. Program output for even input to program name Alice0165b.

The process of displaying the image shown in Figure 8 for two seconds and then asking the user to enter another integer continues for as long as (while) the user continues entering even integer values.

Program output for odd integer

When the user enters an odd integer, the penguin speaks, turns, and walks away as shown in Figure 9.

Figure 9. Program output for odd input to program named Alice0165b.

When the penguin has walked 100 meters, (which takes a fairly long time because penguins walk very slowly), the program terminates.

Creating a skeleton while loop in Alice

To create a while loop structure in Alice, begin by dragging the while tile (not the loop tile) from the bottom of the Alice development screen and dropping it at the appropriate location in the edit pane.  (I will have more to say about the loop tile later.)  As with the selection structure, you will be required to select a placeholder value of true or false.  This will result in the skeleton code shown in Figure 10 being inserted into the edit pane.

Figure 10. Skeleton code for a loop structure.

The conditional clause

As with a selection structure discussed earlier, a loop structure has a conditional clause.  The placeholder value (true in Figure 10) and the parentheses that surround it in the skeleton code constitute the conditional clause.  Once the skeleton for the loop structure appears in your code, you can replace the placeholder value with any expression that will evaluate to a value of type Boolean.

The expression that you place in the conditional clause is the expression that will be evaluated to determine if the code in the body of the loop structure (the code between the curly braces in Figure 10) will be executed one time, or if the loop structure will terminate.

If the expression in the conditional clause evaluates to true, the code in the body of the loop will be executed once.  If the expression in the conditional clause evaluates to false, the loop will terminate immediately causing the code in the body of the loop to be skipped and causing the next statement following the body of the loop to be executed.

Source code for the program named Alice0165b

The source code for the program named Alice0165b is presented in Listing 2 near the end of the lesson.  All of the code is contained in the main method.  You can also download an executable version of the program (see Resources).

To create and run this program, either download the executable version, or:

• Create a new world.
• Add a penguin to the world.
• Write the code shown in Listing 2.

Two variables

As was the case with the previous program, the code in Listing 2 declares the following two variables:

1. A variable named testResult of type Boolean.
2. A variable named userInputValue of type Number.

Once again, the initial values of the variables are immaterial because they are set to current values by program code when the program is run.

Code in the main method

The code in the main method consists of the following sequence of actions:

2. A while loop.
3. A doTogether block that is executed when the user enters an odd integer causing the loop to terminate.

Getting user input

This program uses the same code as the previous program to:

• Get an input integer from the user.
• Test to determine if it is even or odd.
• Set the value of the variable named testResult to true for even input and false for odd input.

This code appears at two different locations within the program.

 Iteration The term first iteration describes one pass through the loop structure including the test at the beginning and either one execution of the code in the body of the loop or the termination of the loop, whichever is dictated by the value of the expression in the conditional clause.

The code that appears before the beginning of the while loop in Listing 2 is commonly known as a priming read.  (This terminology comes from the concept of "priming the pump."  If you don't know about priming pumps, don't worry about it.  Knowing about pumps is not a requirement for learning how to program.)  The purpose of the priming read is to get the first input value (from the user in this case) before entering the loop so that the value can be used to determine the behavior of the loop during the first iteration.

The while loop

As described earlier, if the value of testResult is true, the code inside the body of the loop is executed once.  The code in the body of the loop in Listing 2 consists of two sequential actions:

1. Cause the penguin to display "Even, keep on looping" on the screen for two seconds.
2. Update the value of the variable named testResult by asking the user to enter another integer using the same code as before.

After the user enters another integer value and it is tested to produce and store a Boolean value, control goes back to the top of the loop where the value of testResult is tested for true or false again.

If the value of testResult is still true when the test is performed, the code in the body of the loop is executed one more time.  This looping process continues until the value of testResult becomes false, at which time the body of the loop is skipped, and the loop structure terminates.

Termination of the loop and the program

When the value of testResult is found to be false, the code in the body of the loop is skipped, the looping action ceases (the loop terminates) and the statements in the doTogether block following the while loop structure is executed.  (See Figure 9.)  You already know about code like this from previous lessons, so I won't explain it here.  When the code in the doTogether block finishes execution, the program terminates.  (In general, the loop will exit or terminate when the conditional clause evaluates to false.)

### A pre-test or entry-condition loop

There is another point that I need to make before leaving the topic of loops.  The loop structure in Listing 2 was implemented using a  while loop.  A while loop is  known as a pre-test or entry-condition loop.  This is because the conditional test is performed before the code in the body of the loop is executed.

If the test returns true, the code in the body of the loop is executed and the test is performed again.  When the test returns false, even if it is first time that the test is performed, the code in the body of the loop is skipped and control exits the loop structure.  Therefore, if the test returns false the first time that it is performed, the code in the body of the loop won't be executed.

### An exit-condition loop

Other programming languages such as Java, C++, and C# also have an exit-condition loop, known as a do-while loop.  The major significance of the exit-condition loop is that the code in the body of the loop will be executed at least once, even if the test returns false the first time that it is performed.  This is because the test is performed after the body of the loop has already executed once.  Alice does not have an exit-condition loop.

### A for loop

If you drag the loop tile (instead of the while tile) from the bottom of the Alice development screen and drop it into the edit pane, a different kind of loop will be created.  This kind of loop is commonly called a for loop.  I will explain in detail how to use a for loop in a future lesson.

In general, a for loop is also an entry-condition loop.  The code in the body of the loop will continue to execute for as long as the conditional clause evaluates to true.  There are no exit-condition loops in Alice.

### The if-else-if composite structure

A particularly important composite structure is the nested combination of several if-else structures to form a sort of multiple choice structure.

The if-else-if structure is illustrated by the program named Alice0165c.  A complete listing of the program is provided in Listing 3.  You can also download an executable version of the program (see Resources).

Ask the user to enter an integer

This program asks the user to enter an integer between 1 and 3 inclusive as shown in Figure 11.

Figure 11. User input dialog for program named Alice0165c.

Display a message regarding a valid input integer

Figure 12 shows typical program output for the case where the user input is in the range of 1 through 3 inclusive.  (The image in Figure 12 resulted from a user input value of 2.)

Figure 12. Typical output for input in the range of 1 through 3 inclusive for program Alice0165c.

Display an error message

The error message shown in Figure 13 is displayed if the integer value entered by the user is outside the range of 1 through 3 inclusive.

Figure 13. Output for input outside the range of 1 through 3 inclusive for program Alice0165c.

Source code for the program named Alice0165c

Please turn your attention to the source code shown in Listing 3.

None of the code in Listing 3 is new to you.  You have seen all of this code before in previous programs in this and earlier lessons.  The thing that is new about the code in Listing 3 is the organization of the code.

Although the user is requested to enter an integer value between 1 and 3 inclusive, she is free to enter any value she wishes to enter.  The value entered by the user is stored in the variable named userInputValue.

Nested selection structures

The program uses three nested selection structures to test the value stored in the variable named userInputValue and to display one of the following messages as a result:

1. Thanks for the 1.
2. Thanks for the 2.
3. Thanks for the 3.
4. User input error.

The choice of message to display depends on the value stored in the variable named userInputValue.  Perhaps this will illustrate why I sometimes refer to this kind of structure as a sort of multiple choice structure.  (See Figure 12 and Figure 13 for examples of two of the messages in the above list being displayed.)

Trace through the code

If you start tracing through the code at the first occurrence of the word if in Listing 3, you will see that the conditional clause contained in the first selection structure tests to determine if the value stored in the variable named userInputValue is equal to 1.  If so, the first message in the above list is displayed and control transfers to the next statement following the final curly brace in the light blue area in Listing 3.  However, since there is no statement following that curly brace, the program terminates at that point.

Value not equal to 1

If the value stored in the variable named userInputValue is not equal to 1, control transfers to the else clause belonging to that selection structure .  However, that else clause contains another selection structure beginning with the word if.  This time, the conditional clause tests to determine if the value stored in the variable named userInputValue is equal to 2.  If so, the second message in the above list is displayed and control transfers to the next statement following the final curly brace in the light blue area in Listing 3.

Value not equal to 2

If the value is not equal to 2, control transfers to the else clause of that selection structure, which contains another selection structure.  This time, the conditional clause tests to determine if the value stored in the variable named userInputValue is equal to 3.  If so, the third message in the above list is displayed and control transfers to the next statement following the final curly brace in the light blue area in Listing 3.

Value equal to 1, 2, or 3

Therefore, at each stage, if the expression in the conditional clause is true, the program displays one of the first three messages in the above list, and transfers control to the next statement following the final curly brace in the light blue area in Listing 3.

Value not equal to 3

If the conditional clause in the third stage is false, control transfers to the else clause of the third selection structure.  However, that else clause does not contain another selection structure.  Instead, the code in that else clause causes the penguin to display the fourth message in the above list(See Figure 13.)  Following that, control transfers to the next statement following the final curly brace in the light blue area in Listing 3.

 The switch structure Other languages such as Java, C++, and C# have a switch structure, which in some cases can make it easier to write the code for multiple-choice selections.  However, Alice doesn't have a switch structure so you will have to use this more cryptic format.

Study this structure carefully

You should study this structure until you understand it completely.  It will turn up again and again in the programs that you will write once you get serious about creating animation programs using Alice.

## Run the programs

Executable versions of the programs that I explained in this lesson are available for downloading (see Resources).  I encourage you to either download those programs, or copy the code from Listings 1 through 3  into your Alice development environment and play it.  Experiment with the code, making changes, and observing the results of your changes.

## Summary

In this lesson, I taught you about the following topics:

• Structured programming.
• The sequence structure.
• The selection structure.
• The loop structure.
• Composite structures such as the multiple-choice structure.

## What's next?

In future lessons, I will teach you about:

• Relational and logical operators
• Counter loops, nested loops, and sentinel loops
• Arrays and lists
• Events and event handling
• Saying, thinking, and playing sounds
• Recursion

So stay tuned.  There is lots of fun ahead.

## Lab project

Beginning with the program named Alice0165b, create a new program.

The behavior of the new program is the same as the behavior of the original program except that the program keeps looping for as long as the user enters odd integers.  (The behavior for even and odd is switched relative to the program named Alice165b.)

When the user enters an odd integer, the program displays an image similar to that shown in Figure 8 for two seconds.  (Cause the penguin to say "Odd, keep on looping.")  Then the program returns to the image shown in Figure 4 to ask the user to enter another integer.

When the user enters an even integer, the penguin speaks, turns, and walks away in a manner similar to that as shown in Figure 9.  (Cause the penguin to say "Even, I'm outa here.")

Save your world in a file named Alice165LabProjA.a2w and be prepared to deliver it to your instructor in whatever manner the instructor specifies.

Make certain that your preferences are set to Java Style in Color.

Select Export Code For Printing... on the File menu and save your source code in a file named Alice165LabProjA.html.  Also be prepared to deliver this file to your instructor in whatever manner the instructor specifies.

View a movie of the lab project

You can download and play a small, low-quality movie of my version of the lab project as it being executed from the Resume button (see Resources).  This movie was designed to give you a rough idea of how your program should behave.  The movie was purposely recorded in low-quality format in a small window in order to reduce the file size and hence reduce the download time.

Because of the low quality of the movie, the execution of your program should provide much smoother animation than the movie, and should be less grainy than the movie.  Also, because of the low quality of the movie, the timing in the movie doesn't necessarily match the duration times specified for the lab project.

The movie was terminated early when the penguin began to walk away rather than to waste bandwidth watching the penguin walk and walk.

I attempted to synchronize the beginning of the recording with the beginning of the program execution by starting, then quickly pausing, and then resuming the execution.  If you watch closely, when the movie starts running, you will see the mouse pointer click the Resume button, and the movie will show one complete pass through the program.

You should view this movie in its original size.  If you allow the media player to enlarge it, the quality will be poor.

## Resources

General resources

Resources from earlier lessons in the series titled "Learn to Program using Alice"

• 100 Getting Started
• 105 Setting the Stage
• 110 Objects in 3D Space
• 115 Setting the Stage Manually, Part 1
• 120 Setting the Stage Manually, Part 2
• 125 Your First Alice Program
• 130 The Program Development Cycle
• 135 Functions that return values
• 140 Data Types and Variables
• 145 World-Level Methods
• 150 Class-Level Methods and Inheritance
• 155 Syntax, Runtime, and Logic Errors
• 160 Expressions and Operators
• 900 Appendix A, Behavior of Primitive Methods

## Complete program listings

Complete listings of the programs discussed in this lesson are shown in Listing 1 through Listing 3 below.

Listing 1. Source code for the program named Alice0165a.

# Created by: Dick Baldwin

## world

### Methods

 public void main ( ) {     Boolean testResult = true ; Number userInputValue = 1 ; // Copyright 2007, R.G.Baldwin // Uses if-else to test a user input value for even or odd. // Get user input. userInputValue .set( value , ( NumberDialog( question = Enter an integer. ) ) ); // Compute remainder after dividing by 2 and return true // if remainder is equal to 0 testResult .set( value , ( ( Math.IEEERemainder( userInputValue , 2 ) ) == 0 ) ); // Execute the selection structure. if ( testResult ) { penguin .say( Even ); duration = 30 seconds } else { penguin .say( Odd ); duration = 30 seconds } }

Listing 2. Source code for the program named Alice0165b.

# Created by: Dick Baldwin

## world

### Methods

 public void main ( ) {     Boolean testResult = true ; Number userInputValue = 1 ; // Copyright 2007, R.G.Baldwin // Illustrates use of a "while" loop. // Program loops for as long as user keeps entering // even integers. Terminates on odd integer. // Perform a priming read. doInOrder { . . . . . } // Get user input. userInputValue .set( value , ( NumberDialog( question = Enter an integer. ) ) ); // Compute remainder after dividing by 2 and return true // if remainder is equal to 0 testResult .set( value , ( ( Math.IEEERemainder( userInputValue , 2 ) ) == 0 ) ); } // Execute a "while" loop. while ( testResult ) { . . . . } // Execute this code when testResult is true. penguin .say( Even, keep on looping. ); duration = 2 seconds // Update value of testResult. doInOrder { . . } userInputValue .set( value , ( NumberDialog( question = Enter an integer. ) ) ); testResult .set( value , ( ( Math.IEEERemainder( userInputValue , 2 ) ) == 0 ) ); } } // Execute this code when testResult is false. doTogether { . . . . } // Penguin speaks, turns, and walks away. penguin .say( Odd, I'm outa here. ); duration = 20 seconds penguin .turn( RIGHT , .375 revolutions ); penguin.walking ( x = 100 ); } }

Listing 3. Source code for the program Alice0165c.

# Created by: Dick Baldwin

## world

### Methods

 public void main ( ) {     Number userInputValue = 1 ; // Copyright 2007, R.G.Baldwin // Illustrates use of if-else-if structure. // Get user input. userInputValue .set( value , ( NumberDialog( question = Enter an integer between 1 and 3 inclusive ) ) ); // Execute the nested selection structure. if ( ( userInputValue == 1 ) ) { penguin .say( Thanks for the 1. ); duration = 30 seconds } else { if ( ( userInputValue == 2 ) ) { penguin .say( Thanks for the 2. ); duration = 30 seconds } else { if ( ( userInputValue == 3 ) ) { penguin .say( Thanks for the 3. ); duration = 30 seconds } else { // Code executed when userInputValue is // neither 1 nor 2 nor 3. penguin .say( User input error. ); duration = 30 seconds } } } }

Copyright 2007, Richard G. Baldwin.  Faculty and staff of public and private non-profit educational institutions are granted a license to reproduce and to use this material for purposes consistent with the teaching process.  This license does not extend to commercial ventures.  Otherwise, reproduction in whole or in part in any form or medium without express written permission from Richard Baldwin is prohibited.

Richard Baldwin is a college professor (at Austin Community College in Austin, TX) and private consultant whose primary focus is a combination of Java, C#, and XML. In addition to the many platform and/or language independent benefits of Java and C# applications, he believes that a combination of Java, C#, and XML will become the primary driving force in the delivery of structured information on the Web.

Richard has participated in numerous consulting projects and he frequently provides onsite training at the high-tech companies located in and around Austin, Texas.  He is the author of Baldwin's Programming Tutorials, which have gained a worldwide following among experienced and aspiring programmers. He has also published articles in JavaPro magazine.

In addition to his programming expertise, Richard has many years of practical experience in Digital Signal Processing (DSP).  His first job after he earned his Bachelor's degree was doing DSP in the Seismic Research Department of Texas Instruments.  (TI is still a world leader in DSP.)  In the following years, he applied his programming and DSP expertise to other interesting areas including sonar and underwater acoustics.

Richard holds an MSEE degree from Southern Methodist University and has many years of experience in the application of computer technology to real-world problems.

-end-