Modify the previous example in such a way that the sine wave is drawn using all rainbow colors. The drawing loop should look like the following:

Reactive Programming is all about building responsive applications. There are several ways in which we can make our applications reactive. Some are old ideas: dataflow programming, electronic spreadsheets, and the Observer pattern are all examples. But CES in particular has become popular in recent years.

CES aims to bring to Reactive Programming the declarative way of modeling problems that is at the core of Functional Programming. We should worry about what and not about how.

In this chapter, we took a deep dive into RxJava, a port form Microsoft's Reactive Extensions from .NET. We learned about its main abstraction, the observable, and how it relates to iterables.

We also learned how to create, manipulate, and combine observables in several ways. The examples shown here were contrived to keep things simple. Nevertheless, all concepts presented are extremely useful in real applications and will come in handy for our next chapter, where we put them to use in a more substantial example.

Finally, we finished by looking at error handling and backpressure, both of which are important characteristics of reliable applications that should always be kept in mind.

In this chapter, we simulated a real-world application with our stock market program. We've written it in a somewhat traditional way using thread pools and a custom queue implementation. We then refactored it to a CES style using RxClojure's observable sequences.

The resulting program is shorter, simpler, and easier to read once you get familiar with the core concepts of RxClojure and RxJava.

In the next Chapter we will be introduced to core.async in preparation for implementing our own basic CES framework.

By now, I hope to have proved that you can write reactive applications using core.async. It's an extremely powerful and flexible concurrency model with a rich API. If you can design your solution in terms of queues, most likely core.async is the tool you want to reach for.

This version of the stock market application is shorter and simpler than the version using only the standard Java API we developed earlier in this book—for instance, we didn't have to worry about thread pools. On the other hand, it feels like it is a little more complex than the version implemented using Reactive Extensions inChapter 3, Asynchronous Programming and Networking.

This is because core.async operates at a lower level of abstraction when compared to other frameworks. This becomes especially obvious in our application as we had to worry about creating broadcasting channels, go loops, and so on—all of which can be considered incidental complexity, not directly related to the problem at hand.

core.async does, however, provide an excellent foundation for building our own CES abstractions. This is what we will be exploring next.