Functional programming vs OOP: Which paradigm to use

What is functional programming?#

Functional programming is centered around building software composed of functions, similar to procedural programming; however, there are subtle differences. We highlight these differences by discussing key concepts of functional programming below.

First-class citizens#

Functions are treated as primitives. Primitives serve as the simplest elements of a programming language. Thus, a function can be:

• stored in a variable
• passed as an argument
• returned from a function

Since they have these capabilities, functions are referred to as first-class citizens. The term first-class citizen essentially notates an element that supports all other generally available operations.

Pure functions#

A goal of functional programming is to write pure functions whenever possible.

A pure function does not change the global state of the program and therefore is said to have no side effects. Instead, its return value is solely based on its input parameters.

Pure functions enable numerous compiler optimizations, leading to significantly reducing a program’s execution time. Furthermore, pure functions are ideally suited for unit testing. We can unit-test a pure function in isolation without having to worry about where in the code it will be used.

Higher-order functions and recursion#

Instead of iterative loop constructs, such as for and while, in functional programming, we use higher-order functions and tail calls for a recursive loop.

A higher-order function takes a function as its input, performs an operation on the input function, and subsequently returns a function.

A tail call refers to a function call at the end of a function. A tail call may result in a recursive loop when a function calls itself. Many compilers perform tail call optimization (a.k.a. tail call elimination) making recursion as fast as iterative loops.

Key reasons for preferring recursion over typical primitive loops are:

• simplicity of code
• avoiding mutable objects to make code more robust

Immutability#

Immutability is the permanence of a variable once the data is assigned to it.

No value assigned to a variable in functional programming can be changed; the only way to change a value is to create a new variable. It is immutability that enables functional programming to use pure functions. These functions do not mutate their inputs and rely on nothing but the input to achieve results. In this way, functional programming is similar to math. Functional programming was even created for an academic computer science setting through the Haskell language.

In summation, functional programming is a declarative programming model that communicates what the program does without specifying the flow of control. It uses pure functions, immutable variables, and tail-call recursion. This results in code that is easier to understand, debug, and unit-test. Furthermore, functional programming enables numerous compiler optimizations for an increase in a program execution speed and reduction in memory requirements.

What is object-oriented programming?#

In contrast to functional programming, object-oriented programming (OOP) is an imperative paradigm. This means that the code describes how the program should achieve a result in a step-by-step process. These statements procedurally change the program’s state.

The term state, in OOP, refers to any set values plus the alterations made to them over the course of the program.

Object-oriented programming groups related functions and their variables into objects. In an object, functions are referred to as methods and variables are referred to as properties.

For example, this figure represents how OOP may represent a car as a group of properties and methods.

When to use object-oriented or functional programming#

Some programming languages only allow for one particular paradigm. For example, Haskell is by definition a functional programming language because its state cannot mutate. Other primarily functional programming languages include Lisp, F#, and Erlang. Some OOP languages, or languages that lean more toward the object-oriented paradigm are Java, C#, and C++. Several programming languages, such as TypeScript and Python, are multi-paradigm and support both OOP and functional programming to some capacity. These languages have certain allowances to utilize pure functions, and immutable objects at the developer’s will.

Python is one of the most popular languages, and it represents a middle-ground on this spectrum of mutable to immutable or object-oriented to functional. Python has built-in types that are immutable: strings, numbers, and Booleans, to name a few. Custom classes in Python, however, are typically mutable data. With a language like Python, it is almost entirely up to the programmer as to what paradigm they use primarily.

OOP is currently the paradigm used by most developers, mostly for its accessibility. Functional programming is great for the server side of applications, data manipulation, and web crawling. For example, all of Facebook’s spam filtering was built using functional programming in Haskell. For the most part, there is no clear-cut answer as to what paradigm will serve you best in your software development education and career. Good software engineers use techniques and habits that can be prescribed to both object-oriented programming and functional programming.

Even if you primarily code in an OOP environment it can benefit you to implement some functional programming constraints. In doing so, you may find that your code is clearer and easier to debug. One of the biggest barriers to making an effective, easy-to-use API is repetitive code, so learning and practicing functional programming concepts now may pay dividends in the future.

When deciding what paradigm to develop a new program in, it can be beneficial to create a roadmap for how the program may change in the future. If your program has a set number of operations to be performed on entities, and you intend to grow the application by adding more entities, an object-oriented approach makes the most sense. If instead, you have a fixed number of entities and intend to add more operations, functional programming will create fewer problems during scaling.

Wrapping up and next steps#

At its simplest, functional programming uses immutable data to tell the program exactly what to do. Object-oriented programming tells the program how to achieve results through objects altering the program’s state. Both paradigms can be used to create elegant code. From an OOP perspective you may be sculpting something out of clay, modeling it after the real world. Through functional programming it more closely resembles stacking building blocks together to eventually create a cohesive piece.

So where should you go from here? If you want help acing an object-oriented programming job interview you can check out the course: Grokking the Low Level Design Interview Using OOD Principles

Happy learning!