Tweet
Tweet

Slide 1

Slide 1 text

Introduction to Pragmatic Functional 
 PHP Branislav Bujisic

Slide 2

Slide 2 text

–Saunders Mac Line, Categories for the Working Mathematician “All told, a monad in X is just a monoid in the category of endofunctors of X, with product X replaced by composition of endofunctors and unit set by the identity endofunctor.”

Slide 3

Slide 3 text

Continuous Deployment Cloud Hosting Drupal 7 / Drupal 8 / Front End Product Engineer

Slide 4

Slide 4 text

Bad Accent Included

Slide 5

Slide 5 text

No content

Slide 6

Slide 6 text

No content

Slide 7

Slide 7 text

No content

Slide 8

Slide 8 text

Fathers of computing were playing in their laboratories... The goal: 
 a computation model free of human decision making

Slide 9

Slide 9 text

Alan Mathison Turing (1912-1954)

Slide 10

Slide 10 text

Alonzo Church (1903-1995)

Slide 11

Slide 11 text

x result A Function calculation

Slide 12

Slide 12 text

λx.x

Slide 13

Slide 13 text

λx.λy.x2+y2

Slide 14

Slide 14 text

(λx.x)y ͢ y

Slide 15

Slide 15 text

(λx.x)(λx.λy.x2+y2)

Slide 16

Slide 16 text

EVERYTHING is a function, even a boolean value! TRUE := λa.λb.a FALSE := λa.λb.b AND := λp.λq.pqp OR := λp.λq.ppq
 NOT := λp.λa.λb.pba

Slide 17

Slide 17 text

TRUE AND FALSE = ? " TRUE FALSE TRUE " FALSE (λp.λq.pqp) TRUE FALSE p q " (λa.λb.a) FALSE TRUE a b

Slide 18

Slide 18 text

EVERYTHING is a function, even a natural number! 0 := λf.λx.x function zero($f, $x) { return $x;
 } 1 := λf.λx.fx function one($f, $x) { return $f($x);
 } 2 := λf.λx.f(fx) function two($f, $x) { return $f($f($x));
 }

Slide 19

Slide 19 text

1+2 = ? " (λf.λx.f(f(fx)) (λf.λx.fx)(λf.λx.f(fx))

Slide 20

Slide 20 text

No content

Slide 21

Slide 21 text

John Von Neumann (1903-1957)
 Neumann János

Slide 22

Slide 22 text

