Programming Paradigms

A programming paradigm is a style or approach to programming. Different paradigms suit different problems. OCR H446 requires knowledge of four key paradigms:

Object-Oriented Programming (OOP)

OOP organises code around objects — instances of classes that bundle together data (attributes) and behaviour (methods). The four pillars of OOP are:

Classes and Objects

A class is a blueprint/template. An object is an instance of a class. A class defines attributes (data) and methods (behaviour). The __init__ constructor sets up initial attribute values when an object is created.

class Animal:
    def __init__(self, name, sound):
        self.__name = name      # private attribute
        self.__sound = sound

    def speak(self):            # public method
        return self.__name + " says " + self.__sound

dog = Animal("Dog", "Woof")
print(dog.speak())  # Dog says Woof

Inheritance Example

class Shape:
    def __init__(self, colour):
        self.colour = colour
    def area(self):
        return 0

class Circle(Shape):
    def __init__(self, colour, radius):
        super().__init__(colour)
        self.radius = radius
    def area(self):             # override parent method
        return 3.14159 * self.radius ** 2

Functional Programming

Functional programming treats computation as the evaluation of mathematical functions. Key features:

• First-class functions: Functions can be passed as arguments, returned from other functions, and stored in variables.
• Higher-order functions: Functions that take other functions as arguments or return functions. Examples: map(), filter(), reduce().
• Pure functions: Given the same inputs, always produce the same output; no side effects (don't modify external state).
• Immutability: Data is not modified — new data structures are created instead.
• Statelessness: No shared mutable state; avoids the problems of concurrency (race conditions, deadlocks).

# Higher-order functions in Python
nums = [1, 2, 3, 4, 5, 6]

evens = list(filter(lambda x: x % 2 == 0, nums))   # [2, 4, 6]
doubled = list(map(lambda x: x * 2, nums))           # [2, 4, 6, 8, 10, 12]

# Function passed as argument
def apply(func, value):
    return func(value)

print(apply(lambda x: x**2, 5))  # 25

Recursion

Recursion is when a function calls itself. It is a key technique in both functional and procedural programming. Every recursive function needs:

• Base case: The condition under which the function stops calling itself (prevents infinite recursion)
• Recursive case: The function calls itself with a smaller/simpler version of the problem

def factorial(n):
    if n == 0:          # base case
        return 1
    return n * factorial(n - 1)  # recursive case

# factorial(5) → 5 * factorial(4) → 5 * 4 * factorial(3) → ...
# → 5 * 4 * 3 * 2 * 1 = 120

Each recursive call adds a new stack frame. Deep recursion can cause a stack overflow if the call stack runs out of memory. Tail recursion (where the recursive call is the last operation) can be optimised by some languages to avoid this.

Procedural Programming

The most fundamental paradigm. Code is a sequence of instructions. The key constructs are: sequence, selection (if/else), iteration (while/for), and sub-routines (functions/procedures). Variables, parameters, return values, and local/global scope are all part of procedural thinking.

Global and Local Variables