I like to think of Functional Programming as another level of abstraction that pulls code further away from the physical machine, much like how automatic memory management once hid raw memory addresses from the developer. To me, Functional Programming is a guide for building applications without the need for manual memory assignments.

It is all about Immutability

What is the problem with memory assignment, or more specifically, mutable data?

In a world where software runs in parallel, shared mutable states are a massive problem. Countless solutions have been built to address this, but they usually involve synchronization, locks, and waiting – all of which lead to performance and scalability bottlenecks.

Another way to solve the problem is to avoid it entirely by writing software without shared mutable states. This means using exclusively immutable data structures. In this context, a paradigm that thrives on immutability becomes very attractive. Functional Programming fits this role perfectly; it acts as a discipline that abstracts software away from the constant need for memory assignments.

Be Functional

The core principle of Functional Programming is transformation: a function takes an input, applies a logic, and returns an output. This approach has the same expressive power as imperative code but offers tools and patterns that guide developers to work within this different paradigm.

Let’s compare an imperative example of finding the maximum value in a list with a functional version:

Imperative Approach:

List<Integer> list = Arrays.asList(3, 6, 5);
int max = Integer.MIN_VALUE;
for (int value : list) {
  if (value > max) max = value;
}

In this example, the imperative code uses a max variable to store and update the result.

Functional Approach:

int calculateMax(List<Integer> list, int max) {
  if (list.isEmpty()) return max;
  else {
    int head = list.get(0);
    List<Integer> tail = list.subList(1, list.size() - 1);
    int newMax = head > max ? head : max;
    return calculateMax(tail, newMax);
  }
}
List<Integer> list = Arrays.asList(3, 6, 5);
calculateMax(list, Integer.MIN_VALUE);

While the imperative version relies on re-assignment, the functional version relies on passing the state through parameters. Concepts like pipelines, higher-order functions, and composition simply make this data transformation more efficient and easier to manage.

Be Pure

An entire application can be viewed as a single, massive function. Since a thousand-line function is obviously bad practice, we modularize: functions are composed to create larger transformations. Simply put, composition is using the output of one function as the input for the next.

int f(double input) { ... }
String g(int input) { ... }
String output = g(f(1.2));

Pure functions are functions with no side effects. This means every observable effect is contained within the output. When you compose functions, the output defines the “interface” between them. If a function throws an unhandled exception, it breaks that interface and falls out of the transformation flow.

Be Typed

A typed language helps define a function’s signature. The more precise the type, the safer the composition. The type system acts as the contract between functions, allowing the compiler to handle a significant portion of the software validation for you.