The joy of functional programming
Download as PPTX, PDF1 like358 views
This document discusses functional programming and its benefits. It begins with an overview of functional programming concepts like pure functions, referential transparency, and immutability. It then covers functional programming techniques like higher order functions, recursion, composition, and pattern matching. Examples are given comparing imperative and functional implementations for quicksort and optional types. The document argues that functional programming leads to cleaner code by improving modularity, testability and adherence to SOLID principles. It recommends starting with functional features in existing languages and learning Haskell to fully embrace the functional paradigm.
![Quicksort In C
void quicksort(int *A, int len) {
if (len < 2) return;
int pivot = A[len / 2];
int i, j;
for (i = 0, j = len - 1; ; i++, j--) {
while (A[i] < pivot) i++;
while (A[j] > pivot) j--;
if (i >= j) break;
int temp = A[i];
A[i] = A[j];
A[j] = temp;
}
quicksort(A, i);
quicksort(A + i, len - i);
}](https://image.slidesharecdn.com/thejoyoffunctionalprogramming-170813045208/85/The-joy-of-functional-programming-19-320.jpg)
![Quicksort in Haskell
quicksort :: Ord a => [a] -> [a]
quicksort [] = []
quicksort (p:xs) = (quicksort lesser) ++ [p] ++ (quicksort greater)
where
lesser = filter (< p) xs
greater = filter (>= p) xs](https://image.slidesharecdn.com/thejoyoffunctionalprogramming-170813045208/85/The-joy-of-functional-programming-20-320.jpg)
![Map
map (x -> x*x) [1, 2, 3, 4, 5]
[1, 4, 9, 16, 25]
map _ [] = []
map f (x : xs) = f x : map f xs](https://image.slidesharecdn.com/thejoyoffunctionalprogramming-170813045208/85/The-joy-of-functional-programming-24-320.jpg)
![Filter
filter even [1..10] [2,4,6,8,10]
filter _ [] = []
filter p (x:xs)
| p x = x : filter p xs
| otherwise = filter p xs](https://image.slidesharecdn.com/thejoyoffunctionalprogramming-170813045208/85/The-joy-of-functional-programming-25-320.jpg)
![Fold (Reduce)
• sum [1, 5, 10] 16
• product [2,3,4] 24](https://image.slidesharecdn.com/thejoyoffunctionalprogramming-170813045208/85/The-joy-of-functional-programming-26-320.jpg)
![sum [] = 0
sum (x:xs) = x + sum xs
product [] = 1
product (x:xs) = x * product xs
concat [] = []
concat (x:xs) = x ++ concat xs
Identify the
similar structure,
abstract the
common pattern](https://image.slidesharecdn.com/thejoyoffunctionalprogramming-170813045208/85/The-joy-of-functional-programming-27-320.jpg)
![foldr
foldr f z [] = z
foldr f z (x:xs) = f x (foldr f z xs)
sum = foldr (+) 0
product = foldr (*) 1
concat = foldr (++) []](https://image.slidesharecdn.com/thejoyoffunctionalprogramming-170813045208/85/The-joy-of-functional-programming-28-320.jpg)
![Function composition
(f . g) x = f (g x)
( sum . take 5 . filter even ) [1..100]
ls -l | grep key | less
functions are Lego bricks, they are easily
assembled](https://image.slidesharecdn.com/thejoyoffunctionalprogramming-170813045208/85/The-joy-of-functional-programming-30-320.jpg)
The joy of functional programming
- 2. About Me • @CiaD team in Scotiabank • I am Passionate about: TDD, XP, Clean Code Software craftsmanship Learning, deliberate practice
- 3. My Journey To Functional Programming
- 4. The Joy of Functional Programming • Pure • Elegant • Powerful
- 5. Anything that is “effectively computable” can be computed by a Universal Turing Machine. - Alan Turing, 1936 Alan Turing
- 6. History
- 8. Alonzo Church λ calculus Anything that is “effectively computable” can be computed by via λ Calculus. - Church 1933, 1935
- 9. λ calculus • Invented by mathematician Alonzo Church in the 1930s • It is anonymous function • Each lambda has single argument • Consists of a single transformation rule - variable substitution
- 11. λ calculus is equivalent to Turing machines Turing machine Lambda Calculus Imperative Programming Functional Programming Assembly C / C++ Java JavaScript OO … Lisp Erlang Haskell Scala F# ….
- 12. Lambda Calculus influences • Lisp (lambda (x) (* x x)) • Ruby lambda { |name| "Hi #{name}!" } • Java 8 isOdd = n -> n % 2 != 0; • JS var multiply = (x, y) => { return x * y }; • Haskell addOne = x -> x + 1
- 13. What is Functional Programming • A Programming paradigm based on functions • Function is a first class citizen - can be a variable - passed as argument - return as a value • Roots in Lambda calculus
- 14. Functional Programming Concepts • Pure functions • Referential Transparency • Immutability • Declarative Programming
- 15. Pure Functions • Came from Math functions, a function is a mapping between input and output • Output value only depends on input value • No external dependencies • Will not update any global state x ↦ f (x)
- 16. Referential Transparency • Same input always get the same result • Every subexpression can be substituted by any other that’s equal to it in value • Easier to reason • RT functions will NOT - print on screen - output logs
- 17. Immutability • Data can’t be changed after it’s been created • No assignment • No shared state
- 18. Declarative Programming • Imperative Programming - uses statements that change a program's state - Focus on how a program operate • Declarative Programming - expresses the logic of a computation without describing its control flow - Focus on what a program achieve
- 19. Quicksort In C void quicksort(int *A, int len) { if (len < 2) return; int pivot = A[len / 2]; int i, j; for (i = 0, j = len - 1; ; i++, j--) { while (A[i] < pivot) i++; while (A[j] > pivot) j--; if (i >= j) break; int temp = A[i]; A[i] = A[j]; A[j] = temp; } quicksort(A, i); quicksort(A + i, len - i); }
- 20. Quicksort in Haskell quicksort :: Ord a => [a] -> [a] quicksort [] = [] quicksort (p:xs) = (quicksort lesser) ++ [p] ++ (quicksort greater) where lesser = filter (< p) xs greater = filter (>= p) xs
- 21. FP techniques
- 22. Functional Programming Techniques • High order function • Recursion • Composition • Lazy Evaluation • Currying • Pattern matching • Algebraic type • Functor • Applicative • Monoid • Monad
- 23. High Order Functions • Function that takes another function as argument • Return function as a result - Map - Filter - Fold (Reduce)
- 24. Map map (x -> x*x) [1, 2, 3, 4, 5] [1, 4, 9, 16, 25] map _ [] = [] map f (x : xs) = f x : map f xs
- 25. Filter filter even [1..10] [2,4,6,8,10] filter _ [] = [] filter p (x:xs) | p x = x : filter p xs | otherwise = filter p xs
- 26. Fold (Reduce) • sum [1, 5, 10] 16 • product [2,3,4] 24
- 27. sum [] = 0 sum (x:xs) = x + sum xs product [] = 1 product (x:xs) = x * product xs concat [] = [] concat (x:xs) = x ++ concat xs Identify the similar structure, abstract the common pattern
- 28. foldr foldr f z [] = z foldr f z (x:xs) = f x (foldr f z xs) sum = foldr (+) 0 product = foldr (*) 1 concat = foldr (++) []
- 29. Conclusion Map / Filter / Reduce can replace almost all the loops
- 30. Function composition (f . g) x = f (g x) ( sum . take 5 . filter even ) [1..100] ls -l | grep key | less functions are Lego bricks, they are easily assembled
- 31. Functions are the building blocks Standard Self-contained Independent Easy to assemble
- 32. Maybe Monad and Null References
- 33. I call it my billion-dollar mistake…. simply because it was so easy to implement. - Tony Hoare, null reference inventor Null References – A Billion-Dollar Mistake
- 34. Java Example
- 35. Imperative way public String getCarInsuranceName(Person person) { if (person != null) { Car car = person.getCar(); if (car != null) { Insurance insurance = car.getInsurance(); if (insurance != null) { return insurance.getName(); } } } return "Unknown"; }
- 36. Java 8 Optional API Optional.of(car) Optional.empty() Optional.ofNullable(car)
- 37. Optional is a Container
- 38. The Functional Alternative public String getCarInsuranceName(Optional<Person> person) { return person .flatMap(Person::getCar) .flatMap(Car::getInsurance) .map(Insurance::getName) .orElse("Unknown"); }
- 39. FP and OO
- 41. The Problem of OO The problem with object-oriented languages is they’ve got all this implicit environment that they carry around with them. You wanted a banana but what you got was a gorilla holding the banana... and the entire jungle. - Joe Armstrong
- 42. Functional core, imperative shell • Core – FP pure functions, business logic • Shell – OO • Separation of concerns https://www.destroyallsoftware.com/talks/boundarie s http://www.mokacoding.com/blog/functional-core-reactive-shell/
- 43. FP and Clean Code
- 44. FP and Simple Design • Functional Programming leads to simple design • Function depends only on input, no external dependencies • Reduce complexity • Easy to compose • Easy to reason
- 45. FP and SOLID Principles • SRP – each pure function has single responsibility • OCP - logics are easy to extend via Function composition, easy to integrate, no glue code • DIP - functions are injected into high order functions • LSP - pure functions are substitutable • ISP - …
- 46. FP makes Unit tests easy Michael Feathers’ Unit Test definition: Should NOT access the file system Should NOT access a database Should NOT access any network resources Should NOT depend on local configuration Pure functions meet these requirements naturally
- 47. FP and Design Patterns • Many design patterns are absorbed into functional programming paradigm: - template method - strategy - chains of responsibility - decorator - command - visitor pattern Functor and Monad
- 48. Conclusion Functional Programming leads to Clean Code we should master the Functional programming
- 50. FP learning path • Start from where you are, begin with lambda - Java 8 - JavaScript ES 6 - Scala • Learn an new FP language, unlearn your past experiences - Haskell
- 51. Learning FP is HARD • A big mindset change – Imperative to Functional • Your past experiences won’t help – unlearn first • Be patient, it takes time Learn Unlearn Relearn
- 53. FP books for JavaScript
- 54. Review The History Again
- 55. “One of our difficulties will be the maintenance of an appropriate discipline, so that we do not lose track of what we are doing.”
- 56. • Take away goto statements Structure Programming • Take away pointersObject Oriented • Take away assignmentsFunctional Programming
- 57. Some Final Thoughts • Functional Programming brings more disciplines to programming • Since Functional Programming is rooted in math, it will change programming from craft to science. • Function Programming will take software craftsmanship movement to the next level
- 58. Q&A
Editor's Notes
- #42: Encapsulation – hide state State mutation and state sharing Mixed data and behavior Hard to manage dependency Hard to compose and decompose