What happened to Scala.React?

Citing Li Haoyi,

who has used Scala.React, his observations are:

• "it is extremely difficult to set up and get started."
• "It requires a fair amount of global configuration"
• "It took several days to get a basic dataflow graph (..,) working."

He had a lot of questions but did not manage to contact the author of the publication...

Li also implemented a Scala.RX addressing these and other issues. The code is good shape but I cannot observe any action of pushing it into the Standard Scala library. Also, Li is the driver behind the ongoing Scala & Javascript effort thus he is mostly occupied with that project.

Answering your questions:

Is the JavaRx library based on Observable advisable?

JavaRx is based on the Observer pattern Martin Odersky tried to deprecate...

https://github.com/Netflix/RxJava/blob/master/rxjava-core/src/main/java/rx/Observer.java https://github.com/Netflix/RxJava/blob/master/rxjava-core/src/main/java/rx/Observable.java

While every issue Martin pointed out in the paper is true and valid, Netflix had exploited a major property of Observables:

Futures and Observables share an isomorphism, thus are composable. In JavaRx, an Observable returns a stream of events. However, a Future on the other hand, can be seen as a specialized Observable that returns only a singleton. In this case, Futures and Observables can be asynchronously composed whenever it makes sense.

Is there a story behind this?

No idea but maybe Netflix did some sponsoring. You may have noticed the Netflix logo appearing in the RX diamonds examples....

Or can we expect something similar or better from Typesafe?

I honestly doubt that. Why should they? Typesafe is busy with pushing their stack into industry and advancing Akka further. Scala.React is a neat idea but does not produce any cash whereas Akka brings them paying customers....

Instead I would ask the question what exactly Scala.React, after all, tries to solve?

IMHO,JavaRx already does a good job, is in production and those improvements Scala.React could possible add are most likely not enough for a major change.

RxJava: Reactive Extensions has very little in common with scala.react. RxJava deals with observers and concurrency but helps very little regarding correctness of evaluation order. Basically it is just streams of events, and if events that are split into several effects those will never be coherent again. Basically it's a mess and can only be used for GUI where precision in computation is not so critical. You never know when you get an extra update or extra refresh.

scala.react is a single threaded computation model and deals with order of computation with a strict evaluation order that is defined by the functional dependencies between computations.

Akka, or actors, again, is a third model and completely different thing. It is just threads with some fancy syntax and scheduliing, really.

No wonder everyone is confused. Sadly scala.react has not moved anywhere, which is bad as it's the only innovative model of these three.