What this book covers
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 as seen in Chapter 8, Futures.
Appendix B, Bibliography, provides all the references used throughout the book.
What you need for this book
This book assumes that you have a reasonably modern desktop or laptop computer as well as a working Clojure environment with leiningen (see http://leiningen.org/) properly configured.
Who this book is for
This book is for Clojure developers who are currently building or planning to build asynchronous and concurrent applications and who are interested in how they can apply the principles and tools of Reactive Programming to their daily jobs.
Knowledge of Clojure and leiningen—a popular Clojure build tool—is required.
The book also features several ClojureScript examples, and as such, familiarity with ClojureScript and web development, in general, it will be helpful.
Notwithstanding, the chapters have been carefully written in such a way that as long as you possess knowledge of Clojure, following these examples should only require a little extra effort.
As this book progresses, it lays out the building blocks required by later chapters, and as such my recommendation is that you start with Chapter 1, What is Reactive Programming? and work your way through subsequent chapters in order.
A clear exception to this is Appendix A, The Algebra of Library Design, which is optional and can be read independent of the others—although reading Chapter 8, Futures, might provide a useful background.