What is a Programming Paradigm?

A programming paradigm is a style or approach to programming — a way of thinking about and structuring programs. Different paradigms provide different models of computation and different ways of organising code.

OCR H446 requires knowledge of four paradigms: imperative/procedural, declarative, functional, and object-oriented (OOP).

1. Imperative / Procedural Paradigm

The imperative paradigm is the most traditional approach. Programs are sequences of statements that tell the computer how to do something step by step. The programmer specifies the exact steps and control flow.

• Programs use: variables, assignments, loops, conditionals, and procedures/functions.
• Procedural programming is a sub-type of imperative programming that uses procedures (subroutines/functions) to structure code into reusable blocks.
• Examples: C, Pascal, early Python scripts, BASIC.
• Advantages: intuitive — maps closely to how computers execute instructions; efficient; straightforward for sequential tasks.
• Disadvantages: can become difficult to manage in very large programs; state (variables) is shared globally, making bugs harder to trace.

2. Declarative Paradigm

The declarative paradigm specifies what the desired result is, rather than how to achieve it. The programmer describes the problem and the language/runtime figures out how to solve it.

• Examples: SQL (Structured Query Language), HTML, Prolog, CSS.
• SQL example: SELECT name FROM students WHERE grade = 'A'; — the programmer states what data is wanted, not how to search for it.
• Declarative languages often use logic and rules (Prolog) or query specifications (SQL).
• Advantages: simpler and more concise for certain problems; the runtime can optimise how to achieve the result; easier to read intent.
• Disadvantages: less control over performance; may be less efficient than procedural code for some tasks; not suitable for all problems.

3. Functional Paradigm

In the functional paradigm, programs are composed of mathematical functions. The focus is on applying and composing functions. Key characteristics:

• Pure functions: a function always returns the same output for the same input and has no side effects (does not modify external state). This makes programs easier to reason about and test.
• Immutability: data is not modified after creation — instead, new data structures are created.
• No mutable state: programs avoid shared mutable variables, reducing bugs from unintended state changes.
• First-class and higher-order functions: functions can be passed as arguments to other functions, returned as values, and stored in variables.
• Function composition: combining simple functions to build more complex behaviour.
• Examples: Haskell, Erlang, ML, F#; Python and JavaScript support functional features (map, filter, lambda).
• Advantages: easier to debug/test (pure functions); naturally thread-safe (no shared state); code is concise.
• Disadvantages: can be difficult to learn; some problems map more naturally to imperative style; performance can be a concern (immutability requires creating new copies of data).

4. Object-Oriented Paradigm (OOP)

In object-oriented programming, programs are structured as collections of objects that combine data (attributes) and behaviour (methods). OOP is covered in detail in 1.2.4e — key concepts below:

• Class: a blueprint/template defining the attributes and methods of objects of that type.
• Object: an instance of a class — a specific entity created from the class blueprint.
• Encapsulation: data and methods are bundled inside a class; internal data is hidden from outside (private attributes).
• Inheritance: a subclass inherits attributes and methods from a parent (superclass) — promotes code reuse.
• Polymorphism: objects of different classes can be treated through the same interface — e.g. different animals all have a makeSound() method that behaves differently.
• Examples: Python, Java, C++, C#, Ruby.

Comparison of Paradigms

Declarative vs Procedural: Key Contrast

A critical distinction for the exam:

• Procedural: the programmer specifies every step — e.g. a loop to search through a list item by item.
• Declarative: the programmer specifies the desired result — e.g. SELECT in SQL: the database engine decides how to find the data.

Prolog: A Declarative/Logic Language

Prolog is a logic programming language (sub-type of declarative). The programmer defines facts and rules, then asks queries. Prolog's inference engine determines how to answer the query.

• Fact: parent(tom, bob). — tom is a parent of bob.
• Rule: grandparent(X, Z) :- parent(X, Y), parent(Y, Z). — X is grandparent of Z if X is parent of Y and Y is parent of Z.
• Query: ?- grandparent(tom, ann). — asks the engine if tom is a grandparent of ann.