Programming Paradigms

// TypeScript OOP example
class User {
  private email: string;
  protected name: string;

  constructor(name: string, email: string) {
    this.name = name;
    this.email = email;    // private — only readable via getter
  }

  greet(): string {
    return `Hello, I'm ${this.name}`;
  }

  getEmail(): string {     // encapsulation: controlled access
    return this.email;
  }
}

class AdminUser extends User {  // inheritance
  private permissions: string[];

  constructor(name: string, email: string, permissions: string[]) {
    super(name, email);   // call parent constructor
    this.permissions = permissions;
  }

  greet(): string {       // polymorphism: overrides parent method
    return `${super.greet()} (Admin)`;
  }
}

const alice = new User('Alice', 'alice@example.com');
const bob   = new AdminUser('Bob', 'bob@example.com', ['users:write']);

console.log(alice.greet()); // "Hello, I'm Alice"
console.log(bob.greet());   // "Hello, I'm Bob (Admin)"

// Functional style in TypeScript — no mutations, no side effects

// Pure function: same input → always same output
const add = (a: number, b: number): number => a + b;

// Immutable transformation — returns NEW array, never mutates original
const prices = [10, 25, 8, 45, 15];

const discounted = prices
  .filter(p => p >= 10)       // keep items $10 or more
  .map(p => p * 0.9)          // apply 10% discount
  .reduce((sum, p) => sum + p, 0); // total after discount

// 85.5 — computed without modifying 'prices'

// Higher-order function: takes a function, returns a function
const withLogging = <T, R>(fn: (arg: T) => R) =>
  (arg: T): R => {
    console.log(`Calling with: ${arg}`);
    const result = fn(arg);
    console.log(`Result: ${result}`);
    return result;
  };

const addTax = withLogging((price: number) => price * 1.2);
addTax(100); // logs inputs/outputs, returns 120

// ── IMPERATIVE: how to do it ────────────────────────────────────
// Filter active users — you manage the loop and accumulator
const users = [
  { name: 'Alice', active: true  },
  { name: 'Bob',   active: false },
  { name: 'Carol', active: true  },
];

const activeUsers = [];
for (let i = 0; i < users.length; i++) {
  if (users[i].active) {
    activeUsers.push(users[i]);
  }
}


// ── DECLARATIVE: what you want ───────────────────────────────────
// Same result — you state the intent, filter handles the loop
const activeUsers2 = users.filter(u => u.active);


// ── DECLARATIVE: SQL ─────────────────────────────────────────────
// SELECT name FROM users WHERE active = true;
// You declare the result you want — the DB engine optimises the path


// ── DECLARATIVE: Terraform IaC ───────────────────────────────────
// resource "aws_s3_bucket" "my_bucket" {
//   bucket = "my-app-assets"
// }
// You declare "I want this bucket to exist" — Terraform figures out how

// C-style procedural approach (TypeScript analogy)

// Each procedure does one thing
function readConfig(path: string): string {
  return fs.readFileSync(path, 'utf-8');
}

function parseConfig(raw: string): Record<string, string> {
  return Object.fromEntries(
    raw.split('\n').map(line => line.split('='))
  );
}

function startServer(config: Record<string, string>): void {
  const port = parseInt(config['PORT'] ?? '3000');
  console.log(`Server starting on port ${port}`);
  // ...
}

// Main entry point: call procedures in order
function main(): void {
  const raw    = readConfig('./config.env');
  const config = parseConfig(raw);
  startServer(config);
}

main();

// Browser event-driven example
const button = document.getElementById('submit-btn');

// Register a listener — code runs only when the event fires
button?.addEventListener('click', (event: MouseEvent) => {
  event.preventDefault();
  console.log('Button clicked! Submitting form...');
  submitForm();
});

// Node.js EventEmitter — backend pub/sub
import { EventEmitter } from 'events';

const orderBus = new EventEmitter();

// Subscribers — registered independently and decoupled from each other
orderBus.on('order:placed', (order) => sendConfirmationEmail(order));
orderBus.on('order:placed', (order) => reserveInventory(order));
orderBus.on('order:placed', (order) => notifyWarehouse(order));

// Publisher — emits the event, doesn't know who's listening
function placeOrder(order: Order) {
  saveOrderToDatabase(order);
  orderBus.emit('order:placed', order);  // triggers all listeners
}

// RxJS example: autocomplete search with debounce
import { fromEvent, switchMap, debounceTime, distinctUntilChanged, map } from 'rxjs';
import { ajax } from 'rxjs/ajax';

const input = document.getElementById('search') as HTMLInputElement;

fromEvent(input, 'input')           // Stream of keyboard events
  .pipe(
    map((e: Event) => (e.target as HTMLInputElement).value),
    debounceTime(300),              // wait 300ms after user stops typing
    distinctUntilChanged(),         // don't search if value didn't change
    switchMap(query =>              // cancel previous HTTP request, start new one
      ajax.getJSON(`/api/search?q=${query}`)
    )
  )
  .subscribe({
    next: results => renderResults(results),
    error: err => showError(err),
  });

// Without reactive: you'd manually manage timers, XHR cancellation,
// and deduplication — all with state variables and callbacks.

% Prolog
parent(alice, bob).
parent(bob, carol).

grandparent(X, Z) :- parent(X, Y), parent(Y, Z).

?- grandparent(alice, W).
% W = carol.   -- the engine found it by search, not by an algorithm you wrote

