1. Microsoft® Small Basic
Branches and Subroutines
Estimated time to complete this lesson: 1 hour

2. Code Branches and Subroutines
In this lesson, you will learn how to:
Branch your code by using Goto statements.
Create subroutines by using Sub and EndSub statements.

3. Branching
As you know, the computer runs a program by reading and processing the statements line by line, one at a time.
Sometimes, you may want the computer to break the flow and jump to another line of code while the program is running.
Code:
j = 1
lineQ:
TextWindow.WriteLine(j)
j = j + 1
If j < 30 Then
Goto lineQ
EndIf
You can instruct the computer to process a line of code out of sequence if you use the Goto statement.

4. Branching in Small Basic Programs
Let’s examine the Goto statement and its various parts by writing a program.
In this program, the lineQ: statement is called a label, which is similar to a bookmark. You can add as many labels as you want and name them whatever you want, as long as you don’t use the same name more than once.
The Goto statement instructs the computer to run the statements after the lineQ: label again only if the condition in the If statement is true.
output
In the first line of this program, you create a variable that is named j, and you set its value to 1.
Then you create a label that is named lineQ: with a colon (:) at the end.
In the next line, you tell the computer to display the value of the j variable on the screen.
Then you increase the value of the j variable by 1.
In the fourth line, you determine whether the value of the j variable is smaller than 10.
--If it is, you tell the computer to repeat the lines of code that follow the lineQ: label. In other words, you tell the computer to display the value of the j variable, increase its value by 1, and then determine whether that value is smaller than 10.
--If the value of the j variable is not smaller than 10, you tell the computer to continue to the next part of the program (or to stop running the program if no more code exists).
Code:
j = 1
lineQ:
TextWindow.WriteLine(j)
j = j + 1
If j < 10 Then
Goto lineQ
EndIf

5. Branching in Small Basic Programs
You can also use the Goto statement to make a program run forever.
Let’s see how Goto statements work by adding one to a familiar program.
This program will continue to run until someone clicks the Close (X) button in the top-right corner of the text window.
Warning: If you use Goto statements a lot, your code will be difficult to understand and to correct. Although these statements are useful sometimes, you should try to structure your programs so that you rarely use Goto statements.
Code:
start:
TextWindow.WriteLine("How many members are in your family?")
number = TextWindow.ReadNumber()
remainder = Math.Remainder(number, 2)
If remainder = 0 Then
TextWindow.WriteLine("Your family has an even number of members.")
Else
TextWindow.WriteLine("Your family has an odd number of members.")
EndIf
Goto start

6. Subroutines in Small Basic Programs
When we write programs, we often want the computer to run certain statements more than once. You can avoid writing the same statements over and over if you use subroutines in your programs.
By using a subroutine, you can run one or more statements with a single instruction. To create a subroutine, you use the Sub keyword, and then you give the subroutine a specific name. You end the subroutine by using the EndSub keyword.
Look at the following subroutine named PrintHour, which opens a text window and displays the current hour.

7. Subroutines in Small Basic Programs
Let’s gain a better understanding of subroutines by writing another program…
In this program, we use the Divide( ) statement to run (or “call”) the subroutine Divide from any location within the program.
If you use subroutines, your programs will be easier to read and understand than if you use Goto statements.
In this program, you write the Divide subroutine once, but you can run it from anywhere in the program.
When you instruct the computer to run a subroutine, you use a statement that contains the name of the subroutine followed by a set of open and close parentheses. When you use this type of statement, you are calling the subroutine.
Code:
While i < 5
TextWindow.WriteLine("Enter Dividend: ")
Dividend = TextWindow.Read()
TextWindow.WriteLine("Enter Divisor: ")
Divisor = TextWindow.Read()
Divide()
TextWindow.WriteLine("Your answer is: " + Answer)
i = i + 1
EndWhile
Sub Divide
Answer = Dividend / Divisor
EndSub
output

8. Let’s Summarize… Congratulations! Now you know how to:
Create a branch by using a Goto statement.
Create a subroutine by using a Sub..EndSub statement.

9. Show What You Know
Write a program that opens a text window and then performs the following steps:
Asks the user for the name, temperature, rain status, and wind status of 10 cities.
Uses branching and subroutines to determine and display the total number of:
Cold Cities
Cool Cities
Warm Cities
Hot Cities
Rainy Cities
Windy Cities
Solution:
up:
If i < 10 then
TextWindow.WriteLine("")
TextWindow.Write("What is the name of a city? ")
city = TextWindow.Read()
TextWindow.Write("How warm is that city (in degrees Celsius)? ")
temp = TextWindow.Read()
TextWindow.Write("Is it rainy (Y/N)? ")
rainy = TextWindow.Read()
TextWindow.Write("Is it windy (Y/N)? ")
windy = TextWindow.Read()
'Calling subroutines
subtempCount()
subrainyCount()
subwindyCount()
i = i + 1
If i = 10 Then
subOutput()
EndIf
Goto up
Sub subtempCount
If temp <= 5 Then
ColdCount = ColdCount + 1
ElseIf temp <= 15 Then
CoolCount = CoolCount + 1
ElseIf temp <= 25 Then
WarmCount = WarmCount + 1
Else
HotCount = HotCount + 1
EndSub
Sub subRainyCount
If Rainy = "y" Or Rainy = "Y" Then
RainyCount = RainyCount + 1