PHP Reactive Programming at PHP Confrence Asia 2018

The term reactive was very famous recently. Not only did it get trending, but it has started ruling the software development sector with new blog posts articles every day, and presentations, emerging frameworks and libraries, and more.

This is the improvement from my slide before for Medan Tech Day 2018

Transcript

1. PHP REACTIVE PROGRAMMING PHP CONFRENCE ASIA SINGAPORE
 SEPTEMBER 28, 2018 Dolly Aswin dolly.aswin@gmail.com
2. Dolly Aswin • Start Programming in PHP since 2004 • Zend Certified Engineer PHP 5 (2010) • Zend Framework Certified Engineer (2011) • Zend Framework Certified Architect (2015)

3. What is Reactive Programming
4. Reactive Programming Reactive programming is a declarative programming paradigm concerned with data streams and the propagation of change. This means that it becomes possible to express static (e.g. arrays) or dynamic (e.g. event emitters) data streams with ease via the employed programming language(s) https://en.wikipedia.org/wiki/Reactive_programming
5. What is Programming Paradigm
6. Programming Paradigm This is a set of concepts defining a style of building and structuring programs. Most programming languages, such as PHP, support multiple paradigms. We can also think of it as a mindset and a way we approach problems when using such paradigms.
7. Programming Paradigms Used • Declarative • Asynchronous • Functional
8. Declarative Declarative programming is a paradigm focused on describing a program's logic instead of particular executional steps. (Image Reference: https://xkcd.com/149/)
9. Declarative Example: SQL SELECT * FROM `item` WHERE `id` = 1 In SQL, we define what data from what table we want to query, but the implementation details are completely hidden for us.
10. Asynchronous Minimize idle time by switching the tasks Creating New User Process With Asynchronous Programming Send Welcome Email Give Success Response Create New User
11. Asynchronous Creating New User Process With Synchronous Programming Send Welcome Email Give Success Response Create New User
12. Asynchronous != Paralel Parallelism is a simultaneous execution of multiple things (they may be related and may not). In asynchronous, we are dealing with a lot of different things at once. Parallelism is doing a lot of things at once. It looks like the same but these are actually different ideas. Asynchronous is about structure, while parallelism is about execution
13. Functional (The Image Reference: https://dev.to/navi/why-functional-programming-matters-2o95)
14. Functional The functional programming paradigm treats program flow as an evaluation of functions. It utilizes several concepts, where the most important for us are eliminating side effects, avoiding mutable data, functions as first-class citizens and higher - order functions.
15. Functional Example in Javascript: The Higher-order functions have a very similar meaning and have to do at least one of these • Take a function as an argument • Return a function as a result
16. Functional In functional programming, this concept of higher-order function is often used in connection with methods on collections such as • map() • filter() • reduce() • concat() • zip()
17. Back To Reactive Programming
18. Reactive Programming (Image Reference: https://developers.redhat.com/blog/2017/06/30/5-things-to-know- about-reactive-programming/)
19. Reactive Programming Reactive programming is yet another programming paradigm. It is based around the ability to easily express data flows and the automatic propagation of changes. This reactive concerns with these following: • Data flows • Propagation of change • Easily express data flow
20. Reactive Programming Data Flows In reactive programming, we want to think about variables as "values that change over time".
21. Reactive Programming Propagation of change A very nice example is a spreadsheet editor. If we set the value of a single cell to C1 = A1 + B1, every change to cells A1 and B1 will be propagated to C1
22. Reactive Programming Easily Express Data Flow The first part about data flows and propagation of change looks like the Observer Design Pattern with Iterables.
23. Reactive Programming Observer Design Pattern The Observer Pattern (also known as Publish - Subscribe Pattern) is a behavioral design pattern which defines a one-to-many relationship between objects such that, when one object changes its state, all dependent objects are notified and updated automatically
24. Reactive Programming Reactive Extensions: ReactiveX or just Rx are a set of libraries in various languages that make reactive programming easy even in languages where concepts of asynchronous and functional programming are clumsy, such as PHP.
25. RxPHP
26. RxPHP Output:
27. RxPHP Difference Between Observable & Iterating Array PUSH vs PULL
28. RxPHP Observables behave like a data stream
29. RxPHP Observable map() filter() Observer
30. RxPHP Observable call three methods on it’s Observer onNext() called when the next item is ready to be emitted. onError() Notification called when an error has occurred onComplete() Notification called when there're no more items to be emitted
31. RxPHP In RxPHP, every operator takes a callable as an argument wraps its call internally. If the callable throws Exception, then this Exception is sent as onError() notification
32. RxPHP Output: When an error occurred, no more items were emitted There's also no complete notification. This is because, when the observer received an error, it automatically unsubscribed
33. RxPHP Components of RxPHP: • Observables • Observers • Singles • Subject • Disposable • Scheduler • Operators
34. RxPHP Observable • Observable emits item • Observer subscribe to Observable • Observable notify Data is emitted Error is occured
35. RxPHP Observable RxPHP comes with several basic types of Observables for general usage • ArrayObservable • RangeObservable • IteratorObservable
36. RxPHP Observable All built-in Observables in RxPHP can be instantiated easily: •RxObservable::fromArray() returns Rx\Observable\ArrayObservable •RxObservable::range() method returns Rx\Observable\RangeObservable •RxObservable::fromIterator() method returns Rx\Observable\IteratorObservable
37. RxPHP Observers • Observers are consumer of Observables • The Constructor takes three optional arguments representing callables for each type of signal onNext() onError() onComplete()
38. RxPHP Observers Create our own Observer class for reusable to test what's going on inside Observable chains
39. RxPHP Singles Singles are like Observables, the only difference is that they always emit just one value. In RxPHP, we don't distinguish any difference between Observables and Singles, so we can use the Observable::just() static method:
40. RxPHP Output:
41. RxPHP Subject The Subject is a Class that acts as an Observable and Observer at the same time. This means that it can subscribe to an Observable just like an observer, and also emit values like an Observable does.
42. RxPHP Subject as Observable: Output:
43. RxPHP Subject as Observer: Output:
44. RxPHP Subject in the middle of Operator Chain Output:
45. RxPHP Disposable All Rx implementations internally use the Dispose Pattern. This design decision has two reasons: • To be able to unsubscribe from an Observable • To be able to release all data used by that Observable https://en.wikipedia.org/wiki/Dispose_pattern
46. RxPHP Scheduler Observables and operators usually don't execute their work directly, but use an instance of the Scheduler class to decide how and when it should be executed In most situations in RxPHP, we don't have to even worry about Schedulers because, if not set differently, all Observables and operators internally use the ImmediateScheduler class, which executes all actions immediately without any further logic.
47. RxPHP Scheduler Applying Event Loop from ReactPHP for Observables would work in a similar way.
48. RxPHP Operators • Operators modify data flow • Returns another Observables • Allows chaining of Operator calls • There are about 40 operators
49. RxPHP filter() The behavior of the filter() operator is the same, it just works with data flows instead of arrays. This means it receives items from its source (the preceding Observable) and propagates them to its consequent observer (or chained operator). 5 10 12 20 18 10 12 18 20 filter(x => x > 5)
50. RxPHP concat() This operator is similar with merge(). This operator merges multiple Observables into one. It internally subscribes to each input Observable in order, one after another. This means that, when the first Observable completes, it subscribes to the next one.” 10 12 20 18 20 14 10 12 20 18 20 concat() 14
51. Summary • Using Reactive Programming make our code Concise, Clear, and Readable. • Reactive Programming and Reactive eXtensions provides a development model to tame the asynchronous beast. • Combining the power of Reactive Programming and PHP is the the good approach to create modern PHP Application • Using reactive programming does not transform our system into a Reactive System. Because Reactive Systems are the next level.
52. Reactive Programming != Reactive System Reactive System (The Image Reference: medium.com) https://developers.redhat.com/blog/2017/06/30/5-things-to-know-about-reactive- programming/
53. Resources • PHP Reactive Programming Book (Martin Sikora) • Learning Event Drivent PHP With ReactPHP Book (Sergey Zhuk) • ReactiveX Website http://reactivex.io

54. THANK YOU
 https://github.com/dollyaswin/reactive-php