Programming Paradigms: Discipline, Not Tools

Why this matters

We have had three major programming paradigms since the 1950s, and no new ones have emerged since. Each paradigm is defined not by what it allows, but by what it forbids:

• Structured programming — removes unrestricted goto (discipline over direct transfer of control)
• Object-oriented programming — removes function pointers (discipline over indirect transfer of control, replaced by polymorphism)
• Functional programming — removes assignment (discipline over mutation of state)

These three constraints map directly to the three concerns of architecture: function, component separation, and data management. Understanding paradigms as disciplinary tools — not feature sets — changes how you use them.

✗ The problem

Code that uses mutable globals and unstructured loops forces the reader to simulate the machine in their head — violating every paradigm at once.

# Mutable globals, no abstraction, unstructured mutation
total    = 0
discount = 0
items    = [10, 20, 30]

for price in items:
    total += price          # mutates global
    if total > 40:
        discount = total * 0.1  # side effect on outer state
# What is discount? It depends on iteration order — hard to reason about

let total    = 0;
let discount = 0;
const items  = [10, 20, 30];

for (const price of items) {
  total += price;
  if (total > 40) discount = total * 0.1; // last assignment wins — confusing
}
// discount is not a computed value; it's a side-effect artifact

✓ The solution

Structured flow and a pure function make the logic traceable in a single reading — no globals, no side effects, no mental simulation of state.

def apply_discount(total: float, threshold: float, rate: float) -> float:
    return total * (1 - rate) if total > threshold else total

def calculate_order(items: list[float]) -> float:
    subtotal = sum(items)
    return apply_discount(subtotal, threshold=40.0, rate=0.10)

print(calculate_order([10, 20, 30]))  # 54.0 — deterministic, testable

function applyDiscount(total: number, threshold: number, rate: number): number {
  return total > threshold ? total * (1 - rate) : total;
}

function calculateOrder(items: number[]): number {
  const subtotal = items.reduce((s, n) => s + n, 0);
  return applyDiscount(subtotal, 40, 0.10);
}

console.log(calculateOrder([10, 20, 30])); // 54 — same input, same output, always