Akka

Akka is a foundational framework (set of reusable abstractions)

• reactive Streams (nothing is evaluated before explicitly “consumed”)
• Actors from Erlang (share-nothing, async message-passing, persistent mailboxes)
• everything is asynchronous (runs on scala.concurrent abstractions)

A typical use case for stream processing is consuming a live stream of data (K-Lines, an OrderBook, etc.) that we want to extract or aggregate some other data from as it goes, without slowing down - pseudo real-time.

Conceptually we can do transformations, like traditional map, scan, filter and then consumption (updating some moving averages, etc).

At least in theory, with asynchronous (reactive) non-blocking processing we always must be way faster than any internet connection, and this is why we are using this bloated framework and JVM.

We delegate all that enormous complexity of implementations to the JVM, Scala and Akka developers and communities respectively, hoping (because it is impossible to know, leave alone understand all the details) that they did everything right.

At least the design is very good - declarative, functional DSLs and message-passing Actors instead of method calls (actual non-blocking communication) with dynamic buffers inside and back-pressure coordination (via messages).

It will be beautiful if they spend some effort to make at least design minimal and “perfect” (when there is nothing to remove), but corporate code tends to go in opposite direction, adding more and more features.

Anyway.