Learnings From Functional Programming

Journey to learn the basic concepts of Functional Programming.
Short intro and examples on Category Theory and some real life examples of its applications
Step into some core fundamentals of Functional Programming
Introduce function composition whereby composition is an aspect inherited from Category Theory

Transcript

1. Learnings From Functional Programming
2. Motivations You will write better code! Better understanding of RxJava Kotlin is a Functional Language Your code will be more robust It’s the next BIG thing!
3. Journey Reading! Reading! Reading! Category Theory? Application to FP Arrow Framework It’s a Long Long Road Brain Damage Brain Damage
4. Category Theory
5. Category Theory Eugenia Cheng - “Category Theory is the mathematics of mathematics and mathematics is the logical study of how logical things work” Daniela Sfrigola - “Category Theory is about how things compose” Bartosz Milewski - “Category Theory is the science of composition and abstraction”
6. Example 1 - London Underground
7. Example 1 - London Underground
8. Example 2 - Family Tree
9. Basis of Category Theory • Study relationships rather than characteristics • A lot can be learned from object interactions
10. Basis of Category Theory A category consists of • Some objects A, B, C • Some morphisms • Compositions and identities • Associativity and unit laws
11. Objects and Morphism A B
12. Composition A B C Is the mother of Is the mother of Is the grandmother of
13. Composition A B C Is the mother of Is the mother of Is the grandmother of Composition allows you to deduce arrows that can be omitted
14. Associativity A B mother of grandmother of C mother of D mother of great-grandmother of
15. Associativity A B mother of grandmother of C mother of D mother of great-grandmother of
16. Associativity The grandmother of my mother is the mother of my grandmother
17. Sameness Mathematics is all about equations
18. Sameness All equations are lies…
19. Sameness All equations are lies… or useless
20. Sameness All equations are lies… or useless 8 + 1 = 1 + 8 2 x 5 = 5 x 2 (8 + 5) + 5 = 8 + (5 + 5)
21. Sameness All equations are lies… or useless 8 + 1 = 1 + 8 2 x 5 = 5 x 2 (8 + 5) + 5 = 8 + (5 + 5) The only equation that is not a lie is x = x
22. Lessons From Category Theory • Everything should be understood in context • Everything should be studied in relationship with other things, not in isolation
23. Functional Programming With Kotlin
24. Journey Learning FP is like starting from scratch… Not completely but effectively
25. What is Functional Programming (FP)? It is a way of thinking in order to build software
26. Principles of Functional Programming Pure Functions Immutability Avoid Shared State Explicitness
27. Principles of Functional Programming Pure Functions Immutability Avoid Shared State Explicitness
28. Principles of Functional Programming Pure Functions Immutability Avoid Shared State Explicitness
29. Principles of Functional Programming Pure Functions Immutability Avoid Shared State Explicitness
30. Pure Functions • Given some inputs, the output is always the same • No side effects • Predictable and easy to test
31. Pure Functions • Given some inputs, the output is always the same • No side effects • Predictable and easy to test
32. Pure Functions • Given some inputs, the output is always the same • No side effects • Predictable and easy to test
33. Pure Functions fun add(x: Int): Int { val y: Int = readNumFromFile() return x + y }
34. Pure Functions fun add(x: Int): Int { val y: Int = readNumFromFile() return x + y }
35. Pure Functions fun add(x: Int, y: Int): Int { return x + y }
36. Pure Functions fun add(x: Int, y: Int): Int { return x + y }
37. Side Effects fun add(x: Int, y: Int): Int { val result = x + y writeResultToFile(result) return result }
38. Side Effects fun add(x: Int, y: Int): Int { val result = x + y writeResultToFile(result) return result }
39. Side Effects • Any code that writes to the outside world e.g. file, DB, delete • Depends on historical context • Less predictable
40. Side Effects • Any code that writes to the outside world e.g. file, DB, delete • Depends on historical context • Less predictable
41. Side Effects • Any code that writes to the outside world e.g. file, DB, delete • Depends on historical context • Less predictable
42. Immutability • Once an object is created, it is that thing forever
43. Immutability data class Car(var name: String?)
44. Immutability data class Car(val name: String)
45. Immutability val fancyCar = Car("Jessica") fancyCar.name = "Shakira"
46. Immutability val fancyCar = Car("Jessica") fancyCar.name = "Shakira" Compile Error!
47. Immutability val fancyCar = Car("Jessica")
48. Immutability val fancyCar = Car("Jessica") val fancyCar = Car("Shakira") or val otherFancyCar = fancyCar.copy(name = "Shakira")
49. Avoid Shared State • Any variable, object or memory space that exists in a shared scope • The classic problem - Race Condition • Changing order in which functions are called can cause failures
50. Avoid Shared State • Any variable, object or memory space that exists in a shared scope • The classic problem - Race Condition • Changing order in which functions are called can cause failures
51. Avoid Shared State • Any variable, object or memory space that exists in a shared scope • The classic problem - Race Condition • Changing order in which functions are called can cause failures
52. Avoid Shared State Thread 1 Car Thread 2 getNoOfDrivers 5 setNoOfDrivers(7)
53. Avoid Shared State Thread 1 Car Thread 2 getNoOfDrivers 5 setNoOfDrivers(7) Does calculation based on assumption that Car has 5 drivers
54. Avoid Shared State Thread 1 Car Thread 2 getNoOfDrivers 5 Create car with NoOfDrivers (7) Does calculation based on assumption that Car has 5 drivers Thread 2 gets new copy of car Does stuff with Car of 7 drivers
55. Explicitness • A function does what it says it does - No Surprises!
56. Explicitness fun divide(x: Int, y: Int) = x / y fun processData(data: String) { if (data.isNotEmpty()) { println("Good data") } else { throw Exception("Data is crap") } }
57. Explicitness fun divide(x: Int, y: Int) = x / y fun processData(data: String) { if (data.isNotEmpty()) { println("Good data") } else { throw Exception("Data is crap") } } What about divide by 0? Function does not say it can throw an exception
58. Explicitness fun divide(x: Int, y: Int) = x / y fun processData(data: String) { if (data.isNotEmpty()) { println("Good data") } else { throw Exception("Data is crap") } } What about divide by 0? Function does not say it can throw an exception These are LIES!
59. Explicitness - Partial Functions • Function does not work for all potential input values
60. Explicitness fun divide(x: Int, y: Int) = x / y
61. Explicitness fun divide(x: Int, y: Int) = x / y fun divide(x: Int, y: Int): Option<Int> { return if (y > 0) { Option.just(x / y) } else { Option.empty() } }
62. Explicitness fun processData(data: String) { if (data.isNotEmpty()) { println("Good data") } else { throw Exception("Data is crap") } }
63. Explicitness sealed class Result { class Success(val value: String): Result() class Failure(val message: String): Result() } fun processData(data: String): Result { return if (data.isNotEmpty()) { Result.Success("Good Data") } else { Result.Failure("Crap Data") } }
64. Explicitness - Total Functions • Functions work for all input values
65. Explicitness - Arrow: Either Object CrapData fun processData(data: String): Either<String, NotApplicable> { return if (data.isNotEmpty()) { Either.Left(data) } else { Either.Right(CrapData) } }
66. Explicitness - Arrow: Try fun processData(data: String): Try<String> { return Try { if (data.isNotEmpty()) { "Good data" } else { throw Exception("Data is crap") } } }
67. Abstraction • Make code more concise and easier to understand • Abstract using functions • Hard to remember implementation details but we remember what a function does and we use them
68. Abstraction fun itDoesSomething(elements: List<String>): HashMap<String, Int> { var i = 0 val results = hashMapOf<String, Int>() while (i < elements.size) { val element = results[elements[i]] if (element != null) { results[elements[i]] = element + 1 } else { results[elements[i]] = 1 } i++ } return results }
69. Abstraction fun itDoesSomethingAlso(elements: List<String>): List<Pair<String, Int>> { return elements.groupBy { it }.map { Pair(it.key, it.value.count()) } }
70. High Order Functions • In Functional Programming, functions are first class citizens
71. High Order Functions • In Functional Programming, functions are first class citizens • Functions that take functions as parameters and can return functions
72. High Order Functions interface CompressionStrategy { fun compress(files: List<File>) } class ZipCompressionStrategy : CompressionStrategy { fun compress(files: List<File>) { // Do ZIP stuff } } class RarCompressionStrategy : CompressionStrategy { fun compress(files: List<File>) { // Do RAR stuff } }
73. High Order Functions fun decideStrategy(strategy: Strategy): CompressionStrategy { when (strategy) { ZIP -> return ZipCompressionStrategy() RAR -> return RarCompressionStrategy() } }
74. High Order Functions • A lot of ceremony • All we are trying to do is use a variable to choose a business logic
75. High Order Functions fun compress(files: List<File>, applyStrategy: (List<File>) -> CompressedFiles) { applyStrategy(files) }
76. High Order Functions fun compress(files: List<File>, applyStrategy: (List<File>) -> CompressedFiles) { applyStrategy(files) } // At call site compress(fileList, { files -> ZipCompression() } ) compress(fileList, { files -> RARCompression() } )
77. Composition • Create small pieces of code (functions) that can be used in small building blocks to build bigger systems
78. Composition • Collaboration between functions to create another function
79. Composition val oddLength = compose(::isOdd, ::length) val strings = listOf("a", "ab", "abc") println(strings.filter(oddLength))
80. Composition fun isOdd(x: Int): Boolean = x % 2 != 0 fun length(s: String): Int = s.length fun <A, B, C> compose(f: (B) -> C, g: (A) -> B): (A) -> C { return { x -> f(g(x)) } }
81. Composition val oddLength = compose(::isOdd, ::length) val strings = listOf("a", "ab", "abc") println(strings.filter(oddLength))
82. Composition val oddLength = compose(::isOdd, ::length) val strings = listOf("a", "ab", "abc") println(strings.filter(oddLength)) // Output [a, abc]
83. Where to Go From There? • Tip of the iceberg • Functors • Arrow Framework • Change of mindset when writing code • Practice! Practice! Practice!
84. Resources and Inspirations • Category Theory in Life - Eugenia Cheng (This is where I got my examples for the Category Theory slides) https://www.youtube.com/watch?v=ho7oagHeqNc • Category Theory 1.1: Motivation and Philosophy - Bartosz Milewski (Very popular series on Category Theory) https://www.youtube.com/watch?v=I8LbkfSSR58 • Functional Programming with Kotlin - Hadi Hariri https://www.youtube.com/watch?v=eNe5Nokrjdg • Functional Programming for Android Developers - Part 1 (4 Parts series) https://medium.com/free-code-camp/functional-programming-for-android-developers-part-1-a58d40d6e742 • Functional Programming with Kotlin and Arrow: Getting Started - Massimo Carli (2 Parts series) https://www.raywenderlich.com/9527-functional-programming-with-kotlin-and-arrow-getting-started • Effective Kotlin - Marcin Moskala (I bought the pdf) https://leanpub.com/effectivekotlin • The Science Behind Functional Programming - Rafa Paradela https://www.47deg.com/blog/science-behind-functional-programming/