Valery Calderon - Reactive Programming with RxPy

Web applications contains lots of database operations, network calls, nested callbacks and other computationally expensive tasks that might take a long time to complete or even block other threads until it's done, here is where ReactiveX enters, it doesn't only gives us the facility to convert almost anything to a stream; variables, properties, user inputs, caches, etc to manage it asynchronously. But it also gives us an easy way to handle errors which is a hard task within asynchronous programming. ReactiveX makes our code more flexible, readable, maintainable and easy to write.

We will be exploring how ReactiveX help us to make things easier with its operators toolbox that can be used to filter, create, transform or unify any of those streams. We will learn that in just a few lines of maintainable code, we can have multiple web sockets which recieves multiple requests all handled by an asynchronous process that serves a filtered output.

To do that I decided to explain an example of the use with an example by implementing observables, observers/subscribers and subjects. We will start by requesting our data stream from the Github API with a Tornado web socket and then filtering and processing it asynchrounosly.

https://us.pycon.org/2018/schedule/presentation/129/

Transcript

1. Reactive Programming with RxPy
2. $Whoami $ @valerybriz $ Pythonista $ Telecomm Engineer $ Co-Founder and Leader of Python Guatemala $ Systems Development Specialist at Skyguard GPS
3. What Does Reactive Programming Really Means?
4. Why Reactive Programming?
5. Why Reactive Programming?
6. Why Reactive Programming?
7. How Does Reactive Programming Works?
8. Observable and Observer onNext() onComplete() onError()
9. Observables source = Observable.from_list([1,2,3,4,5,6])
10. Observers source.subscribe(lambda value:print("Received {0}".format(value)))
11. Subjects mySubject = subject.on_next([1,2,3,4,5,6]) mySubject.subscribe(send_response, on_error)
12. Data Operators in Reactive Programming • Creating Observables • Transforming Observables • Filtering Observables • Combining Observables • Error Handling Operators • Observable Utility Operators • Conditional and Boolean Operators • Mathematical and Aggregate Operators • Connectable Observable Operators
13. Observable.just(a,b,c,d)
14. Observable.filter( lambda text: not text or len(text) > 2 )
15. Subject.flat_map( lambda value: Observable.from_future( self.get_value(value) ) )
16. Subject.do_action( lambda x: send_response('clear') )
17. user_input.combine_latest( interval, lambda input_value, i:input_value )
18. Advantages of Reactive Programming •Asynchronous •Error Handling •Multiple Subscribers •Functional programming
19. Trying it out self.subject = Subject() user_input = self.subject.throttle_last( 1000 ).start_with("").filter( lambda text: not text or len(text) > 2 )
20. Trying it out self.combine_latest_sbs = user_input.combine_latest( interval, lambda input_val, i: input_val ).do_action( lambda x: send_response('clear') ).flat_map( self.get_data ).subscribe(send_response, on_error)
21. Conclusions