In this session we will go over the fundamentals of functional programming and see how functional programming can help make our code more reusable, stable, scalable and fun.

1. Functional Programming
by Assaf Gannon

2. Why Do We Need to Change
The Paradigm?!
Object Oriented Programming
is Awesome!

3. OOP is not cutting
it

4. Testability
Require lots of mocking
Extensive environmental setup
Hard to maintain as the objects
evolve

5. Complexity
Tendency to over-design
Re-Use is often complicated and
requires frequent refactoring
Often Objects DON’T represent the
problem correctly

6. Concurrency
Objects naturally live in a shared
state environment
Multiple Objects in a shared state
environment handle concurrency
poorly

7. Enter Functional
Programming!

8. Why Functional?!
Mathematical approach to solving
problems
More simple and less abstract
Easy Reuse, Test and handle
Concurrency

9. FP Principles
Purity
Immutability
High Order
Composition
Currying

10. Purity

11. Pure Function
Pure functions act on their
parameters
Are not efficient if not returning
anything
Will always produce the same output
for the given parameters
Have NO side affects

12. Pure Function

13. ImPure Functions

14. Immutability

15. There are no “Variables” in Functional
programming - all “variables” should
be considered as constants

16. When Do we mutate
variables?
Short living “local” variables
Loop flow structures
State objects

17. Javascript is Not a
pure functional
programming
language - it allows
for mutable
structures. We need
to “tweak” it…

18. Simple Immutable
tweaks
arr.push(val) —> [].concat(arr, val)
obj[‘key’] = val —> Object.assign({key: val}, obj)
ImmutableObj = Object.freeze(obj)
** Object assign is limited to shallow cloning and
may produce strange outcomes.
see:
https://developer.mozilla.org/en-US/docs/Web/
JavaScript/Reference/Global_Objects/Object/create

19. For “real” projects use an immutable
library such as ImmutableJS or
seamless-immutable

20. Higher Order Functions

21. In Functional Programming, a
function is a first-class citizen of the
language. In other words:
A function is just another value

22. Higher Order
Functions
Take functions as parameters
Return functions
Both

25. A closure is a function’s scope that’s
kept alive by a reference to that
function.

26. Function Composition

27. newFunc = f(g(x))
Application of one function to the
result of another to produce a third
function

29. A Problem
Write a composed function that does
text Capitalization:
“the FORCE is strong with YOU” —>
“The Force Is Strong With You”

31. Composition
h = f(g(x))

33. Enhanced
Capitalize Problem
I want to ignore a list of words:
a, is, for, etc. so:
“the FORCE is strong with YOU” —>
“The Fore is Strong With You”

34. This sucks…

35. Currying

36. A Curried Function is a function that
only takes a single parameter at a
time.

37. Much better :)

38. Common Functional
Functions

39. Map
Creates a new array with the results
of calling a provided function on
every element in the array

41. Filter
Creates a new array with all
elements that pass the test
implemented by the provided
function

43. Reduce
Applies a function against an
accumulator and each value of the
array (from left-to-right) to reduce
it to a single value

45. Summary
Use “Pure” functions to create predictable &
stable code
Use Immutable structs to avoid side effects
Compose complex functionality from
simple building blocks
Use currying for simple composition
Avoid “boilerplate” code and loops by using
functional functions