RxJava- When not to use an Observable? - reactive-programming

Question

I came across a scenario in using RxJava and I am not quite sure if I should use an Observable<T> or a final ImmutableList<T>.
Basically, if I import a final and immutable dataset once and never again, should I really expose that as a cold Observable<T>?
public final class StrategyManager {
private static final StrategyManager instance = new StrategyManager();
private final ImmutableList<Strategy> strategies;
private StrategyManager() {
strategies = //import from db
}
public Observable<Strategy> getStrategies() {
return Observable.from(strategies);
}
public static StrategyManager get() {
return instance;
}
}
Or should I just expose it as an ImmutableList<T>?
public final class StrategyManager {
private static final StrategyManager instance = new StrategyManager();
private final ImmutableList<Strategy> strategies;
private StrategyManager() {
strategies = //import from db
}
public ImmutableList<Strategy> getStrategies() {
return strategies;
}
public static StrategyManager get() {
return instance;
}
}
If I expose it as an ImmutableList<T>, the clients have one less monad to deal with for something that will always be constant.
However, maybe I lose flexibility and should use an Observable<T>. For instance, I can decide to use RxJava-JDBC to query the data directly on each call without any caching. Or I can cache() or even replay() so the data can expire and free up memory.
public final class StrategyManager {
private static final StrategyManager instance = new StrategyManager();
private final Observable<Strategy> strategies;
private Database db = null;
private StrategyManager() {
strategies = db.select("SELECT * FROM STRATEGY")
.autoMap(Strategy.class)
.replay(1, TimeUnit.MINUTES)
.autoConnect();
}
public Observable<Strategy> getStrategies() {
return strategies;
}
public static StrategyManager get() {
return instance;
}
}
So my question is, are there situations to not use an Observable? Or in a reactive application, should I always use an Observable even for constant data sets that will not change? Am I right that I should use the latter for flexibility and easily changing behaviors?

Answer 1

I like the question. I suppose there a lots of factors involved in the decision to use a reactive API and no clear Yes or No answer, just a judgement call on what the future might hold.
should I always use an Observable even for constant data sets that will not change?
If you want maximal flexibility, don't mind burdening the client with using RxJava, don't mind debugging difficulties (you've seen long RxJava stacktraces) then use an Observable. Note that even for a "constant data set that will not change" your memory constraints might change and a large data set might not be suitable for holding in memory any more.
Another thing to keep in mind is that Observables do have some processing overhead (volatile reads on every emission for potentially every operator in the chain) so for performance reasons it's sometimes good not to use.
Your use cases, your data and your benchmarks will really determine which way you go.
Would be interesting to hear from API designers within Netflix (and anywhere else) about their experience.