CMS 710 · The Test Questions, Answered in Full

(i) Control flow, defined

Control flow refers to the order in which statements, instructions or function calls are executed in a program. It is governed by control structures · the mechanisms that determine the sequence of execution.

Control flow determines four things:

1. Which instruction executes next
2. Under what conditions execution changes direction
3. How repetition occurs
4. How data moves through program components

It is commonly represented using flowcharts, control-flow graphs or execution traces.

Why it matters: without control structures, programs would execute instructions strictly in the order they appear, making it impossible to implement decision-making, loops or complex algorithms. The design of control structures significantly influences program readability, software reliability, maintainability and execution efficiency.

The four forms of control flow are sequential execution, selection, iteration and recursion.

(ii) Sequence vs iteration

Sequential execution is the simplest form of control flow: statements are executed one after another in the order they appear. Iteration allows a set of instructions to execute repeatedly until a specified condition is satisfied; it is commonly called looping.

SEQUENCE                ITERATION
x = 10                  for i in range(5):
y = 20                      print(i)
z = x + y
print(z)

Execution order:        Output:  0 1 2 3 4
  1. x = 10             One statement, five
  2. y = 20             executions · the flow
  3. z = x + y          returns to the top of
  4. print(z)           the block each pass.
Four statements,
each run once.

Closing sentence: sequential execution alone cannot support decision-making or repetition, which is precisely why languages provide selection and iteration · iteration reduces code duplication, improves efficiency and simplifies repetitive tasks.

Definition

Recursion is a control mechanism in which a function calls itself to solve a problem. It applies to problems that can be broken into smaller sub-problems of the same kind.

A recursive solution has two essential parts:

• Base case · the condition that terminates the recursion
• Recursive case · the call to itself with a smaller problem

The example · factorial

RECURSIVE                ITERATIVE
def factorial(n):        def factorial(n):
    if n == 1:               result = 1
        return 1             for i in range(1, n+1):
    return n * \                 result *= i
        factorial(n-1)       return result

TRACE of factorial(5) · recursive
factorial(5) = 5 * factorial(4)
factorial(4) = 4 * factorial(3)
factorial(3) = 3 * factorial(2)
factorial(2) = 2 * factorial(1)
factorial(1) = 1              ← BASE CASE reached

unwinding:  2*1=2  3*2=6  4*6=24  5*24 = 120

Draw that two-column trace · the winding down to the base case and the unwinding back up. It shows the marker you understand why recursion uses more memory: five calls are alive at once, each holding its own n.

Recursion vs iteration · the comparison table

Advantages and disadvantages, as the module lists them

Definitions first

Scope determines where a variable can be accessed within a program. It is a fundamental concept because it controls variable visibility and lifetime.

Global scope · the variable is accessible throughout the program, from any function or block.
Local scope · the variable is accessible only within the function or block in which it is declared.

The module names a third: block scope, where variables exist only inside a specific block · in JavaScript, let age = 20; declared inside an if block produces an error if read outside it.

The example

x = 10                  # GLOBAL · visible everywhere

def test():
    y = 20              # LOCAL · visible only in test()
    print(x)            # legal: globals are visible here
    print(y)            # legal

test()
print(x)                # legal · 10
print(y)                # ERROR: y does not exist here

Using scope to explain lifetime · what the question actually wants

Variable lifetime is the period during which a variable exists in memory. It depends on scope, the storage allocation method and the program execution state.

THE LIFETIME OF EACH VARIABLE, ON A TIMELINE

program starts ─────────────────────────────► ends
      │                                          │
  x created                                 x destroyed   ← GLOBAL
      │                                          │
      │    test() called ──────► returns         │
      │          │                    │          │
      │      y created           y destroyed     │        ← LOCAL
      │
  Each further call to test() creates a NEW y and
  destroys it again · the value is not carried over.

The consequence worth stating: because a local variable is destroyed on return, it cannot remember anything between calls; because a global survives, any function can change it, which is why globals are convenient but harmful to modularity.

Importance of scope · the four points

1. Prevents naming conflicts · two functions may each use i without interference
2. Enhances security · data is not exposed beyond where it is needed
3. Improves maintainability · a change to a local variable cannot affect distant code
4. Supports modular design · modules communicate through parameters, not shared state

Definitions

Functions often require data from other parts of a program, and languages provide parameter-passing mechanisms for supplying it.

Pass-by-value: a copy of the argument is passed to the function. Changes made inside the function do not affect the original variable.

Pass-by-reference: the function receives a reference to the original variable. Changes made inside the function affect the original.

The example, with output

PASS BY VALUE
#include <iostream>
using namespace std;

void increment(int x) {      // a COPY
    x++;
    cout << "inside:  " << x << endl;
}

int main() {
    int num = 10;
    increment(num);
    cout << "outside: " << num << endl;
    return 0;
}

OUTPUT   inside:  11
         outside: 10      ← original UNCHANGED

PASS BY REFERENCE
#include <iostream>
using namespace std;

void increment(int &x) {     // the ACTUAL variable
    x++;
    cout << "inside:  " << x << endl;
}

int main() {
    int num = 10;
    increment(num);
    cout << "outside: " << num << endl;
    return 0;
}

OUTPUT   inside:  11
         outside: 11      ← original MODIFIED

The two programs differ by a single character · the & · and that is exactly what makes them worth putting side by side in an answer.

Python's mechanism · the extra mark

Python uses an approach usually described as pass-by-object-reference: objects are passed by reference to object values.

def modify(lst):
    lst.append(100)         # the ORIGINAL list is modified

numbers = [1, 2, 3]
modify(numbers)
print(numbers)              # [1, 2, 3, 100]

def reassign(lst):
    lst = [9, 9, 9]         # rebinds the local name only

reassign(numbers)
print(numbers)              # [1, 2, 3, 100] · unchanged

The subtlety worth one sentence: in Python, mutating an object through the parameter affects the caller, but rebinding the parameter to a new object does not · which is why it is neither pure pass-by-value nor pure pass-by-reference.

Syntax vs semantics

Static vs dynamic typing

Strong vs weak typing

Primitive vs composite vs user-defined types

Array vs list

Stack vs queue

Parse tree vs abstract syntax tree

Imperative vs functional control flow

Compiled vs interpreted

ADT vs data structure