Highly concurrent applications such as user interfaces have traditionally managed state through the mutation of global variables. Various actions are coordinated via event handlers, which are procedural in nature.
Over time, the complexity of a system increases. New feature requests come in, and it becomes harder and harder to reason about the application.
Functional programming presents itself as an extremely powerful ally in building reliable systems by eliminating mutable states and allowing applications to be written in a declarative and composable way.
Such principles gave rise to Functional Reactive Programming and Compositional Event Systems (CES), programming paradigms that are exceptionally useful in building asynchronous and concurrent applications. They allow you to model mutable states in a functional style.
This book is devoted to these ideas and presents a number of different tools and techniques to help manage the increasing complexity of modern systems.
Chapter 1, What is Reactive Programming?, starts by guiding you through a compelling example of a reactive application written in ClojureScript. It then takes you on a journey through the history of Reactive Programming, during which some important terminology is introduced, setting the tone for the following chapters.
Chapter 2, A Look at Reactive Extensions, explores the basics of this Reactive Programming framework. Its abstractions are introduced and important subjects such as error handling and back pressure are discussed.
Chapter 3, Asynchronous Programming and Networking, walks you through building a stock market application. It starts by using a more traditional approach and then switches to an implementation based on Reactive Extensions, examining the trade-offs between the two.
Chapter 4, Introduction to core.async, describes core.async, a library for asynchronous programming in Clojure. Here, you learn about the building blocks of Communicating Sequential Processes and how Reactive Applications are built with core.async.
Chapter 5, Creating Your Own CES Framework with core.async, embarks on the ambitious endeavor of building a CES framework. It leverages knowledge gained in the previous chapter and uses core.async as the foundation for the framework.
Chapter 6, Building a Simple ClojureScript Game with Reagi, showcases a domain where Reactive frameworks have been used for great effects in games development.
Chapter 7, The UI as a Function, shifts gears and shows how the principles of functional programming can be applied to web UI development through the lens of Om, a ClojureScript binding for Facebook's React.
Chapter 8, Futures, presents futures as a viable alternative to some classes' reactive applications. It examines the limitations of Clojure futures and presents an alternative: imminent, a library of composable futures for Clojure.
Chapter 9, A Reactive API to Amazon Web Services, describes a case study taken from a real project, where a lot of the concepts introduced throughout this book have been put together to interact with a third-party service.
Appendix A, The Algebra of Library Design, introduces concepts from Category Theory that are helpful in building reusable abstractions. The appendix is optional and won't hinder learning in the previous chapters. It presents the principles used in designing the futures library seen in Chapter 8, Futures.
Appendix B, Bibliography, provides all the references used throughout the book.