Every subprogram consists of a unique name and one or more commands. You can name a subprogram anything although it's usually best to give a subprogram a descriptive name. So if you create a subprogram to convert yards into meters, you might name your subprogram Yards2Meters or MetricConverter.

After you define a name for your subprogram, you can fill it up with one or more commands that tell that subprogram what to do. So if you wanted to write a subprogram that prints your name on-screen, your main subprogram might look like this:

SUB PrintMyName
  FOR I = 1 TO 5
    PRINT "John Smith"
  NEXT I
END SUB

The preceding BASIC language example defines the beginning of a subprogram by using the SUB keyword followed by the subprogram's name, PrintMyName. The end of the subprogram is defined by the END SUB keywords.

Not every language defines subprograms with keywords. In the curly bracket language family, the main program is called main and every subprogram is just given its own name, such as

print_my_name ()
  {
  for i = 1; i < 5; i++)
    {
    printf ("John Smith");
   }
 }

You can store subprograms in the same file as the main program or in a separate file. If you store a subprogram in the same file as the main program, you can place the subprogram at the beginning or end of the file, as shown in Figure 6-4.

Figure II.6-4. Subprograms usually appear at the beginning or end of a file.

After you isolate commands inside a subprogram, your program can't run those commands until it "calls" the subprogram. Calling a subprogram basically tells the computer, "See those commands stored in that subprogram over there? Run those commands now!"

To call a subprogram, you must use the subprogram's name as a command. So if you had the following subprogram:

SUB PrintMyName
  FOR I = 1 TO 5
    PRINT "John Smith"
  NEXT I
END SUB

To run this subprogram, you use its name as a command in any part of your program like this:

PRINT "The subprogram is going to run now."
PrintMyName
END

The preceding BASIC program would print the following:

The subprogram is going to run now.
John Smith
John Smith
John Smith
John Smith
John Smith

In the curly bracket language family, calling a subprogram (function) is the same. Use the subprogram's name as a command. So if you had the following subprogram:

print_my_name ()
  {
  for i = 1; i < 5; i++)
    {
    printf ("John Smith");
   }
 }

You could call that subprogram (function), as follows:

main ()
  {
  print_my_name ();
  }

If you've stored a subprogram in a separate file, you may need to go through two steps to call a subprogram. First, you may need to specify the filename that contains the subprogram you want to use. Second, you need to call the subprogram you want by name.

In the curly bracket languages, like C, you specify a filename where your subprogram is stored like this:

#include <filename>
main()
  {
  subprogram name ();
  }

In this C example, the #include<filename> command tells the computer that if it can't find a subprogram in the main program file, look in the file dubbed filename.

When a program calls and passes parameters to a subprogram, the computer makes duplicate copies of those parameters. One copy of those parameters stays with the main program and the second copy gets passed to the subprogram.

Now if the subprogram changes those parameters, the values of those parameters stay trapped within the subprogram, as shown in Figure 6-6.

Figure II.6-6. Normally when you pass parameters to a subprogram, the computer makes a second copy for the subprogram to use.

Most of the time when you call a subprogram and pass it parameters, you don't want that subprogram to change the value of its parameters; you just want the subprogram to modify its behavior based on the parameters it receives, such as the subprogram that prints a name a fixed number of times.

Rather than give a subprogram parameters that modify its behavior, you can also give a subprogram parameters that the subprogram can modify and send back to the rest of the program.

To make a subprogram modify its parameters, you must use an x called pass by reference. Essentially, instead of letting a subprogram use a copy of data, passing by reference gives the subprogram the actual data to manipulate, as shown in Figure 6-7.

Figure II.6-7. Passing by reference means the subprogram can manipulate data that another part of the program will use.

Suppose you have a subprogram that converts temperatures from Celsius to Fahrenheit with this formula:

Tf = ((9/5)*Tc)+32

Your subprogram could look like this:

SUB ConvertC2F (ByRef Temperature as Single)
  Temperature = ((9/5) * Temperature) + 32
END SUB

This is how the preceding subprogram works:

subprogram_example (int a, float &x);

If you had the following BASIC subprogram:

SUB ConvertC2F (ByRef Temperature as Single)
  Temperature = ((9/5) * Temperature) + 32
END SUB

You could call that subprogram like this:

DIM Temp AS SINGLE
Temp = 12
PRINT "This is the temperature in Celsius = "; Temp
ConvertC2F (Temp)
PRINT "This is the temperature in Fahrenheit = "; Temp END

Running this program would produce the following:

This is the temperature in Celsius = 12
This is the temperature in Fahrenheit = 53.6

Notice that right before calling the ConvertC2F subprogram, the value of the Temperature variable is 12, but the ConvertC2F subprogram changes that value because the subprogram was passed the Temperature value by reference. What happens if you run the same program except change the subprogram to accept parameters passed by value instead, such as

DIM Temp AS SINGLE
Temp = 12
PRINT "This is the temperature in Celsius = "; Temp
ConvertC2F (Temp)
PRINT "This is the temperature in Fahrenheit = "; Temp
END

SUB ConvertC2F (Temperature as Single)
  Temperature = ((9/5) * Temperature) + 32
END SUB

This program would print the following:

This is the temperature in Celsius = 12
This is the temperature in Fahrenheit = 12

Although the ConvertC2F subprogram changed the value of the Temperature variable, it never passes the changed value back to the main program. So the main program blissfully uses the current value of the Temperature variable, which is always 12.

One problem with passing parameters by reference is that you may not always know when a subprogram will change its parameter values. To make it clear when a subprogram returns modified data, you can create a special type of subprogram called a function.

A function is nothing more than a subprogram with the subprogram name representing a value. So a typical function might look like this:

FUNCTION Name (parameter list) AS DataType
  Commands
  RETURN value
END FUNCTION

In BASIC, you identify a function with the FUNCTION keyword to define a subprogram as a function. After listing a parameter list, the first line also defines the data type that the function name can hold, such as an integer, a string, or a single (decimal) number.

datatype function_name (parameter list)
  {
  commands
  return value
  }

Inside the function, one or more commands must calculate a new result. Then you use the RETURN keyword to define what value to store in the function name. Whatever value this is, it must be the same data type that you defined for the function name in the first line. So if you defined a function as a String data type, you can't return an integer value from that function.

A typical function in BASIC might look like this:

FUNCTION ConvertC2F (Temperature AS SINGLE) AS SINGLE
  Temperature = ((9/5) * Temperature) + 32
  RETURN Temperature
END FUNCTION

The function name ConvertC2F can hold a Single data type.

Unlike a subprogram that may or may not return a modified value, functions always return a value. To call a function, you must assign the function name to a variable or use the function name itself as a variable, such as

PRINT "Temperature in Fahrenheit = "; ConvertC2F (12)

DIM Temp AS SINGLE
Temp = 12
PRINT "Temperature in Celsius = "; Temp
PRINT "Temperature in Fahrenheit = "; ConvertC2F (Temp)
END

FUNCTION ConvertC2F (Temperature AS SINGLE) AS SINGLE
  Temperature = ((9/5) * Temperature) + 32
  RETURN Temperature
END FUNCTION

Unlike a subprogram that you can call just by typing its name on a line by itself, you can call a function only by using that function name as if it's a variable.

This same function as seen in the Python language might look like this:

def convertc2f(temperature):
    new = ((9.0/5.0) * temperature) + 32
    return new

To run this function, you could use the following program:

temp = 12
print "Temperature in Celsius = ", temp
print "Temperature in Fahrenheit = ", convertc2f(temp)