Functional programming uses pure functions that have no side effects to make code more predictable, stable, and easier to test and maintain. It favors immutability over mutable state to avoid side effects. Complex programs are built by composing simple functions together rather than using complex objects. Higher order functions like map, filter, and reduce help avoid loops. Currying allows functions to take parameters one at a time for simpler composition.

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. How do I not use variable?!!!

18. Recursion
Functional Programming uses recursion
to do looping

19. Consider the
following:

20. Consider this
solution:

21. Function “pow” has side effects so
it’s impure…

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

23. 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

24. This is better:

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

26. Higher Order
Functions

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

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

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

32. Function Composition

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

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

37. Currying

38. 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”

39. This sucks…

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

41. Much better :)

42. Common Functional
Functions

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

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

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

49. 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