The Von Neumann Model Input Device Output Device Memory Central Processing Unit Control Unit Arithmetic / Logic Unit ebp-0x1 ebp-0x2 ... 00001010 00000101 ebp-0x4 ebp-0x3 mov eax, [ebp-0x1] jmp ebp-0x0 {

Slide 23

Slide 23 text

The Machine Language mov eax, [ebp-0x1] mov ebx, [ebp-0x2] loopTop: cmp eax, ebx jle loopDone dec eax jmp loopTop loopDone: ebp esp FFFD ebp-0x1 ebp-0x2 ... 10 5 ebp-0x4 ebp-0x3 FFF7 ... ...

Slide 24

Slide 24 text

Higher-Level Programming Languages 10 I = 10 20 J = 5 30 IF I <= J GOTO 60 40 I = I - 1 50 GOTO 30 60 ... mov eax, [ebp-0x1] mov ebx, [ebp-0x2] loopTop: cmp eax, ebx jle loopDone dec eax jmp loopTop loopDone: compiler

Slide 25

Slide 25 text

Higher-Level Programming Languages mov eax, [ebp-0x1] mov ebx, [ebp-0x2] loopTop: cmp eax, ebx jle loopDone dec eax jmp loopTop loopDone: for ($i = 5; $i <= 10; $i++) { ... } compiler

Slide 26

Slide 26 text

Higher-Level Programming Languages mov eax, [ebp-0x1] mov ebx, [ebp-0x2] loopTop: cmp eax, ebx jle loopDone dec eax jmp loopTop loopDone: compiler MyFancyClass - i: int + myFancyLoop

Slide 27

Slide 27 text

Meanwhile, the academia contuned playing with the lambda calculus...

Slide 28

Slide 28 text

Functional Programming Languages

Slide 29

Slide 29 text

Once set, a variable must not be changed during the runtime. Immutability Basic Concepts of Functional Programming class Immutable
 {
 private $var;
 
 public function __construct($var)
 {
 $this->var = $var;
 }
 
 public function get()
 {
 return $this->var;
 }
 } Pragm atic?

Slide 30

Slide 30 text

Not a requirement but a convenient way to prevent unplanned problems. Static Typing Basic Concepts of Functional Programming

Slide 31

Slide 31 text

A pure function always returns the same result for the given set of parameters. sin() 3.14 0.00 1 0.84 2 0.91 Param Result 1 0.84 2 0.91 3.14 0.00 Referential Transparency Basic Concepts of Functional Programming

Slide 32

Slide 32 text

A pure function never changes a state outside of its scope. Eliminated Side-Effects Basic Concepts of Functional Programming user_save() $user $user

Slide 33

Slide 33 text

A pure function does not depend on external state and relies only on the parameters it was called with. No External Dependencies Basic Concepts of Functional Programming user_load($uid) $user

Slide 34

Slide 34 text

A higher-order function can accept another functions as arguments and return a function. Higher-Order Functions Basic Concepts of Functional Programming array_filter($users, $callback) $callback = function ($user) { return ($user->age >= 18); }; $callback = function ($user) { return ($user->gender == 'f')
 && ($user->age < 13); };

Slide 35

Slide 35 text

A function can be passed as argument to other functions, returned as value from other functions and assigned to variables. First Class Functions Basic Concepts of Functional Programming function area($r) {/*...*/} $area = function($r) {/*...*/} array_map($area, $radiuses);

Slide 36

Slide 36 text

But... Why?! • Testing • Caching • Complexity control • Performance*

Slide 37

Slide 37 text

Testing params result [5, 0] 25 [0, 5] 3 [5, 5] 28 [0, 0] 0 test($myObscureFunction, $table); $myFunction = function(int $a, int $b) { // I don't care about the content of
 // this function. If it is clean,
 // it will always return the same // response for the given params. }

Slide 38

Slide 38 text

Testing function test($function, $table) { foreach ($table as $row) { $params = $row['params']); $expected_result = $row['result'];
 
 $result = call_user_func_array($function, $params);
 if ($result !== $expected_result) { echo "Test failed for parameters "
 . implode(', ', $row['params']); } } }

Slide 39

Slide 39 text

Caching –Phil Carlton. Quoted by Martin Fowler in TwoHardThings "There are only two hard problems in Computer Science: cache invalidation and naming things.

Slide 40

Slide 40 text

Caching Memoization params result [5, 0] 25 [0, 5] 3 [5, 5] 28 [0, 0] 0 memoize($myObscureFunction, $parameters); $myFunction = function(int $a, int $b) { // I don't care about the content of
 // this function. If it is clean,
 // it will always return the same // response for the given params. }

Slide 41

Slide 41 text

Memoization:
 Nuts and Bolts function memoize(callable $func, $params = []) { return call_user_func_array($func, $params); } 
 $result = memoize($somethingTerriblyExpensive, [2, 5]); $somethingTerriblyExpensive = function($a, $b) { // ...
 } 
 static $storage = []; $key = get_class($func) . implode(':', $params); // OMG, BAD!! if (!isset($storage[$key])) { $storage[$key] = call_user_func_array($func, $params); } return $storage[$key];

Slide 42

Slide 42 text

Complexity Control Does not necessarily mean "less code to write"

Slide 43

Slide 43 text

–Neal Ford. Functional Thinking (Sebastopol: O'Reilly, 2014) "I’d rather spend my time at a higher level of abstraction, thinking about ways to solve complex business scenarios, not complicated plumbing problems."

Slide 44

Slide 44 text

Higher level of abstraction means: • Less plumbing problems • More focus on business problems • Easier debugging and refactoring • Less control over every aspect of the program • Performance tradeoffs

Slide 45

Slide 45 text

The Stack Push Pop FFFD FFFE FFFF FFFC FFFB FFFA Addr Value FFF8 FFF9 FFF7 FFF6 Stack Frame ebp esp Junk Junk

Slide 46

Slide 46 text

What else can be abstracted away?

Slide 47

Slide 47 text

Loops are not business logic $output = [];
 foreach ($collection as $item) { $output[] = strtoupper($item); }; process
 $collection[0] process
 $collection[1] process
 $collection[2] process
 $collection[3] Sequential Execution Guaranteed™

Slide 48

Slide 48 text

The loop still exists, but it's a responsibility of compiler $output = array_map(function($item) { strtoupper($item); }, $collection); process
 $collection[0] process
 $collection[1] process
 $collection[2] process
 $collection[3]

Slide 49

Slide 49 text

Process could be parallelized $output = array_map(function($item) { strtoupper($item); }, $collection); process
 $collection[0] process
 $collection[1] process
 $collection[2] process
 $collection[3] assemble result parallelize
 job

Slide 50

Slide 50 text

Process could be parallelized $output = array_map(function($item) { strtoupper($item); }, $collection); process
 $collection[0] process
 $collection[1] process
 $collection[2] process
 $collection[3] assemble result parallelize
 job

Slide 51

Slide 51 text

This "might" work with PHP • https://github.com/krakjoe/pthreads
 Threading for PHP • PHP 7.2+ • ZTS Enabled (Thread Safety) • Posix Threads Implementation • Some boilerplate work and/or 
 https://github.com/functional-php/parallel

Slide 52

Slide 52 text

Design patterns are not a business logic Therefore they should be abstracted away

Slide 53

Slide 53 text

Decorator Pattern Pizza 4.00 Mushrooms +1.00 Mozarella +2.00 Basil +0.50 Mushrooms getPrice() Sellable getPrice() Pizza getPrice() Topping __construct(Sellable)
 getPrice() Mozarella getPrice() Basil getPrice()

Slide 54

Slide 54 text

Decorator Pattern $pizza = new Pizza(); $mushroomPizza = new Mushrooms($pizza); $mushroomMozarellaPizza = new Mozarella($mushroomPizza); //... $mushroomMozarellaBasilPizza ->getPrice(); Mushrooms getPrice() Sellable getPrice() Pizza getPrice() Topping __construct(Sellable)
 getPrice() Mozarella getPrice() Basil getPrice() $badPizza = new Basil( new Mozarella( new Mushrooms ( new Pizza() ) ) );

Slide 55

Slide 55 text

Functional solution is called composition $badPizza = compose($mushrooms, $mozarella, $basil); $mushrooms = function($price) {return $price + 1;};
 $mozarella = function($price) {return $price + 2;};
 $basil = function($price) {return $price + .5;}; $badPizzaPrice = $badPizza(4); // 4 == base price // Tripple Mozarella FTW
 $fixBadPizza = compose($badPizza, $mozarella, $mozarella);

Slide 56

Slide 56 text

It's not all lollipops and unicorns function identity($value) { return $value; } function compose(...$functions) { return array_reduce( $functions, function ($chain, $function) { return function ($input) use ($chain, $function) { return $function($chain($input)); }; }, 'identity' ); }

Slide 57

Slide 57 text

Primitives for functional programming in PHP { "require": { "lstrojny/functional-php": "~1.2" } }

Slide 58

Slide 58 text

Composition use function Functional\compose;
 
 $betterPizza = compose( $pizzaDough, $mozarella, $mozarella, $mushrooms, $basil, $tomatoes );

Slide 59

Slide 59 text

Memoization use function Functional\memoize;
 
 $results = memoize( $expensiveFunctionYouWantToCache, [$param1, $param2, $param3] );

Slide 60

Slide 60 text

Operations on traversable objects and arrays use function Functional\every; use function Functional\select; use function Functional\invoke;
 
 if (every($group, function($user) {$user->age > 18}) {
 print "You may enter the bar!"; } $kids = select($group, function($user) {
 $user->age < 12;
 }); invoke($kids, 'goToBed', []); // ...

Slide 61

Slide 61 text

Performance

Slide 62

Slide 62 text

time 0s 0.4s 0.8s 1.2s 1.6s map filter reduce 0.86 1.54 1.27 0.48 1.12 0.72 0.23 0.54 0.58 imperative functional lstrojny/functional-php Tested on OS X, Apache 2.4 and PHP 7.1 10 000 000 operations

Slide 63

Slide 63 text

It is safe to parallelize stateless processes

Slide 64

Slide 64 text

Synchronous monthly invoicing Payment Pending Order Email the user Charge Credit Card Completed Order 1 000 times in a single night,
 1 minute per job (optimistic)
 Total: 16h 40m Issue the invoice

Slide 65

Slide 65 text

Synchronous monthly invoicing Payment Pending Order Email the user Charge Credit Card Completed Order 1 000 times in a single night,
 1 minute per job (optimistic)
 Total: 16h 40m Issue the invoice Invoicing Queue

Slide 66

Slide 66 text

Synchronous monthly invoicing Payment Pending Order Email the user Charge Credit Card Completed Order 1 000 times in a single night,
 1 minute per job (optimistic)
 Total: 16h 40m Invoicing Queue Issue the invoice Issue the invoice Issue the invoice

Slide 67

Slide 67 text

Upload a function Request Response

Slide 68

Slide 68 text

Serverless • Compute Service On Demand • Pay infrastructure only during the execution of functions • AWS Lambda (Java, Python, Node.js, C#)
 Google Cloud Functions (Node.js)
 MS Azure Functions (C#, Node.js)
 IBM Cloud Functions (Node.js, Swift, Java, PHP, Python, any compiled language in Docker) • Execute functions on event or on http request

Slide 69

Slide 69 text

PHP is not a functional language

Slide 70

Slide 70 text

Say NO to PHP monads

Slide 71

Slide 71 text

Use functional style of programming together with the object-oriented code

Slide 72

Slide 72 text

Thanks! Wanna talk about functional programming, platform.sh or even monads?
 
 Come by the Platform.sh booth or drop me an email! Branislav Bujisic
 [email protected] @bbujisic