Global and local variables of various data types

Explainer

Northgate Swim Club keeps a whiteboard by the pool door. One line never changes all season: the pool is 25 metres long. Another line is rubbed out and rewritten every time somebody finishes a session: the number of swims logged today. Both are just labelled spaces holding a value, but one is written once and read by everybody, while the other is updated constantly. A program stores information the same way, and gives you control over both things: what kind of value the space can hold, and who is allowed to look at it.

Explainer

The five data types this statement names

The syllabus lists exactly five, and every one of them shows up in the swim club program below. Python works out the type from the value you assign, while Java makes you state it before the name. Both are examinable, so read each row across.

Choosing the type is a real decision, not decoration. Storing a lap count as a string means "24" + "1" gives "241" rather than 25, because joining text is a perfectly legal thing to do with two strings. Markers report answers losing marks for exactly this: a value stored under a type that cannot support the operation the question then asks for.

Explainer

Global and local: who can see the variable

Scope is the second half of this statement, and it is about visibility and lifetime rather than value. The deciding question is where the variable was created.

Reading a global from inside a function needs nothing special. Writing to one does. In Python, assigning to a name inside a function creates a local variable by default, even when a global of the same name already exists, so the global is left untouched and the change silently disappears when the function returns. The global keyword is how you say you meant the outer one.

# the trap: this does NOT change the global
session_count = 0

def log_swim():
    session_count = session_count + 1   # makes a brand new LOCAL, then fails reading it

# the fix: say which one you mean
def log_swim():
    global session_count                # "the outer one, not a new local"
    session_count = session_count + 1

Java needs no equivalent to the global keyword. A static field is written to directly from any method, no declaration required first, since it already belongs to the class rather than to any one method call.

// the Java equivalent: sessionCount is a static field of the class
public class Pool {
    static int sessionCount = 0;   // one shared copy, not per-call

    static void logSwim() {
        sessionCount = sessionCount + 1;   // writes straight to the class's copy
    }
}

There is no risk of accidentally creating a new local here the way Python's default behaviour allows, a bare sessionCount = sessionCount + 1 inside a method always means the class's own static field.

Explainer

Choosing between global and local

B2 asks how programming is applied to solve problems, and scope is one of the places where that choice is made explicitly rather than by habit. The deciding question is short: does anything outside this function genuinely need this value?

The working rule: make everything local by default, and promote a variable to global only when something genuinely has to outlive a single call, like a running total or a fixed setting. A global chosen out of convenience is the most common source of bugs that are hard to trace.