Concepts In Functional Programming

Episode Breakdown

12:55 The Functional Paradigm

The functional paradigm uses expressions or declarations rather than statements. Expressions are combinations of values and functions that are computed to produce another value. In functional programming the result of an expression can be another function to be evaluated.

Computation is treated as the evaluation of mathematical functions. This avoids changing state or mutable data. Outputs are always the same with the same inputs and are not state dependant.

“If you think of this as something bolted onto algebra it makes a lot more sense.”

One of the biggest advantages of functional programming is the ability to run programs concurrently. When a function can change an object’s state it can be a mess for concurrency if the state is not managed properly.

16:29 Based on Lambda Calculus

“It’s meta math.”

All functions can be written anonymously. The only thing effecting the function is the arguments passed into it. This is where Lambda (anonymous) functions get their name.

All functions go through currying. When invoked with multiple arguments a function will only set one variable in the list. Then it returns a function with one less argument that is immediately invoked. This only works because state changes cannot effect the pure function.

“It’s something that makes sense given the other restrictions.”

Lambda calculus and therefore functional programming contain free and bound variables. A bound variable is bound to the lambda expression and can be replaced by any input. A free variable is a variable within the expression that is not effected by the input. Beta reductions is the concept that bound variables can be replaced by the inputs they represent.

22:07 Functions Are Pure

A function called with the same input will always have the same output. The function works the same independent of state. If you call add(2,2) it will always return 4 regardless of big brother.

“If you change the state of the program it’s going to give you the same output given the same inputs.”

No side effects occur. A side effect is the modification of something outside the scope of a a function such as modifying a global variable, raising an exception, writing to a file, or even reading data. This is the most common way programs interact with the outside world.

25:15 Variables Are Immutable

“In other words variables…don’t!”

Variables cannot be modified after initialization. Once it’s set, it’s set. This maintains state throughout runtime. However, you can create new variables. The constructor is the only way to mutate state by creating a new variable, the new variable will not change either once initialized.

27:00 Functions are First-Class and Higher-Order

This is not exclusive to functional but required for it. First-class functions can be set to a variable. They treat the function like a normal data type and execute it at another point in runtime.

“A variable is a function, basically.”

Higher order functions accept or return a function. For example, map functions that iterate over a list, modify data, and return new list. Or filter functions that return a new list of selected items

31:20 Referential Transparency

You can replace a function with the value it returns everywhere in a program and the state of the program will not change. Take all the instances where you call a function and replace them with the output of that function. To be referentially transparent there should be no changes when this is done.

33:07 How do you write to a database or file system?

“Most of what I code is a functional/object oriented blend.”

Be pragmatic in don’t write pure functional code. Write the code that works. Functional, object oriented, and procedural are all paradigms or ways of thinking about or structuring your code. To be effective you’ll need to combine paradigms at times.