Programming Paradigms - A Comprehensive Guide

1. Procedural Programming

Core Concept

• Programs are structured as sequences of instructions
• Focuses on procedures or functions that perform specific tasks
• Data and functions are separate entities

Example: Calculating Average Temperature

# Procedural Approach
temperatures = [72, 68, 75, 70, 69]

def calculate_average(temp_list):
    total = 0
    for temp in temp_list:
        total += temp
    return total / len(temp_list)

def print_temperature_analysis(temps):
    average = calculate_average(temps)
    print(f"Average Temperature: {average}")
    
    if average > 70:
        print("It's warm!")
    else:
        print("It's cool.")

print_temperature_analysis(temperatures)

Characteristics

• Step-by-step execution
• Global data manipulation
• Functions operate on shared data
• Linear problem-solving approach

2. Object-Oriented Programming (OOP)

Core Concept

• Programs are collections of objects
• Objects combine data and behavior
• Supports encapsulation, inheritance, and polymorphism

Example: Temperature Tracking System

class TemperatureTracker:
    def __init__(self):
        self._temperatures = []
    
    def add_temperature(self, temperature):
        self._temperatures.append(temperature)
    
    def get_average(self):
        if not self._temperatures:
            return None
        return sum(self._temperatures) / len(self._temperatures)
    
    def get_analysis(self):
        avg = self.get_average()
        if avg is None:
            return "No temperatures recorded"
        
        if avg > 70:
            return f"Warm average: {avg:.2f}"
        else:
            return f"Cool average: {avg:.2f}"

# Usage
tracker = TemperatureTracker()
tracker.add_temperature(72)
tracker.add_temperature(68)
tracker.add_temperature(75)

print(tracker.get_analysis())

Characteristics

• Encapsulates data and behavior
• Supports code reuse through inheritance
• Provides abstraction and modularity
• Objects interact through well-defined interfaces

3. Functional Programming

Core Concept

• Treats computation as evaluation of mathematical functions
• Avoids changing state and mutable data
• Functions are first-class citizens

Example: Temperature Data Processing

from functools import reduce

# Pure functions
def fahrenheit_to_celsius(temp):
    return (temp - 32) * 5/9

def is_warm(temp):
    return temp > 70

# Function composition
def analyze_temperatures(temperatures):
    # Convert to Celsius
    celsius_temps = list(map(fahrenheit_to_celsius, temperatures))
    
    # Filter warm temperatures
    warm_temps = list(filter(is_warm, temperatures))
    
    # Calculate average of original temperatures
    average = reduce(lambda x, y: x + y, temperatures) / len(temperatures)
    
    return {
        'celsius_temps': celsius_temps,
        'warm_temp_count': len(warm_temps),
        'average': average
    }

# Immutable data processing
temperatures = [72, 68, 75, 70, 69]
result = analyze_temperatures(temperatures)
print(result)

Characteristics

• Emphasizes immutable data
• Avoids side effects
• Supports higher-order functions
• Enables powerful data transformations

4. Declarative Programming

Core Concept

• Describes WHAT should be done, not HOW to do it
• Focuses on the end result rather than step-by-step process

Example: SQL Temperature Query (Declarative)

-- Declarative approach
SELECT AVG(temperature) as avg_temp,
       COUNT(*) as warm_days
FROM temperature_log
WHERE temperature > 70;

Characteristics

• Abstracts implementation details
• Often used in database queries
• Focuses on the desired outcome

5. Logic Programming

Core Concept

• Based on formal logic
• Programs are set of facts and rules
• Solver determines how to satisfy conditions

Example: Prolog Temperature Rules

% Logic Programming Approach
% Facts
temperature(monday, 72).
temperature(tuesday, 68).
temperature(wednesday, 75).

% Rules
is_warm(Day) :- temperature(Day, Temp), Temp > 70.
warm_days(WarmDays) :- findall(Day, is_warm(Day), WarmDays).

Characteristics

• Defines relationships and rules
• Solver finds solutions
• Common in AI and expert systems

Hybrid Approaches

Modern languages often support multiple paradigms:

• Python supports procedural, OOP, and functional programming
• JavaScript is multi-paradigm
• Scala combines OOP and functional approaches

Choosing a Paradigm

• Consider problem domain
• Project complexity
• Performance requirements
• Team expertise
• Specific language strengths