Reactive jLove

Reactive Systems — as defined by the Reactive Manifesto — is a set of architectural design principles for building more robust, more resilient, more flexible and better positioned to meet modern demands systems.

The idea of Reactive Systems is not new. In 70s and 80s Jim Gray and Pat Helland presented their work on the Tandem System and Joe Armstrong and Robert Virding on Erlang.

However, Reactive is probably one of the less understood terms. It is often abused, and it seems if we want to make something sound cooler, then we can put "Reactive" in front of it.

There are a lot of talks to explain Reactive's primary goals and why it does matter today. But what’s important to understand is that Reactive Systems are not tied to a concrete language/framework, programming model or network interaction style. Instead, it focuses on the principles of such systems, and there are only 8 of them: Stay Responsive, Accept Uncertainty, Embrace Failure, Assert Autonomy, Tailor Consistency, Decouple Time, Decouple Space, Handle Dynamics.

As of now, we are living in a Kubernetes/Container era. Architectural styles like microservices and serverless are growing in popularity.
Data streams that have always been there starting to expand their niche.
Reactive has a lot of essential characteristics to build such systems.

So, Reactive will be a necessary trend for the next five years and let's explore what jLove speakers say about it.

Enabling real time collaboration with RSocket by Sergey Tselovalnikov

Most of the client-server interactions can be expressed with the request-response paradigm, which maps pretty well to HTTP. However, once users start interacting with each other, the request-response paradigm hits its limits as users need to see each other's actions as soon as possible.

This leads to the situation where the backends have to push data to the clients before it's requested. Building such a system is difficult when the number of clients is large since every such a client needs to maintain a connection to the backend. At Canva, we enabled our users to collaborate with each other by introducing services that support bidirectional streaming with RSocket. The talk walks over the challenges that we faced building these services, and the solutions we came up with.

Reacting to an Event-Driven World by Grace Jansen and Kate Stanley

In this session explore how Kafka and Reactive application architecture can be combined in applications to better handle our modern data needs.

Outline:

• The need for event-driven architecture with example
• Correcting the incorrect assumption that using Kafka give you complete Reactivity and what this really means (i.e. reactive programming, reactive architecture, reactive manifesto)
• How to configure Kafka to best enable the cornerstones of the reactive manifesto (with analogies to original example)
• How to get started with Kafka
• Reactive Kafka frameworks available
• Demo application built using Kafka and Vert.x Kafka client and significant changes made when re-architecting this application
• Useful resources and helpful links

Reactive Spring by Josh Long

Join Spring Developer Advocate Josh Long (@starbuxman) for a roving tour of how to build more cloud-native, reactive, scalable services with Spring Boot.

Thirst-Quenching Streams for the Reactive Mind by Mary Grygleski

With the advances in multicore hardware and virtualization technologies, and the demand for highly responsive, resilient, and elastic systems and increasingly sophisticated applications, an array of reactive data stream processing libraries have been born to address the needs. Reactive Streams is an initiative to provide a standard for asynchronous stream processing with non-blocking back pressure. This encompasses efforts aimed at runtime environments that include JVM and Javascript, as well as network protocols. So how do the various library implementations of Reactive Streams, such as Spring Reactor, Akka Streams, Vert.x, and RSocket, stack up against each other? And what about Project Loom, and the introductions of continuations and fibers? Will these seemingly promising new features eventually replace reactive? This talk will go into explaining and demonstrating the practical use of reactive streams, then also present some initial analysis on how fibers may potentially become the "new reactive" for the future.

This presentation will go into some details on how streams leverage on the underlying multicore processor to achieve parallelism. It will then explain the push vs the pull streaming model. It will then use a simple use case with code examples to illustrate the different API usages, as well as runtime processing analysis between a few popular Java implementations of Reactive Streams.

Fly like a rocket with Helidon by Dmitry Alexandrov

Good news, everyone! Helidon got a jet engine! Now Helidon is packed with modern, high-tech, James Bond-level features and it flies like a rocket! Also, thanks to a nicely crafted fitness plan, the weight has been reduced and concentration increased - resulting in less RAM consumption and faster waking. Come to my live coding session to learn about all of the new features added in Helidon 2.1; such as GraalVM native image support in Helidon MP, MicroProfile Reactive Streams and Reactive Stream Operators, Helidon DB Client and HTTP Client in Helidon SE. I will also be demonstrating the new command line tool and live-reloading feature which will nitro-boost your development process.

How we got 10x performance in RSocket by Oleh Dokuka

Do you care about performance in Java? Do you want to get a better one? In this talk, I will share what we learned improving the performance of RSocket - Java; Why did we do that?; and of course What you can do to optimize your application.