Introduction to Reactive Programming
So when the word strike REACTIVE, it merely makes us think like “acting in response to a situation.” Reactive Programming is same like that, here we deal with the stream of data which is coming continuously. Reactive programming is an asynchronous programming model where the developer process the stream of coming data to propagate the changes in code. In simple term, we can say that Reactive programming is parallel programming in which a unit of job runs separately from the main application, and this particular unit of job notifies Calling a method of its completion, failure or progress.
Anything that may change can be a stream –
- User inputs
- Data structure
- Click events
- HTTP requests
- Measures from a sensor
Reactive Programming helps in building a reactive system, and a reactive system is a system which –
- should respond promptly.
- should stay responsive in case of time failure and under varying a workload.
- should rely on asynchronous message passing.
Reactive Programming can be implemented in several ways –
- Reactive eXtension i.e. reactive + functional
- Akka Actors
Reactive programming supports decomposing or breaking the problem into multiple individually separate and distinct steps where each of these steps could be executed in an asynchronous way, and then recombining these decomposed steps to produce a workflow.
The application programming interface (APIs) for reactive programming is mostly either –
Callback – An executable code that is passed as an argument to other code, which Is expected to call back the argument at some appropriate time. Callback Based APIs are those where unidentified side-effecting callbacks are being tied with event source and are being called when the event passes through the dataflow chain.Generally, callbacks are used when –
- Downloading files.
- Reading files.
- Querying on the database.
Declarative – Where we describe our application in terms of components that know how to render themselves in given different sets of data or states, when the applications state changes, the entire application is re-rendered.
The Use Cases are as follows –
- The user sends a request to the Application.
- The application calls the service 1.
- Get the response from service 1 and send it to service 2.
- Get the response from service 2 and send it to service 3.
- Get the response from service 3 and send it to the user.
Reactive eXtension – Also know as RX, is an implementation of the responsive programming facts to compose event-based and asynchronous programs with the help of observable patterns.
RX has three basic entities
Observable –These are the data streams which combines the data which can be passed from one thread to another. They release the data as per their configuration either once in their life cycle or emitting data periodically. There are the numbers of operators available that helps the observer to produce specific data based on specific events.
Observers –They consumes the data stream produced by observable using subscribeOn( ) function. As soon as the Observable produces data, all the configured Observers receives the data in onNext( ) callback. Here they perform different functionality like updating of UI, parsing the response (XML or JSON). If any error is found from Observable, then Observer will get this error in OnError( ) function.
Schedulers – As reactive programming is asynchronous programming where we need thread management, for managing these thread we have Scheduler which Tells Observable and Observers on which thread they should execute. For achieving this, we have scheduleOn( ) method to inform Observable on which thread they should start execution.
React is a Declarative Programming
Declarative Programming – A programming that expresses the logic of a computation without describing its control flow. In this, the code is written in a way such that it represents what you want to do but not how it will be done. So it is left up to the compiler to figure out how it will be done.
Example – We use the tag image source in HTML for displaying the image as to tell the browser for displaying image and we do not care how it does that.
Features of Reactive Programming
As of now We can see the significant trends, i.e. data volume, data velocity and variety which are threatening traditional data centers. There is a common need of handling streams of live data whose size is not predetermined and the issue facing the industry is resource consumption needs to be in control in a way that fast data sources should not overwhelm the stream destination. The asynchronous methodology is required to enable the parallel use of computing resources on collaborating the network hosts or multiple CPU cores with a single machine.
Event Handling –
- 30% of the code in desktop applications.
- 50% of the bugs reported during the production cycle.
Processing user events such as –
- Mouse click and movement
- Keyboard typing.
- GPS signals getting the change over time as user move with their device.
- Touch events in devices.
Optimization – As we don’t tell the system which steps to take and also not the order of doing it, so it can rearrange the code and can even execute some of the tasks in parallel.
Monitoring with Reactive Programming
There is no concept like “set it and forget it.” Doesn’t matter how much the things getting automated, there is still a need for assuring the applications and data flow to work smoothly.
Monitoring the infrastructure is a must thing, and the monitoring should be done for both proactive and reactive purposes.
Proactive Monitoring: This monitoring collects the data to make decisions for the future.
- Allows understanding of how services are performing.
- Identifies the potential area of risk.
Places where Proactive monitoring is deployed –
Network Monitoring – As network contains data traffic in the workplace, so monitoring networks allow to determine where the problem is occurring either on protocol, transport or at the application level.
Security Monitoring – As to protect assets from security breaches for wired or wireless networks. It reduces the risk of vulnerabilities and provides real-time Information to manage security posture designed to maintain confidentiality, integrity, and availability.
Application Monitoring – Monitoring application allows an organization to address faults before they occur without impacting coworkers. It also provides metric based reports about the performance of a database, website or analytical tool. This helps an organization in performance tuning and future planning.
Reactive Monitoring – This monitoring helps in identifying the problems that are real and provide reports to fix the issues. System monitoring notifies the problem as soon as the problem gets developed, as to let the developer correct the issue before it impacts any end user or at least prevents it from turning it to a big problem.
Reactive Programming Advantages
- Need not to worry about “callback hell.”
- There are a lot of operators available to recover from Error.
- Offers APIs for UI, network access, database access, and computation.
Why we need Reactive Programming?
Tackling with the stream of data, especially live data whose volume is not determined Before, needs care in an asynchronous system. And why we need asynchronous is to enable the parallel usage of computing resources while collaborating with multiple CPU cores or network hosts within a single machine.
Scope of Reactive Programming
The range of reactive programming is to find the minimum set of methods, interfaces, and the protocol that is going to describe the essential operations and entities to attain the goal of asynchronous streams of data.
Approach for Reactive Programming
Reactive programming offers productivity for developers through the resource and performance efficiency at the component level (translating the design model into the software) for internal logic and data flow modification.To Enable Reactive Programming approach we advise taking the following steps –