What is Reactive Programming?

"Reactive systems have been defined by Harel and Pnueli [On the development of reactive systems, 1985] as systems that are supposed to maintain an ongoing relationship with their environment. Such systems do not lend themselves naturally to description in terms of functions and transformations: they cannot be described adequately as computing a function from an initial state to a terminal state. On the contrary, behaviours of reactive systems are better seen as reactions to external stimuli. The role of reactive systems is to react continuously to external inputs by producing outputs. For example, man–machine interface handlers or computer games fall into the category of reactive systems."

Reactive C: An Extension of C to Program Reactive Systems (F. Boussinot, 1991)

Renewed Interest

Changing Requirements...

...Require New Approaches

Deriving Rx

Duality (Category Theory)

Duality - Examples

Duality - Two Facets of the Same Concept

Duality for Dummies

Easy enough, let's give it a try

public interface Iterable<T> {
    Iterator<T> iterator();
}
public interface Iterator<E> {
    boolean hasNext();
    E next();
    void remove();
}

Step 0 - Simplify

public interface Iterable<T> {
    Iterator<T> iterator();
}
public interface Iterator<E> {
    boolean hasNext();
    E next();
    void remove();
}

• Let us not mix concepts (iterating vs. modifying).

Step 0 - Simplify

public interface Iterable<T> {
    Iterator<T> iterator();
}
public interface Iterator<E> {
    boolean hasNext();    E next() throws Exception;
}

• next may throw an exception when it fails to produce the next element or if there are no more elements.
• Let's make the exception explicit.

Step 1 - Input and Output

public interface Iterable<T> {
    Iterator<T> getIterator(void);
}
public interface Iterator<E> {
    boolean hasNext(void);    E getNext(void) throws Exception;
}

• An exception is an output too!

Step 1 - Input and Output

public interface Iterable<T> {
    Iterator<T> getIterator(void);
}
public interface Iterator<E> {
    (true | false) hasNext(void);    (E | Exception) getNext(void);
}

• Hypothetical syntax:
• Multiple return values
• Discriminated unions
  (aka tagged union, algebraic data type)

Step 1 - Input and Output

public interface Iterable<T> {
    Iterator<T> getIterator(void);
}
public interface Iterator<E> {
    (true | false) hasNext(void);    (E | Exception) getNext(void);
}

• Thinking about hasNext returning true :
  
• Means that getNext will return an E.
• On the other hand if hasNext returns  false, we will get a NoSuchElementException.
  
• So, let's consolidate both methods.

Step 1 - Input and Output

public interface Iterable<T> {
    Iterator<T> getIterator(void);
}
public interface Iterator<E> {
    (true | false) hasNext(void);    (E | void | Exception) getNext(void);
}

• Get rid of hasNext.
• Return void (null) instead of throwing an exception when there are no more elements.
• We might still get an exception in case of an error while producing the next element of the iteration.

Step 2 - Duality Applied

public interface IterableDual<T> {
    void someMethod(IteratorDual<T> it);
}
public interface IteratorDual<E> {    void firstMethod(E elem);    void secondMethod(void);    void thirdMethod(Exception ex);}

• We reverse input and output.
• As the one remaining method has three different return values, we end up with three methods in IteratorDual.
• Now we just need to cleanup and think of some decent names for the methods...

Step 3 - Cleaning Up

public interface IterableDual<T> {
    void setIteratorDual(IteratorDual<T> it);
}
public interface IteratorDual<E> {    void gotNext(E elem);    void gotNothing(void);    void gotException(Exception ex);}

• Not bad. Just let's use some more common/telling names...

Design Patterns Applied

public interface Observable<T> {
    Closable subscribe(Observer<T> observer);
}
public interface Observer<E> {    void onNext(E value);    void onCompleted();    void onException(Exception ex);}

• What we have learned:
• Observer and Iterator are intimately related.
• In fact Observer is the dual of Iterator.
• Implications...