Functional Programming

Question 1

What is the purpose of Functional programming?

Answer 1

Data separation
Idea of separation
Data and the effects

Question 2

What are Pure Functions?

Answer 2

A pure function has no side effects on anything outside of it and, given the same input, will always output the same value.

Build lots of minimal, reusable and predictable pure functions that do the following:
• Complete 1 task per function.
• Do not mutate state.
• Do not share state.
• Be predictable.
• Be composable, with one input and one output.
• Be pure if possible.
• Return something.

// Impure:
const array = [1,2,3];
function mutateArray(arr) {
arr.pop()
}

Question 3

What is Idempotence?

Answer 3

Idempotence is another critical piece of functional programming. It is the idea that given the same input to a function, you will always return the same output.
The function could be used over and over again, and nothing changes. This is how you make your code predictable.

Question 4

What is Referential transparency?

Answer 4

A critical concept of functional programming is referential transparency, the ability to replace an expression with the resulting value without changing the result of the program.

Question 5

What difference is Imperative vs Declarative?

Answer 5

Imperative programming tells the computer what to do and how to complete it.
Declarative programming only tells the computer what to do, not how to do things.

// more imperative
for (let i = 0; i < 10; i++) {
}
console.log(i);

// more declarative
let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
arr.forEach(item => console.log(item));

Question 6

What is Immutability?

Answer 6

Immutability is simply not modifying the original data or state. Instead, we should create
copies of the state inside our functions and return a new version of the state.

// Bad code
const obj = {name: ‘Brittney’}
function clone(obj) {
return {…obj} // this is pure
}
obj.name = ‘Joe’ //mutated the state

// Better code
function updateName(obj) {
const newObj = clone(obj)
newObj.name = ‘Joe’
return newObj
}
const updatedNameObj = updateName(obj)
console.log(obj = ${obj}, `updatedNameObj = ${updatedNameObj})

Question 7

What is HOF?

Answer 7

Higher order function is a function which returns or takes a parameter as function or both.

Question 8

What happens during clone with the spread?

Answer 8

A new clone is created

You may be thinking that this could get really expensive, memory-wise, to just copy code over and over. However, there is something called structural sharing that allows the data to only copy new information and points to the original state for any commonalities.

Question 9

What is structural sharing?

Answer 9

Structural sharing provides an efficient way to share data between multiple versions of it, instead of copying the whole data.

https://dev.to/viebel/structural-sharing-with-7-lines-of-javascript-2dnh

Question 10

Can closure be a HOF?

Answer 10

Yes, it can be a higher order function

Question 11

What is currying?

Answer 11

Currying is an advanced technique of working with functions. It’s used not only in JavaScript, but in other languages as well.
Currying is a transformation of functions that translates a function from callable as f(a, b, c) into callable as f(a)(b)(c).

Question 12

What is partial application?

Answer 12

Partial application is expanding on the idea of currying and taking it a step farther by separating a parameter out.

const multiply = (a, b, c) => a * b * c;
const curriedMultiplyBy5 = multiply.bind(null, 5); // this is null
curriedMultiplyBy5(4, 10); // 200

Question 13

What is Pipe?

Answer 13

A pipe function is a function that accepts a series of functions, which process an input parameter and return a output which will be the input for the next function.

Example: const pipe = (fn1, fn2) => data => fn2(fn1(data));

Question 14

What is compose?

Answer 14

It’s just pipe in the other direction.

const compose = (fn1, fn2) => data => fn1(fn2(data));

Question 15

What is The Pipeline Operator ? |>

Answer 15

// without pipeline operator
double(increment(double(double(5)))); // 42
// with pipeline operator

5 |> double |> double |> increment |> double; // 42

Question 16

What is Arity?

Answer 16

Arity simply means the number of arguments a function takes. The more parameters a function has, the harder it becomes to break apart and reuse. Try to stick to only 1 or 2 parameters when writing functions.

Question 17

What is Composition?

Answer 17

Composition is we do with functional programming, creating small reusable function to make code modular.

Question 18

What are the drawbacks for OOPS?

Answer 18

One of the drawbacks to inheritance is that it is based on the fact that it won’t change, we tell it what it is. We create a class and give it properBes and methods that describe the class. But say, down the road, we need to update that class and add more funcBonality. Adding a new method to the base class will create rippling effects through your enBre program. FP is more declaraBve, what to do not how, and OOP is more imperaBve, what and how to do something. This is the Aght coupling problem, things having to depend on one another, which leads to the fragile base class problem, seemingly safe changes cause unforeseen repercussions. It is the opposite of small reusable code. Changing one small thing in either of the class or subclasses could break the program. Another problem is hierarchy where you may need to create a subclass that can only do 1 part of the class, but instead you get everything passed down to it.