Programming Paradigms (OCR A-Level Computer Science): Revision Notes

Programming Paradigms

Overview

Programming paradigms are different approaches or styles of programming, each with unique principles and techniques for structuring code. Each paradigm has specific strengths and weaknesses, making it more suitable for particular types of problems or programming scenarios. Understanding these paradigms helps programmers choose the right tool for the job, enhancing code quality, maintainability, and efficiency.

Key Programming Paradigms

Procedural Programming

• Characteristics:
  • Code is organised into procedures or functions that contain a sequence of steps to execute specific tasks.
  • Emphasises a clear flow of control, typically through loops, conditionals, and function calls.
• Strengths:
  • Simple and Structured: Procedural programming is straightforward, making it easy to learn and understand.
  • Efficient for Linear Tasks: Well-suited for tasks that require a step-by-step approach.
• Weaknesses:
  • Limited Reusability: Functions can be reused but are less flexible than objects in object-oriented programming.
  • Less Suitable for Complex Applications: As projects grow, procedural code can become harder to manage and maintain.
• Examples of Languages: C, Python (when used with functions), and BASIC.
• Use Cases: Scientific calculations, data processing, and applications with a clear, linear flow.

Object-Oriented Programming (OOP)

• Characteristics:
  • Organises code into objects, which are instances of classes. Objects encapsulate data and methods, mimicking real-world entities.
  • Core principles include Encapsulation (data hiding within objects), Inheritance (creating new classes from existing ones), Polymorphism (methods behaving differently in different contexts), and Abstraction (simplifying complex systems by modelling).
• Strengths:
  • Code Reusability: Inheritance and polymorphism allow code to be reused, reducing duplication.
  • Modularity: Encapsulation helps maintain modular code, making it easier to debug and extend.
• Weaknesses:
  • Complexity for Small Programmes: OOP can introduce unnecessary complexity for small, simple applications.
  • Higher Resource Usage: Objects can consume more memory and processing time, especially in languages like Java.
• Examples of Languages: Java, C++, Python (when using classes), and C#.
• Use Cases: Large-scale applications, like GUI applications, games, and enterprise software, where modularity and reusability are essential.

Low-Level Programming

• Characteristics:
  • Involves programming closer to machine code, providing direct control over hardware and memory.
  • Often uses Assembly Language or other languages with direct hardware manipulation capabilities.
• Strengths:
  • High Performance: Low-level code is optimised for specific hardware, maximising speed and efficiency.
  • Fine-Grained Control: Provides complete control over system resources, making it ideal for real-time applications.
• Weaknesses:
  • Complex and Error-Prone: Low-level programming requires an understanding of the underlying hardware, making it difficult to learn and prone to errors.
  • Poor Portability: Low-level code is often specific to a particular hardware architecture, limiting its portability.
• Examples of Languages: Assembly, C, and languages with system-level access like C++.
• Use Cases: Embedded systems, operating system development, and performance-critical applications.

Functional Programming

• Characteristics:
  • Based on mathematical functions and treats computation as the evaluation of expressions rather than state changes.
  • Emphasises pure functions (functions with no side effects) and immutability (unchanging data).
• Strengths:
  • Easier Debugging: Pure functions are isolated and don't depend on or alter external states, reducing bugs.
  • Concurrency-Friendly: Immutability and statelessness allow functional programmes to run concurrently with fewer risks of data conflicts.
• Weaknesses:
  • Steeper Learning Curve: Functional programming can be challenging for beginners used to imperative or procedural styles.
  • Performance Overhead: Recursion and functional constructs can lead to higher memory usage in some languages.
• Examples of Languages: Haskell, Lisp, F#, and functional features in languages like Python and JavaScript.
• Use Cases: Data analysis, concurrent applications, and applications requiring predictable and testable code.

Event-Driven Programming

• Characteristics:
  • Code is organised around events (e.g., user actions, sensor inputs, or messages from other programmes) rather than sequential instructions.
  • Programmes react to events with specific actions (e.g., clicking a button triggers a function).
• Strengths:
  • Ideal for Interactive Applications: Works well for applications needing constant user interaction.
  • Flexible and Responsive: Allows programmes to respond to different triggers, making them adaptable and responsive.
• Weaknesses:
  • Complex Event Handling: Managing multiple event handlers and asynchronous events can be complex and lead to bugs.
  • Higher Resource Consumption: Event-driven applications often require more memory and processing, especially when dealing with numerous event listeners.
• Examples of Languages: JavaScript (especially in web development), Visual Basic, and GUI-focused languages.
• Use Cases: GUI applications, mobile apps, and web applications.

Comparison and Use Cases

Note Summary

Programming Paradigms Examples

Object-Oriented Programming (OOP)

Object-Oriented Programming organises code around "objects" rather than actions. An object is an instance of a class, which is a blueprint for creating objects with specific properties (attributes) and behaviours (methods). Key OOP principles include Encapsulation, Inheritance, Polymorphism, and Abstraction.

// Base class
public class Animal {
    private int numberOfLegs;
    private boolean isMammal;

    // Method to simulate making a sound
    public void makeSound() {
        System.out.println("I'm making a sound");
    }

    // Getter for number of legs (Encapsulation)
    public int getNumberOfLegs() {
        return numberOfLegs;
    }
}

// Subclass demonstrating Inheritance
public class Dog extends Animal {
    private String breed;
    private String name;

    // Unique method for Dog class
    public void fetch() {
        System.out.println("I caught the ball!");
    }

    // Overriding makeSound method for Dog
    @Override
    public void makeSound() {
        System.out.println("Woof woof");
    }
}

// Demonstration of Polymorphism and object creation
public static void main(String[] args) {
    Animal cow = new Animal();
    Dog spot = new Dog();

    // Calling methods
    cow.makeSound();  // Output: "I'm making a sound"
    spot.makeSound(); // Output: "Woof woof" (overridden)

    // Demonstrating Polymorphism
    Animal rex = new Dog();
    rex.makeSound();  // Output: "Woof woof"
}

Procedural Programming

Procedural programming structures code around procedures or functions, creating a clear flow of instructions. It emphasises sequential execution and is well-suited for tasks with a logical flow.

# Procedural approach to calculate the factorial of a number
def factorial(n):
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

# Example usage
print(factorial(5))  # Output: 120

Low-Level Programming

Low-level programming operates close to the hardware, providing direct control over memory and processing. This paradigm often uses Assembly Language or low-level languages like C, making it suitable for performance-critical tasks.

section .data
    num1 db 5      ; Define a byte with value 5
    num2 db 10     ; Define a byte with value 10
    result db 0    ; Define a byte to store the result

section .text
    global _start

_start:
    mov al, [num1]  ; Load num1 into register AL
    add al, [num2]  ; Add num2 to the value in AL
    mov [result], al ; Store the result in 'result'

    ; Exit the programme (Linux system call)
    mov eax, 1
    int 0x80

Functional Programming

Functional programming treats computation as the evaluation of mathematical functions, avoiding changing state and mutable data. It emphasises pure functions, immutability, and first-class functions.

-- Function to calculate nth Fibonacci number using recursion
fibonacci :: Int -> Int
fibonacci 0 = 0
fibonacci 1 = 1
fibonacci n = fibonacci (n - 1) + fibonacci (n - 2)

-- Usage example
main = print (fibonacci 10)  -- Output: 55

Summary of Paradigm Characteristics and Examples