Introduction

Reactive programming is programming with asynchronous data streams.

• In a way, this isn't anything new. Event buses or your typical click events are really an asynchronous event stream, on which you can observe and do some side effects.

In Reactive you are able to create data streams of anything, not just from click and hover events.

• Streams are cheap and ubiquitous, anything can be a stream: variables, user inputs, properties, caches, data structures, etc.
• For example, imagine your Twitter feed would be a data stream in the same fashion that click events are. You can listen to that stream and react accordingly.

A stream is a sequence of ongoing events ordered in time. It can emit three different things: a value (of some type), an error, or a "completed" signal.

We capture these emitted events only asynchronously, by defining a function that will execute when a value is emitted, another function when an error is emitted, and another function when 'completed' is emitted.

• Sometimes these last two can be omitted and you can just focus on defining the function for values. 4
• The "listening" to the stream is called subscribing.
• The functions we are defining are observers. The stream is the subject (or "observable") being observed. This is precisely the Observer Design Pattern.

A stream can be used as an input to another one. Even multiple streams can be used as inputs to another stream.

• You can merge two streams.
• You can filter a stream to get another one that has only those events you are interested in.
• You can map data values from one stream to another new one.
• This one can call the functional magic.

Reactive Programming raises the level of abstraction of your code so you can focus on the interdependence of events that define the business logic, rather than having to constantly fiddle with a large amount of implementation details.

A Promise is simply an Observable with one single emitted value. Rx streams go beyond promises by allowing many returned values.

A metastream is a stream where each emitted value is yet another stream.