Understand and use subroutines (procedures and functions), parameters, return values, local and global variables, scope, and the use of an interface and recursion.

What this dot point is asking

AQA wants you to distinguish a procedure from a function, pass data with parameters and return results, explain local and global variables and scope, give the advantages of subroutines, and describe recursion and how it uses the call stack.

Procedures and functions

FUNCTION area(width, height)   # parameters
  RETURN width * height        # return value
ENDFUNCTION

a = area(4, 5)                 # call, a = 20

The practical difference is how you use them: a function is called where a value is expected (on the right of an assignment or inside a larger expression), whereas a procedure is called as a statement in its own right to make something happen, such as drawing to the screen. Both let a single task be defined once and invoked wherever needed.

Parameters, return values and scope

Parameters are the named inputs in the subroutine definition; arguments are the actual values passed in when it is called. A function passes a result back with a return value. Data can be passed by value (the subroutine receives a copy, so changes do not affect the original) or by reference (the subroutine can change the caller's data), a distinction worth knowing for explaining side effects.

Advantages of subroutines and the interface

Subroutines support modular (structured) programming: a large problem is decomposed into smaller, named tasks. The benefits are reuse (write once, call many times), easier testing and debugging (test each subroutine independently), readability (a well-named subroutine documents its purpose), and the ability for several people to work on different subroutines in parallel. The interface of a subroutine is its name, parameters and return type: the information a caller needs in order to use it without seeing the implementation. This separation between interface and implementation is a form of abstraction, and it is what lets one part of a program change internally without breaking the parts that call it.

Recursion

FUNCTION factorial(n)
  IF n = 0 THEN
    RETURN 1               # base case
  ELSE
    RETURN n * factorial(n - 1)   # general case
  ENDIF
ENDFUNCTION

Recursion and iteration can often solve the same problem. Recursion can express naturally recursive structures (trees, divide-and-conquer algorithms, traversals) very concisely, but it uses stack memory proportional to its depth and carries the overhead of repeated calls. Iteration usually uses constant extra memory but can be more awkward for inherently recursive problems. Being able to weigh this trade-off, conciseness versus memory use, is what higher-mark questions on recursion reward.