Here are some notes I took from Matt Dupree’s talk. It was a really great intro to Rx, and done in a different way than most Rx talks I’ve seen. He creates mental building blocks to get us from the Java Array to the Rx Observable.
“We are missing an abstraction”
Array -> Iterable -> Sequence -> Observable
Goal of this talk: Escape from “Callback Hell” (Too many nested callbacks, and Observables are here to help).
In Java, the “Iterable” interface allow us to abstract away from an Array, hiding us from the underlying implementation like LinkedList, HashSet, etc. We just care that we are going through the items when we have an Iterable, and don’t really car how it’s done.
A button clicks example used:
* If you knew all your button clicks up front, you’d just do a “for” loop
* Instead you have an onClickListener since you don’t know when it’ll happen
* You instead subscribe to an observable stream (which looks like a loop), and for each observable event, you perform the action.
Interesting point: With an observable, data is not in memory necessarily, but you write code like it is. This is another layer of abstraction that is helpful in doing delcarative programing instead of imperative programming.
This is “WHAT” I want to happen.
This is “HOW” I want it to happen.
Cool tip about “Debouncing”: I hadn’t heard of this before, but he shows another use case regarding a search text box, and he showed how EASY it was to use debouncing. Debouncing can help you wait for the stream to settle, and in this case you can wait 300ms after the last event. You can just say wait until the observable hasn’t been called in XXX milliseconds, and if that’s the case, then continue on.
Note: “Rx” means Reactive Extensions. (I, personally hear the term “Rx” so much, that I forget that it means something else sometimes)