Hands-On Reactive Programming with Clojure

coverpage

Title Page

Copyright and Credits

Hands-On Reactive Programming with Clojure Second Edition

About Packt

Why subscribe?

Packt.com

Contributors

About the authors

About the reviewer

Packt is searching for authors like you

Preface

Who this book is for

What this book covers

To get the most out of this book

Download the example code files

Download the color images

Conventions used

Get in touch

Reviews

What is Reactive Programming?

A taste of Reactive Programming

The concept of time in RxJS

More colors

Making it reactive

Exercise 1.1

A bit of history

Dataflow programming

Object-oriented Reactive Programming

The most widely used reactive program

The Observer design pattern

Functional Reactive Programming

Higher-order FRP

Signals and events

Implementation challenges

First-order FRP

Asynchronous data flow

Arrowized FRP

Applications of FRP

Asynchronous programming and networking

Complex GUIs and animations

Summary

Further reading

A Look at Reactive Extensions

The observer pattern revisited

Observer – an iterator's dual

Creating observables

Custom observables

Manipulating observables

flatmap and friends

One more flatmap for the road

Error handling

OnError

Catch

Retry

Backpressure

Sample

Backpressure strategies

Summary

Further reading

Asynchronous Programming and Networking

Building a stock market monitoring application

Rolling averages

Identifying problems with our current approach

Removing incidental complexity with RxClojure

Observable rolling averages

Summary

Introduction to core.async

Asynchronous programming and concurrency

The core.async library

The Communicating Sequential Processes paper

Rewriting the stock market application with core.async

Implementing the application code

Error handling

Backpressure

Fixed buffer

Dropping buffer

Sliding buffer

Transducers

Transducers and core.async

Summary

Further reading

Creating Your Own CES Framework with core.async

A minimal CES framework

Clojure or ClojureScript?

Designing the public API

Implementing tokens

Implementing event streams

Implementing behaviors

Exercises

Exercise 5.1

Exercise 5.2

A respondent application

CES versus core.async

Summary

Further reading

Building a Simple ClojureScript Game with Reagi

Setting up the project

Game entities

Putting it all together