functional programming vs. imperative programming

 

The core difference between imperative and functional programming lies in how you approach a problem: imperative focuses on the steps (how to do it), while functional focuses on the results (what it is).

---

1. Imperative Programming: The "Recipe" Approach

Imperative programming is like a cooking recipe. You give the computer a sequence of specific instructions that update the "state" of the program (like changing the value of a variable).

Key characteristics:

• Uses loops (for, while).

• Uses mutable variables (variables that change over time).

• Focuses on the explicit control flow.

Example: Summing an array of numbers

In an imperative style (using C-like logic), you create a "bucket" for the sum and manually iterate through the list to update that bucket.

Perl

 

# Imperative approach
my @numbers = (1, 2, 3, 4, 5);
my $total = 0; # State that changesfor my $num (@numbers) {$total += $num; # Explicitly updating the state
}print $total; # 15

---

2. Functional Programming: The "Mathematical" Approach

Functional programming treats computation as the evaluation of mathematical functions. It avoids changing state and mutable data.

Key characteristics:

• Uses recursion or higher-order functions (map, filter, reduce) instead of loops.

• Uses immutable data (once a value is set, it doesn't change).

• Focuses on expressions rather than statements.

Example: Summing an array of numbers

In a functional style, you describe the sum as a reduction of the list. You don't manage a counter or a temporary total; you apply a transformation.

Perl

 

# Functional approach
use List::Util qw(reduce);my @numbers = (1, 2, 3, 4, 5);# The 'reduce' function combines elements without an explicit loop
my $total = reduce { $a + $b } @numbers;print $total; # 15

---

Comparison Table

Feature	Imperative	Functional
Primary Goal	Command execution (How)	Evaluating expressions (What)
State	Changes frequently (Mutable)	Avoided (Immutable)
Control Flow	Loops, conditionals, and jumps	Function calls and recursion
Side Effects	Common (changing a global var)	Minimized or isolated
Example Language	C, Fortran	Haskell, Lisp, Erlang

Real-World Analogy

• Imperative: "Go to the kitchen. Open the fridge. Grab the milk. Pour it into a glass. Bring the glass to me."

• Functional: "I would like a glass of milk." (The implementation of how to get the milk is handled by a function that always returns a glass of milk given the context of a kitchen).