So, let's first discuss the reasons to adapt functional reactive programming. There's no point in changing the whole way you code unless it gets you some really significant benefits, right? Yes, functional reactive programming gets you a set of mind-blowing benefits, as listed here:
- Get rid of the callback hell:
A callback is a method that gets called when a predefined event occurs. The mechanism of passing interfaces with callback methods is called callback mechanism. This mechanism involves a hell of a lot of code, including the interfaces, their implementations, and more. Hence, it is referred to as callback hell. - Standard mechanism for error handling:
Generally, while working with complex tasks and HTTP calls, handling errors are a major concern, especially in the absence of any standard mechanism, it becomes a headache. - It's a lot simpler than regular threading:
Though Kotlin makes it easier to work with threading as compared to Java, it's still complicated enough. Reactive programming helps to make it easier. - Straightforward way for async operations:
Threading and asynchronous operations are interrelated. As threading got easier, so did the async operations. - One for everything, the same API for every operations:
Reactive programming, especially RxKotlin, offers you a simple and straightforward API. You can use it for anything and everything, be it network call, database access, computation, or UI operations. - The functional way:
Reactive programming leads you to write readable declarative code as, here, things are more functional. - Maintainable and testable code:
The most important point-by following reactive programming properly, your program becomes more maintainable and testable.