// TypeScript decorator — a lightweight AOP-style "advice" around a method
function logCall(target: any, key: string, descriptor: PropertyDescriptor) {
  const original = descriptor.value;
  descriptor.value = function (...args: unknown[]) {
    console.log(`→ calling ${key}(${JSON.stringify(args)})`);
    const result = original.apply(this, args);
    console.log(`← ${key} returned`, result);
    return result;
  };
}

class OrderService {
  @logCall
  placeOrder(id: string) {
    return { id, status: 'placed' };
  }
}
// Logging is defined once and applied without touching placeOrder's body

// Race condition vs. safe concurrent access (conceptual)
let counter = 0;

// UNSAFE if run from multiple threads/workers concurrently:
function incrementUnsafe() { counter = counter + 1; } // read-modify-write, not atomic

// SAFE: use a lock or an atomic primitive so the read-modify-write
// cannot be interleaved with another thread's read-modify-write
import { Mutex } from 'async-mutex';
const lock = new Mutex();

async function incrementSafe() {
  const release = await lock.acquire();
  try {
    counter = counter + 1;
  } finally {
    release();
  }
}

// Python: parallel map across CPU cores
from multiprocessing import Pool

def square(n: int) -> int:
    return n * n

if __name__ == "__main__":
    with Pool(processes=4) as pool:
        results = pool.map(square, range(1_000_000))
    # The 1M squarings are split across 4 worker processes running in parallel

# Unix pipeline — a classic dataflow graph on the command line
cat access.log | grep "ERROR" | cut -d' ' -f1 | sort | uniq -c | sort -rn
# Each stage fires as soon as data flows in from the previous one —
# grep doesn't wait for cat to finish; they run concurrently on the stream

// TypeScript generic function — works for any type T
function firstOrDefault<T>(items: T[], fallback: T): T {
  return items.length > 0 ? items[0] : fallback;
}

firstOrDefault<number>([1, 2, 3], 0);        // 1
firstOrDefault<string>([], 'none');          // "none"

// Constrained generic: T must have a .length
function longest<T extends { length: number }>(a: T, b: T): T {
  return a.length >= b.length ? a : b;
}

# Python: a decorator is metaprogramming — it wraps the function it decorates
import functools, time

def timed(fn):
    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = fn(*args, **kwargs)
        print(f"{fn.__name__} took {time.time() - start:.4f}s")
        return result
    return wrapper

@timed
def slow_query():
    time.sleep(0.2)
    return "done"

slow_query()  # prints timing, then returns "done" — timed() never touched by caller

// Structured: sequence, selection, iteration — no jumps to arbitrary labels
function classify(n: number): string {
  let result = '';               // sequence
  if (n < 0) {                   // selection
    result = 'negative';
  } else {
    for (let i = 2; i <= n; i++) { // iteration
      if (n % i === 0 && i !== n) {
        result = 'composite';
        break;                    // structured exit, not a GOTO
      }
    }
    if (!result) result = 'prime or one';
  }
  return result;
}

# Elixir: two actors (processes) communicating only via messages
defmodule Counter do
  def start, do: spawn(fn -> loop(0) end)

  defp loop(count) do
    receive do
      {:increment, from} ->
        send(from, {:count, count + 1})
        loop(count + 1)
    end
  end
end

counter = Counter.start()
send(counter, {:increment, self()})
receive do
  {:count, value} -> IO.puts("Count is now #{value}")
end
# No shared memory, no locks — just messages between isolated processes

// JavaScript: prototype-based inheritance without "class"
const animal = {
  speak() { return `${this.name} makes a sound.`; }
};

const dog = Object.create(animal);  // dog's prototype is 'animal'
dog.name = 'Rex';

console.log(dog.speak());
// "Rex makes a sound." — speak() was found by walking the prototype chain,
// not because dog has its own copy of the method

# Python with a constraint solver (OR-Tools CP-SAT, simplified)
from ortools.sat.python import cp_model

model = cp_model.CpModel()
x = model.NewIntVar(0, 10, 'x')
y = model.NewIntVar(0, 10, 'y')

model.Add(x + y == 10)
model.Add(x < y)

solver = cp_model.CpSolver()
if solver.Solve(model) == cp_model.OPTIMAL:
    print(solver.Value(x), solver.Value(y))  # e.g. 4 6
# You declared the constraints; the solver found values satisfying both

; Scheme/Lisp: code and data share the same list structure
(define expr '(+ 1 (* 2 3)))   ; quote — treat this as DATA, don't evaluate it
(display expr)                 ; prints: (+ 1 (* 2 3))

(eval expr)                    ; now evaluate that data AS CODE
; => 7

; This is what lets Lisp macros write programs that write programs

<<define-average>>=
def average(numbers):
    """Computes the arithmetic mean of a non-empty list."""
    return sum(numbers) / len(numbers)
@
The function above is the core of our report generator. It is used
in the summary step below, where we combine it with the parsed input:

<<use-average>>=
scores = parse_scores(raw_input)
print(f"Average score: {average(scores)}")
@
<!-- "tangle" extracts define-average + use-average into a .py file;
     "weave" turns this whole document into readable docs -->

// Data-oriented: plain data + separate transform functions (TypeScript)
type Player = { id: string; hp: number; x: number; y: number };

function damage(player: Player, amount: number): Player {
  return { ...player, hp: Math.max(0, player.hp - amount) }; // new data, not mutated
}

function move(player: Player, dx: number, dy: number): Player {
  return { ...player, x: player.x + dx, y: player.y + dy };
}

// No Player class with methods — just data and functions that transform it
let p: Player = { id: 'p1', hp: 100, x: 0, y: 0 };
p = move(damage(p, 20), 5, 0);