Chapter 6. Being reactive

 

This chapter covers

  • Introduction to reactive domain models
  • Reactive API design using futures and promises
  • Reactive communication between bounded contexts using asynchronous messaging
  • The stream model with example implementations from Akka Streams
  • The actor model of communication

So far you’ve learned about the virtues of functional programming and how to apply these principles when you design a domain model. This chapter starts the discussion of how to make your functional domain model reactive. You want your model to be responsive to users, elastic for scalability, resilient to failures, and decoupled in time and space using message-driven architectures.[1] This chapter covers various ways of being reactive with domain models built using Scala. You’ll take a step up from the low-level concurrency primitives such as threads and semaphores and use higher-order abstractions that Scala offers. These include designing APIs using futures and promises, implementing loosely coupled architectures with asynchronous messaging, building stream pipelines, and finally using the actor model that also provides fault tolerance and redundancy.

Figure 6.1 shows a schematic of this chapter’s topics. This guide will help you selectively choose your topics as you sail through the chapter.

Figure 6.1. The progression of this chapter’s sections

6.1. Reactive domain models

6.2. Nonblocking API design with futures

6.2.1. Asynchrony as a stackable effect

6.2.2. Monad transformer-based implementation

6.2.3. Reducing latency with parallel fetch—a reactive pattern

6.2.4. Using scalaz.concurrent.Task as the reactive construct

6.3. Explicit asynchronous messaging

6.4. The stream model

6.4.1. A sample use case

6.4.2. A graph as a domain pipeline

6.4.3. Back-pressure handling

6.5. The actor model