Paradigmas de Programación: Disciplina, No Herramientas

Hemos tenido tres paradigmas de programación principales desde los años 50, y no han surgido nuevos desde entonces. Cada paradigma se define no por lo que permite, sino por lo que prohíbe:

• Programación estructurada — elimina el goto sin restricciones (disciplina sobre la transferencia directa de control)
• Programación orientada a objetos — elimina los punteros a funciones (disciplina sobre la transferencia indirecta de control, reemplazada por polimorfismo)
• Programación funcional — elimina la asignación (disciplina sobre la mutación del estado)

Estas tres restricciones se corresponden directamente con las tres preocupaciones de la arquitectura: función, separación de componentes y gestión de datos. Entender los paradigmas como herramientas disciplinarias — no como conjuntos de características — cambia cómo los usas.

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

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