From My Notebook: Object Oriented Programming vs Functional Programming

Like most recently graduated programmers, I’ve spent most of my time learning and working within the object oriented programming paradigm. Classes I took at UCI touched on concepts of functional programming, but at the end of the day it has always come back to OOP. In my mind, OOP was just “regular” programming, and functional programming was some odd-ball topic to be explored another day. Well, that day is today.

I finally took the time to sit down, get Googling, and read up on the topic until I felt like I had a good basic understanding of it. What follows is a transcription of my hand-written notes as well as some examples that may help clarify the concepts. I can’t take credit for this – besides the pure/impure function examples, it’s all taken from various sources I personally found useful. As I learned about functional programming, I found that there isn’t a single definition. It’s a broad paradigm, so different people have different ways of talking about it. Because of all thse varying perspectives, I thought it would be valuable to have a compilation of information I found. At first it was just stored for my own sanity, but I figured I’d make it public in case it’s useful to somebody else down the line. Sources are linked at the bottom.

Paradigm Comparison

	Object Oriented Programming	Functional Programming
Philosophy	Having data and its behavior in a single location makes it easier to understand how a program works (encapsulation)	Data and behavior are distinctly different things and should be kept separate for clarity
What is it?	Everything is built upon objects, which... Contain data (attributes) Contain code (methods) that can access and modify data Have a notion of self (this) Seeks to mimic real life Imperative: tell the computer how to do something	Complete separation of data and behvior Objects are immutable Shared state is avoided Uses only pure functions Return value varies based only on input No side effects Does not alter data it is given -- only generates output based on the input Declarative: tell the computer what you want to be done
When to use it	You have a fixed set of operations on various things As your code evolves, you will mostly be adding new things, not new operations This can be easily done with classes	When you have various operations working on a fixed set of things As your code evolves you will mostly be adding new operations on existing things Can be easily added with (pure) functions
Pros	Can be easier to build a mental model for, since it more closely mirrors real life Code can be read and analyzed as step-by-step instructions Encapsulating data and the operations that work on that data can make it more clear what the operations are doing	Eliminates "clutter" from loops, indices, etc. Makes code more concise and easier to digest quickly (provided you understand the syntax) Less likely to introduce bugs from simple coding errors Avoids side effects and mutable state Easier to keep track of state in very large applications Makes parallel processes easier to manage, since they do not have to worry about values being changed by another process (avoids race conditions) Can refactor/optimize with confidence, since only output matters
Cons	If you ever need to add new functionality, you will likely need to change many objects Race conditions can be a pain to handle because of shared state Can lead to verbose, tiring to read code	If you ever need to add new objects, you will need to modify many functions to account for the new case Can be memory intensive because objects are constantly being created whenever a state change is needed Because it is not read as line-by-line instructions, it can actually decrease readability for those not familiar with the syntax

Examples

Pure vs Impure Functions

Pure

For a given argument, a pure function will always return the same value. It does not depend on anything that can change (i.e. anything that is mutable). A pure function also does not have any side effects – even thing as simple as logging to the console.

function multiplyByTwo(a) {
    return a * 2;
}

Impure

The following (admittedly quite contrived) function is impure for two reasons. The value that gets returned depends on an external mutable value, and it also has the side effect of logging to the console. It would also be impure if it changed the value of someNumber.

var someNumber = 2;
function multiplyGlobalAndLog(b) {
    console.log("Multiplying: " + b + " and " + someNumber)
    return b * someNumber;
}

Imperative vs Declarative

Imperative

Using an imperative approach, your code describes how to do something. (i.e. “Loop through the length of this array, and for each item at a particular index multiply it by 3 and add it to this array.”)

// triple the value of every element in a given array
const triple = (arr) => {
  let results = []
  for (let i = 0; i < arr.length; i++){
    results.push(arr[i] * 3)
  }
  return results
}

// sum all the elements in a given array
const sum = (arr) => {
  let result = 0
  for (let i = 0; i < arr.length; i++){
    result += arr[i]
  }
  return result
}

Source: Javascript and Functional Programming: An Introduction

Declarative

Using a declarative approach, your code describes what you want to do. (i.e. “Multiply each item in this array by 3.”)

// triple the value of every item in a given array
const triple = (arr) => arr.map((currentItem) => currentItem * 3)

// sum all the elements in a given array
const sum = (arr) => arr.reduce((prev, current) => prev + current, 0)

Source: Javascript and Functional Programming: An Introduction

Only the Surface

This is only a very shallow overview of a complex topic. Just on this topic alone, there’s still a ton of information that I did not get to touch on – and this is before I even properly try my hand at functional programming! As I learn more I’ll update this post, or make a new one if the topic is deep enough to merit it.

Sources

Norman Ramsey, Green Harry (Stack Overflow)

Sho Miyata (Medium)

Omer Goldberg (Hacker Noon)

Alex Holderness (Hacker Noon)

Chris Hokamp (Quora)

Darrick Mckirnan (Medium)