Introduction to Functional Programming

Thinking in Functions

Most programming is about giving the computer a series of commands. First, do this. Next, do that. Then, if this other thing is true, change that variable. This step-by-step approach is called imperative programming. It's like giving a friend detailed, turn-by-turn directions to get to your house.

Functional programming (FP) takes a different view. Instead of a list of commands, it treats computation as the evaluation of mathematical functions. It's less about the step-by-step process and more about defining the relationships between inputs and outputs. You tell the computer what you want, not how to do it. It's like giving your friend the address and letting their GPS figure out the route.

In functional programming, functions are first-class citizens. This means they can be treated like any other value: passed as arguments to other functions, returned from functions, and stored in variables.

Pure Functions and No Surprises

The heart of functional programming is the pure function. A function is considered pure if it meets two strict criteria:

Predictable Output: Given the same input, it will always return the same output. The function add(2, 3) will always, without fail, return 5.
No Side Effects: It doesn't change anything outside of its own scope. It won't modify a global variable, write to a file, or change the data it was given.

Think of a pure function like a vending machine that has an infinite supply of every item. If you press B4 for a soda, you will always get a soda. It doesn't matter how many times you do it or what buttons you pressed before. An impure function is like a vending machine with limited stock. Your first press of B4 gets you a soda. Your second might get you nothing, because the state of the machine (its inventory) has changed.

This no-surprises approach makes code much easier to reason about. You can look at a pure function and know exactly what it does without worrying about hidden dependencies or external state changes. This makes your programs more reliable and easier to test.

Data That Doesn't Change

Closely related to pure functions is the concept of immutability. In simple terms, it means that once data is created, it cannot be changed.

This might sound restrictive, but it's incredibly powerful. Instead of modifying an existing piece of data (like an array or an object), you create a new one with the updated values. The original remains untouched.

Imagine you have a list of tasks. In an imperative style, you might remove a completed task by deleting it directly from your list. In a functional style, you would create a new list that contains all the tasks except the one you completed. The original list is still there, unchanged.

Immutability eliminates a whole class of bugs where data is changed unexpectedly, leading to unpredictable behavior in different parts of a program.

By combining pure functions and immutable data, you build programs that are more like a series of transformations. Data flows in, gets transformed by functions, and new data flows out, without ever destructively changing the original information.

What vs How

This all leads to a more declarative style of programming. You focus on describing what result you want, rather than detailing the step-by-step process of how to achieve it.

Let's say you have a list of numbers and you want a new list containing only the even ones. An imperative approach would be:

Create an empty list called evens.
Loop through each number in the original list.
For each number, check if it's divisible by 2.
If it is, add it to the evens list.
After the loop, return the evens list.

function getEvens(numbers) {
  const evens = [];
  for (let i = 0; i < numbers.length; i++) {
    if (numbers[i] % 2 === 0) {
      evens.push(numbers[i]);
    }
  }
  return evens;
}

The declarative, functional approach is much more direct. You simply state your intention: "Filter the list of numbers, keeping only the ones that are even."

function getEvens(numbers) {
  return numbers.filter(num => num % 2 === 0);
}

The second example is shorter, easier to read, and less prone to errors like off-by-one mistakes in a loop. You declare your goal, and the underlying functions handle the implementation details.

These core ideas—pure functions, immutability, and declarative code—form the foundation of functional programming. They encourage you to build more predictable, modular, and maintainable software.

Let's check your understanding of these foundational principles.

Quiz Questions 1/5

Which statement best describes the core difference between imperative and functional programming?

Quiz Questions 2/5

A pure function must satisfy two specific criteria. What are they?

By embracing these concepts, you can write code that is not only powerful but also elegant and easier to manage.

Introduction to Vibe Programming