DEV Community

Cover image for Why Functional Programming vs. Imperative/OOP Matters
Asad Ch
Asad Ch

Posted on

Why Functional Programming vs. Imperative/OOP Matters

Functional programming (FP) emphasizes what you want—transforming data via pure functions—whereas imperative or object‐oriented (OOP) code focuses on how to modify state step by step. Below is a tiny comparison showing how the same task looks in each style:

1. Mapping over a list

Imperative (JavaScript):

const nums = [1, 2, 3, 4];
let doubled = [];
for (let i = 0; i < nums.length; i++) {
  doubled.push(nums[i] * 2);
}
console.log(doubled); // [2, 4, 6, 8]
Enter fullscreen mode Exit fullscreen mode

Functional (JavaScript):

const nums = [1, 2, 3, 4];
// “map” declares *what* we want: double each element
const doubled = nums.map(x => x * 2);
console.log(doubled); // [2, 4, 6, 8]
Enter fullscreen mode Exit fullscreen mode

Notice how the FP version avoids manual loops and in‐place mutations. You simply describe “map each element to x * 2.”

2. Filtering objects

Imperative (Python):

people = [
    {"name": "Alice", "age": 17},
    {"name": "Bob",   "age": 22},
    {"name": "Cara",  "age": 15},
    {"name": "Dan",   "age": 30}
]
adults = []
for person in people:
    if person["age"] >= 18:
        adults.append(person)
print(adults)
# [{'name': 'Bob', 'age': 22}, {'name': 'Dan', 'age': 30}]
Enter fullscreen mode Exit fullscreen mode

Functional (Python):

people = [
    {"name": "Alice", "age": 17},
    {"name": "Bob",   "age": 22},
    {"name": "Cara",  "age": 15},
    {"name": "Dan",   "age": 30}
]
# “filter” declares *what* we want: only those age ≥ 18
adults = list(filter(lambda p: p["age"] >= 18, people))
print(adults)
# [{'name': 'Bob', 'age': 22}, {'name': 'Dan', 'age': 30}]
Enter fullscreen mode Exit fullscreen mode

Again, FP avoids manually managing a loop and a separate “append” step: you focus only on the filtering logic.

3. Computing a factorial

Imperative/OOP (Java):

public class Factorial {
    public static int factorial(int n) {
        int result = 1;
        for (int i = 2; i <= n; i++) {
            result *= i;
        }
        return result;
    }
    public static void main(String[] args) {
        System.out.println(factorial(5)); // 120
    }
}
Enter fullscreen mode Exit fullscreen mode

Functional (Haskell):

-- “recursion” and no mutable state
factorial :: Integer -> Integer
factorial 0 = 1
factorial n = n * factorial (n - 1)

main = print (factorial 5)  -- 120
Enter fullscreen mode Exit fullscreen mode

In Haskell’s FP style, there is no mutable result variable. You define the base case (0 → 1) and a single recursive rule (n → n * factorial (n-1)), clearly expressing what the factorial is.

Why This Comparison Matters

  • Readability & Maintainability: FP code often ends up shorter and more declarative. You see immediately “map these numbers” or “filter these objects” without scanning loop constructs.
  • Fewer Side Effects: By relying on pure functions and immutable data, FP reduces bugs caused by inadvertent state changes—a huge win in concurrent or serverless environments.
  • Testability: Pure functions with no hidden dependencies are easy to test in isolation. Imperative/OOP code often requires setting up state or mocking objects before testing.

❓ Want to dive deeper? In my full blog post I cover:

  • Core FP concepts (pure functions, immutability, higher‐order functions, lazy evaluation)
  • A survey of popular FP languages (Haskell, Scala, F#, JavaScript, Python) and real‐world use cases
  • Practical tips for bringing FP thinking into your existing JavaScript or Python projects

👉 Read the full comparison (with more code examples and diagrams) here:
Top Functional Programming Languages Overview - Devscall

Top comments (0)