Data-Oriented Programming vs. Functional Programming

You've been diving into Data-Oriented Programming (DOP), and you're asking how it relates to Functional Programming (FP). Both share some philosophical ground, but they attack complexity differently.

🔹 1. The Common Ground

Both DOP and FP push back against the complexity of classic OOP:

• No data hiding → Both want data to be transparent and easy to manipulate.

  • FP: Uses immutable data structures, passed explicitly.
  • DOP: Structures data in memory for locality and clarity.

• Pure data separation → Code and data are clearly separated.

  • FP: Functions take inputs (data) and return outputs (data).
  • DOP: Data lives in flat structures, and operations are external to it.

• Predictability → Both emphasize reducing "spooky action at a distance."

  • FP: Eliminates side effects (or isolates them in monads/contexts).
  • DOP: Eliminates hidden relations between objects by exposing raw data.

🔹 2. Where They Differ

While both paradigms share common ground in rejecting OOP complexity, they approach problems from fundamentally different angles:

• Goal Orientation

• DOP: Prioritizes performance through optimized data layout and memory locality
• FP: Emphasizes correctness through immutable data flow and pure functions

• Core Building Blocks

• DOP: Centers around arrays, structs, SoA (struct-of-arrays), and data pipelines
• FP: Built upon functions, higher-order operations, immutability, and recursion

• Execution Characteristics

• DOP: Typically imperative, cache-conscious, and designed for SIMD compatibility
• FP: Generally declarative, with lazy or eager evaluation through transformation pipelines

• Approach to State Changes

• DOP: Permits mutation when beneficial for throughput, but in controlled manner
• FP: Strongly favors immutability using persistent data structures

🔹 3. How They Connect in Practice

The connection is that FP can be a high-level style for expressing data transformations, and DOP can be the low-level way of implementing them efficiently.

Example: processing a list of entities

FP-style:

// Immutable transformation
const newEntities = entities
    .filter(e => e.health > 0)
    .map(e => ({ ...e, x: e.x + e.vx, y: e.y + e.vy }));

DOP-style:

// Data-oriented layout (arrays of fields)
const xs = new Float32Array(count);
const ys = new Float32Array(count);
const vxs = new Float32Array(count);
const vys = new Float32Array(count);
const healths = new Int32Array(count);

// Imperative, cache-friendly loop
for (let i = 0; i < count; i++) {
    if (healths[i] > 0) {
        xs[i] += vxs[i];
        ys[i] += vys[i];
    }
}

Here:

• FP expresses what transformations to apply (clean semantics)
• DOP implements how to do it efficiently (raw control over memory)

🔹 4. The Philosophical Link

Both reject OOP's entanglement of code and state.

• FP: "Data is immutable, transform with functions."
• DOP: "Data is raw and central, operations are external and independent."

So in a way:

DOP is "FP at the hardware level." It's about bringing the same clarity of separation but tuned for the CPU and memory hierarchy.