Download as PDF, PPTX
![JavaScript function filter(array, test) { var passed = []; for (var i = 0; i < array.length; i++) { if (test(array[i])) passed.push(array[i]); } return passed; }](https://image.slidesharecdn.com/introductiontofunctionalprogramming-160221140806/75/Introduction-to-functional-programming-42-2048.jpg)
![function map(array, transform) { var mapped = []; for (var i = 0; i < array.length; i++) mapped.push(transform(array[i])); return mapped; }](https://image.slidesharecdn.com/introductiontofunctionalprogramming-160221140806/75/Introduction-to-functional-programming-43-2048.jpg)
Uploaded byKonrad Szydlo
Introduction to functional programming
Functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids mutable state and side effects. Some benefits of FP include succinct and understandable code, different programming perspectives, and easier concurrency without data races. FP programs are made up of functions that avoid variable assignment and modification by relying on immutable data and lazy evaluation. Functional programming is supported by many languages through features like higher-order functions, recursion, and immutable data structures.
Introduction to functional programming
- 1.
- 2.
- 3. Agenda ● Why functionalprogramming? ● Functional Programming ● Benefits of FP ● Concurrency ● How to program functionally
- 4. In the beginningthere was ...
- 5. Lambda calculus ● Theoreticalframework ● Describes functions and their evaluations ● Basis of almost all FPL today
- 7. Why is functionalprogramming important?
- 8. The benefits offunctional programming ● succinct, concise and understandable code ● offers different programming perspective ● FP becoming more accessible ● concurrency / parallelism without tears
- 9. Why FP isimportant? Row 1 Row 2 Row 3 Row 4 0 2 4 6 8 10 12 Column 1 Column 2 Column 3
- 10. Wirth's Law Software isgetting slower more rapidly than hardware becomes faster
- 11.
- 13. If all ofthese are functional programming (languages), isn't it overwhelming and difficult?
- 14. Not really. Butwhy?
- 15. What is functionalprogramming? What is a functional programming language?
- 16. Functional programming isjust a style
- 17. Programming styles Declarative vs.Imperative programming
- 18.
- 19. What is object-oriented programming? ●Reuse code via classes ● Eliminate bugs – Encapsulation – Data hiding
- 20. Functional programming ● Reusecode via function composition ● Eliminate bugs – Immutability – Pure functions
- 23. Programs as functions ●No loops but recursion ● Minimise number of variables ● no assignment operation ● only constants, parameters and values
- 25. The dark side toomuch recursion can overflow the stack (without tail-call optimization) high memory consumptions from creating so many objects
- 26. No variables, noassignment – No problem ● No notion of the internal state of a function ● referential transparency ● value semantics
- 27. Referential Transparency An expressionis said to be referentially transparent if it can be replaced with its value without changing the behaviour of a program 25 == 5 * 5
- 28. Value semantics It meansfor an object that only its value counts, not its identity Coping an object doesn't change the behaviour of your program
- 29. Pure Function ● Alwaysevaluates to the same result ● Evaluation does not cause side effects
- 31. What does itmean in practice? No bugs due to nasty side effects
- 32. Mutable state Map<Person, String>map = … Person p = new Person('John'); map.put(p, "Hey, there!");
- 33.
- 34.
- 35. Immutability “Object-oriented programming makescode understandable by encapsulating moving parts. Functional programming makes code understandable by minimizing moving parts.” — Michael Feathers, author of Working with Legacy Code, via Twitter
- 36. ● Data oncecreated are never changed ● Need to “update” your data? – create new one ● Safe to share data between threads
- 37. HOF Higher order function –Takes one or more functions as an input and/or – Outputs function
- 38. Ruby ● Map ● Each ●Reduce ● Inject ● Select
- 39. Ruby def twice(f, x) f.call(f.call(x)) end f1= ->(x){ x / 3 } print twice(f1, 9) # 1
- 40. JavaScript function twice(f, x){ returnf(f(x)); } function f(x){ return x*3; } twice(f, 7); // 63
- 41. Higher-order functions startto shine when you need to compose functions
- 42. JavaScript function filter(array, test){ var passed = []; for (var i = 0; i < array.length; i++) { if (test(array[i])) passed.push(array[i]); } return passed; }
- 43. function map(array, transform){ var mapped = []; for (var i = 0; i < array.length; i++) mapped.push(transform(array[i])); return mapped; }
- 44. function average(array) { functionplus(a, b) { return a + b; } return array.reduce(plus) / array.length; }
- 45. function age(p) {return p.died - p.born; } function male(p) { return p.sex == "m"; }
- 46.
- 47. Lazy evaluation ● Delayingevaluation of an expression ● Reduction of memory footprint as values are created when needed not when they are declared ● Potential to construct infinite data structures ● Requires pure functions as order of operations becomes indeterminate
- 48. Lazy Fibonacci ● Haskell ●Infinite list fibs = 0 : 1 : zipWith (+) fibs (tail fibs) ● Take only required Fibonacci numbers
- 49. Memoization ● Storing theresult of function calls ● Returning the cached result ● Trade-off between function time cost and space cost ● Run-time not compile-time optimisation
- 51. You can programfunctionally in a variety of programming languages
- 52. A functional languageprovides 'sane' defaults
- 53. Why is FPimportant? (again)
- 54. ● formal provability ●code comprehension modularity ● unit testing and debugging ● automation ● maintainability ● hot code deployment
- 55. Provability simpler execution modelmakes program proving easier both for computers and humans
- 56. Code comprehension easier tounderstand and reason about because you don't have to worry about what is happening behind the scenes
- 57. Modularity modular design bringswith it great productivity improvements. Small modules can be coded quickly and easily and have a greater chance of re-use which leads to faster development of programs. Additionally, the modules can be tested independently, thus helping to reduce the time spent unit testing and debugging
- 58. Testing, debugging &automation ● PF is much easier to reason about ● specific arguments always return specific results ● problems are easy to troubleshoot/duplicate because no state or external dependencies ● automation is simplified due to lack of environmental, state or configuration concerns
- 59. Maintainability easier to maintainas you don't have to worry about accidentally changing anything outside a given function
- 60.
- 63. In the purelyfunctional world, the compiler does not need proof of non-interference. It is built into the programming language.
- 64. Implicit parallelism isfree in functional programming languages.
- 65. Sadly, this storyis naïve and unrealistic and yet it contains the key to a parallel world.
- 66. In the imperativeworld mutation creates too few opportunities for automatic parallel execution
- 67. In the functionalworld a lack of dependencies means too many opportunities for automatic parallel execution.
- 68. The imperative worldwill see explicit parallel programming and the big battle against race condition bugs.
- 69. The functional worldwill provide explicit parallel programming with fewer race conditions.
- 71. How to programfunctionally?
- 72. Avoid side-effects ● donot modify variables passed to functions ● do not modify any global variables
- 73. ● Use higher-orderfunctions ● Limit variable assignment ● Same input → same output ● Don't share state
- 74. Does order matter? Ordercan be a side effect
- 75. ● Use immutabledata ● Lazy evaluation
- 76. Decompose problems intofunctions (whenever you can)
- 77.
- 78.