Sub programs and random numbers

A subprogram is a named section of code that can be used again. A procedure performs a task but does not return a value. A function returns a value. A parameter receives data; the value supplied when calling the subprogram is an argument.

procedure showTotal(scores)
    total = scores[0] + scores[1] + scores[2]
    OUTPUT total
endprocedure
scores = [4, 7, 2]
showTotal(scores)

def show_total(scores):
    total = scores[0] + scores[1] + scores[2]
    print(total)
scores = [4, 7, 2]
show_total(scores)

Both print 13. Python has no separate procedure keyword: a function with no return is used for a task.

A local variable is created inside a subprogram and is only available there. A global variable is created outside subprograms and can be accessed by them. Passing an array as a parameter lets a subprogram use its elements; returning an array sends a new array back to the caller. In this example, passMark is global, while passed and result are local:

passMark = 50
function isPass(score)
    passed = score >= passMark
    return passed
endfunction
function doubleValues(values)
    result = [0, 0, 0]
    FOR i = 0 TO 2
        result[i] = values[i] * 2
    NEXT i
    return result
endfunction
scores = [4, 7, 2]
doubled = doubleValues(scores)
OUTPUT isPass(60)

pass_mark = 50
def is_pass(score):
    passed = score >= pass_mark
    return passed
def double_values(values):
    result = [0, 0, 0]
    for i in range(3):
        result[i] = values[i] * 2
    return result
scores = [4, 7, 2]
doubled = double_values(scores)
print(is_pass(60))

doubled is [8, 14, 4]; isPass(60) returns true.

Random numbers are useful when a program needs an unpredictable choice, such as a dice roll. ERL's random(1, 6) and Python's random.randint(1, 6) both include 1 and 6 as possible results:

roll = random(1, 6)
OUTPUT roll

import random
roll = random.randint(1, 6)
print(roll)

Each call can produce a different integer from 1 to 6.

Splitting a program into subprograms, rather than writing one long block of code, has several benefits:

• Decomposition: each subprogram solves one part of the problem, so the whole is easier to design.
• Reuse: a subprogram is written once and called as often as it's needed, so there is less code.
• Testing: each subprogram can be tested on its own before the parts are put together.
• Maintenance: a change is made in one place, rather than everywhere the code is repeated.
• Teamwork: different programmers can write different subprograms at the same time.