Reactive programming is, quite simply, a programming paradigm where you are working with an asynchronous data flow. There are a lot of books and blog posts that argue about what reactive programming is, exactly, but if you delve too deeply too quickly it’s easy to get confused. Then reactive programming isn’t useful at all. Functional reactive programming takes the principles of functional programming and uses them to enhance reactive programming. You take functions – like map, filter, and reduce – and use them to better manage streams of data.

Read now: What is the Reactive manifesto?

How does imperative programming compare to reactive programming?

Imperative programming makes you describe the steps a computer must do to execute a task. In comparison, functional reactive programming gives you the constructs to propagate changes. This means so you have to think more about what to do than how to do it.

This can be illustrated in a simple sum of two numbers. This could be presented as a = b + c in an imperative programming. A single line of code expresses the sum – that’s straightforward, right? However, if we change the value of b or c, the value doesn’t change – you wouldn’t want it to change if you were using an imperative approach. In reactive programming, by contrast, the changes you make to different figures would react accordingly. Imagine the sum in a Microsoft Excel spreadsheet. Every time you change the value of the column b or c it recalculate the value of a. This is like a very basic form of software propagation.

You probably already use an asynchronous data flow. Every time you add a listener to a mouse click or a keystroke in a web page we pass a function to react to that user input. So, a mouse click might be seen as a stream of events which you can observe; you can then execute a function when it happens. But, this is only one way of using event streams. You might want more sophistication and control over your streams.

Reactive programming takes this to the next level. When you use it you can react to changes in anything – that could be changes in:

• user inputs
• external sources
• database changes
• changes to variables and properties

This then means you can create a stream of events following on from specific actions. For example, we can see the changing value of stocks stock as an EventStream. If you can do this you can then use it to show a user when to buy or sell those stocks in real time. Facebook and Twitter are another good example of where software reacts to changes in external source streams -reactive programming is an important component in developing really dynamic UI that are characteristic of social media sites.

Functional reactive programming

Functional reactive programming, then gives you the ability to do a lot with streams of data or events. You can filter, combine, map buffer, for example. Going back to the stock example above, you can ‘listen’ to different stocks and use a filter function to present ones worth buying to the user in real time:

Why do I need functional reactive programming?

Functional reactive programming is especially useful for:

• Graphical user interface
• Animation
• Robotics
• Simulation
• Computer Vision

A few years ago, all a user could do in a web app was fill in a form with bits of data and post it to a server.  Today web and mobile apps are much richer for users.

To go into more detail, by using reactive programming, you can abstract the source of data to the business logic of the application. What this means in practice is that you can write more concise and decoupled code. In turn, this makes code much more reusable and testable, as you can easily mock streams to test your business logic when testing application.

Read more:

• Introduction to JavaScript
• Breaking into Microservices Architecture
• JSON with JSON.Net