Reactive Java runs on fewer threads, but you must relearn how to debug
A Spring MVC service under heavy request volume can slow down and even hit an out-of-memory error, while a non-blocking reactive stack is built to run on fewer threads. Backend developer and Microsoft MVP Kamila Oliveira, who uses Project Reactor in all her work, traces the path from the Reactive Manifesto to a live Spring WebFlux API. What changes in code, and what does the switch cost?
Learn when to return Flux or Mono and see a reactive MongoDB CRUD API built with Spring WebFlux
Kamila Oliveira introduces reactive programming in Java, from the Reactive Manifesto and the Reactive Streams interfaces to RxJava operators, backpressure, Flux and Mono. She explains why Spring WebFlux was built as a non-blocking alternative to Spring MVC and demonstrates a reactive CRUD API backed by MongoDB, closing with the benefits and costs of the paradigm.
“It is a feedback from the receiver to the producer or from the subscriber to the publisher that he is not supporting the load.”
“Spring Web Flux was developed because we need the non-blocking application.”
What you will learn
Explain the four Reactive Manifesto principles: responsive, resilient, elastic and message driven.
Distinguish the Publisher, Subscriber, Subscription and Processor interfaces defined by Reactive Streams.
Choose Flux for endpoints that return zero to many items and Mono for zero or one item.
Identify the dependencies and repository changes needed to move from Spring MVC to Spring WebFlux.
Anticipate the learning curve and different stack-trace debugging that reactive code brings.
Key takeaways from the speaker
java
backend
reactive programming
Details
Level
Beginner
Format
Tech talk
Technical depth
Practitioner
For
Early career, Mid-career
Length
37:17
Published
June 2021
Questions this talk answers
What are the principles of the Reactive Manifesto?
A reactive system is responsive, resilient, elastic and message driven, staying responsive under failures and whether it receives one request or ten million.
What is backpressure?
Backpressure is feedback from the subscriber to the publisher that it cannot support the load, so the flow of data can be adjusted.
What is the difference between Flux and Mono?
A Flux can emit zero to n events, while a Mono emits zero or one event; both pass through onNext, onError and onComplete.
Why was Spring WebFlux created alongside Spring MVC?
The servlet API is blocking by definition, and the NIO API added in Servlet 3.1 did not match the rest of it, so a non-blocking stack running on few threads was needed.
What changes when building an API with Spring WebFlux instead of Spring MVC?
You use the WebFlux starter, a reactive database driver and repository such as ReactiveMongoRepository, the WebFlux variant of springdoc, and endpoints that return Flux or Mono.
About this talk
Let's talk about the principles of reactive programming and how Java has evolved since object orientation, the concepts of reactive programming that started to come with Java 8 and how this led to the emergence of Webflux. And we will see an example of an API with Spring Webflux using the Reactor library and the asynchronous server Netty.
Speaker 2: So let's start the presentation. Hi everyone. Today we talk about reactive programming Java. The first step is in reactive programming Java. I am Kamila Santos Oliveira. I am back-end developer at XM Digital. I am also Microsoft XMVP and developer technologies and community coordinator at the GozoMaker's Code and Peripher Code Brazilian Tech Communities and I also be co-author of the book Jornada Java. So, first let's define what is reactive, sorry, reactive.
Reactive paradigm is a programming paradigm oriented to data and event flows as well as synchronize. Because it works as synchronize, it is recommended to handle large undergo major changes in the real time, for example, social networks, mobile applications, and streaming applications. The most successful programming is Netflix that have many requests, for example. So, it's an example case. Reactive paradigm is also widely used in social networks, front-end and back-end, because it works oriented to user actions that result in events.
One of the principles of reactive programming and reactive paradigm is the reactive manifest. Reactive Manifest has four principles that are responsibly resilient, elastic, and message driven. Responsibly means that the system responds in a timely manner, if possible. Resilient, the system remains responsive to failures. Elastically, the system remains responsible in the face of a variable workload. We can have one request, or 10 million requests that systems must stay responsible, elastic and resilient.
Message driven. Reactive applications rely on a synchronous message to establish a boundary between events, ensure flexible complete isolation and transparency in the application. We have some frameworks and libraries in reactive programming in Java. The first is RE-X-Java. RE-X-Java is an implementation for the reactive X-stations JVM, which is a synchronous and event-based library that works with observable sequence. It extends from the observer pattern. Observer pattern is a pattern that have each object, college subject, of dependent observers that are automatically notified to exchange of the stage throw data operators and methods.
RE-X-Java supports data sequence and events to compose your event strings in a declarative way. We have some components in RE-X-Java and reactive programming also. The first is a map. Map transforming we have the items emitted by observable by applying a function to each item. And we have an example of a map operator. For example, we have the observable dot from, then have the letters variable. We apply the map function that converts this to uppercase.
And we have the result for the variable in the uppercase. We have another operator that is scan function to each item emitted by observable sequentially and emit each successive value. Scal operators, we have another example. For example, we have the array of strings and letters. We have J, A, V, and A. We do an observable from letters that makes a scan from this and we return a new string builder and append this in this way. We have another operator that's filter. The filter operators emit all of those items from observable that pass a bridge cache.
And I have another example of the filter operator. We also use the observables. You can see this observable from numbers. We have a filter of this and made a subscriber. After I will define what subscriber and subscription. And the reactive strings, that is the base of Java and the reactive programming. Reactive strings, it's an initiative to provide a standard, a guide and a set of rules for a synchronous flow processing with NIO that is non-blocking input and output backpressor. Reactive strings has some interfaces and methods. The first is the interface flow publisher that contains methods to produce strings and other events in the application. And we have an example of the interface publisher. And we have just one method in the interface publisher that is the subscriber. So publisher publishes some events. And we
made the subscriber from this event for a subscriber that will read this information produced by the publisher. And we also have the interface flow subscriber. This interface contains methods for recycling strings and another events for the our application. In the interface subscriber we have four methods. We have the own subscriber that indicates an action that will be done when subscribing in your variable in your class.
On next case, the next step that will be done with the result of some item, or some action, sorry. On error indicates that we will get some error in the application complete. When you finish some action that passed from the on action on subscriber, we will don't some action when we pass this operator, this method on complete. We have other, other in their description. In their interfaces flow to description, we have methods for linking publisher and subscriber. So description is a connection between the publisher that produces some information and the subscriber that reads the receiver, the information from this publisher, these events, this data, these streams that is produced by the publisher. The subscription is the connection between these two objects in the reactive programming. And the subscription interface, we have two methods. We have the request that you
request a new subscription between the publisher and the subscriber. And we have the cancel method that can sell the subscription, can sell this this relation between a publisher and a subscriber. We have another interface that the interface flow processor. The interface flow processor is responsible for The interface flow processor doesn't have any methods. This just extends from flow subscriber and flow From from flow publisher. And the last, I think is the last, the last class from the reactive streams is the submission publisher that implements the flow publisher that is a flexible with item producer according to the reactive streams. Reactive streams is a set of rules that's many rules and many codes and many, many operations between the operations between and then I just just bring some of them because it's many information about reactive streams. This is the simplest way of explaining the reactivist. In the class, transform processor, the exchange, the submission publisher and implement the flow processor that are explained in the previous. And reactive streams, what is the mission, the object of the reactive streams? And reactive streams, what is the mission, the object of the reactive streams? And reactive streams, what is the mission, the object of the
Reactive streams? And reactive streams? And reactive streams? And reactive streams is intended for runtime environments in the JVM, as well as network protocols, you can see in detail after that in the reactive streams. JVM GitHub. The main objective of reactive streams is to define the exchange of flow data through an asynchronous. So, so how the library that is in the library that is in the library. So how the library that uses reactive programming in Java or other languages is based on reactive streams is a set of rules that all languages must follow when you are working with reactive programming. Reactive programming is the scope to find a minimal set of methods, interfaces, and protocols that will describe the operations and entities necessary to to have asynchronous data to have asynchronous data flows with NIO that is non-blocking input and output. And we have some reactive programming concepts that I talked about observables, publishers, subscribers. So now let's see what is, what means each of these publishers, subscribers, and observables, and others.
The first concept is backpressor. Backpressor is the resistance or strength that suppose the desired data flow through the software. It is a feedback from the receiver to the producer or from the subscriber to the publisher that he is not supporting the load. A string is a sequence of objects that support various methods that can be operated to produce a result.
A string is linked to a data search. A string is capable of emit three events. We have the on next event that represents some value that go to the next value or next step in the list. On error that there was an indication that you are on error in the execution. On complete in the case of finish event indicates that finished the list of events or the list of steps of actions.
A flux can meet from zero to an event passing through on next, on complete and on error. And here we have an example of the timeline of flux from the left to right. In the example we can see we have six elements, six objects that pass from this operator. This operator can be a map, scan another operator that uses a new reactive programming.
Sorry, sorry. This box indicates the transformation that operator performs in the flux. And after pass for this operator, this object has resulted in a transformation. And if we have some error, then we produce on error in the end of the action. And we have the monos. And the difference between flux and mono, that mono can be emit just the zero from on one event.
In the flux, we can emit zero to n events. And mono also can pass from an action, complete, and an error. And we also have the representative, the image is not in a high definition. And this is a monotimeline from the left to right also. We have one item issued by a mono. That also passed from some operator.
This box indicates the transformation that the operator performs in a mono. And it results some transformation. If we have some error, we will return on error. And we have some finished agenda. We will return on complete some action after this. Unobservable. Unobservable can pass a message asynchronously. A subscriber or a receiver, as I was saying in previous slides, consumes the data received from a subscription.
A publisher produces the data that will be consumed from the subscription. And a subscription is a connection between subscriber and publisher. And here we have some example of this flow of this process. We have the publisher that produces some data and send events to the subscriber that consumes the data. The backpressor is the response of this subscriber.
It's not able to process this message. For example, we have producing millions of data, millions of streams. And the subscriber cannot read this information. And we use this backpressor to send this feedback to the publisher to make this load balancer and work with other threads or other alternatives with this information. A cold observable. We have cold and hot observable.
A cold observable is the sequence of events. It's only executed if the observable has an associated. And hot observable broadcasts events regardless of weather that is an associated. Area socket is a binary point-to-point communication protocol intended in distribution of the applications. Area socket enables the following symmetric interactions model using async message passing over a single connection. We have a request response.
We have a request response that is a string of one information. Request to a string that is a finished string of many. And we have a file that does not have any response. And a B-directional strings. Area socket supports the resumption of the cesium that allows the resumption of long-term flows in different transport connections. R2DBC is the relational database connectivity that brings reactive programming's API to relational database.
R2DBC is also based on the reactive string specification that a set of rules is a guide of reactive programming. R2DBC provides an open specification. So, and with R2DBC, we can work as synchronous and with NIO, work with relational database. So, parts is scalable. And finally, Spring Web Flux. Spring Web Flux is the most used framework about reactive programming in Java.
Spring Web Flux can be defined as a parallel version to the already known and widely used Spring MVC, the servlet API. And having as main difference the support of reactive and I/O strings. And supporting the concept of backpressor with the net server coming by default embedded in this architecture. In Web Flux is a stereo of using the Tomcat and the servlet container and other components to the servlet API.
We use the net server. We have this net server embedded in the architecture of Spring Web Flux. But you can also use jet server or undertown server. Spring Web Flux from version 5.0 of the Spring framework. We have a reactive part in addition to the servlet structure that already exists. And each model of this is optional. You can use the servlet part, the reactive part, or even both in your application can make a mix of the reactive structure and the servlet structure or use it out of the reactive or our servlet.
This is the stack of Spring framework that we have the servlet container that has these components, the servlet API, the Spring Web MVC, and work with controller and request mapping. And in the reactive stack, we have the Tomcat, the Jet, the net and the undertown server. In stereo of work with the servlet API, we have the HTTP and reactive strings.
And in stereo of work with Spring Web MVC, we work with Spring Web Flux. And in stereo of work with the controller and request mapping, we can use it with other functions. And this is an example that I will show in the end of this presentation. I don't use the halter functions because it's so complicated to change in the beginning of working with Spring Web Flux.
So I use all these components and controller and request mapping. I made this mix of the two weeks. Spring Web Flux was developed because we need the non-blocking application. That code work with a small number of threads and that code will run with some high source. In the servlet 3.1, an NIO API was provided, but it does not correspond to the rest of the API.
That servlet API is blocking in your definition when an NIO API is the opposite of the servlet contract. These factors were the decision for the development of a new API that was used independently of the execution time and is a non-blocking way. It was possible with the service net, for example, or some net and others that consolidated themselves in the asynchronous and non-blocking operation.
Another at Spring Web Flux makes it easier to understand the user the concept of functional and reactive programming with the addition of Java eight functional fixtures and the flowable API reactive streams in Java. Another at Spring Web Flux enables Spring Web Flux to have functional endpoints and another controllers in your applications. And how requests work? What is the flow?
Steps for our request is processing. In this model, in the Spring MVC model, depending on the volume of a request and the way it was developed can cause a slow application and even an out-of-memory error. This type of error usually occurs when we keep objects for a long time or try to process data. And what steps contain the process of request?
The user made the request, the request, sorry, pass for the servlet to catch that has the thread pool, pass for the dispatcher servlet, pass for the request mapping and after to the controller, after to the service. After, uh, uh, uh, made some database operations, a get or a post operations and for finish, return some response. On AppFlux, we have different process and we have called the data and we have some on action, action, action, action, on error, on complete result.
And return the data. And we have the user made some requests that pass for the net and IO, pass for the event loop in the net server, pass from the reactive strings adapter. After pass for the dispatcher handler and after from the functional endpoints and return this response for the user. We have, uh, famous and most used library in the reactive programming that I use all my work.
That is project reactor. Project reactor is a library based on the strings specification. It is complex directly directly with the functional JVPI using the string duration and completable feature for composing elements using flux and mono. In the microservice architectures offering backpressor mechanisms ready for TCP, UDP and ATTP, including web sockets. Uh, uh, uh, uh, uh, uh, uh, uh, uh, reactor modules are abstracted and interoperable reactive flows too fast.
And can be used with the spring frameworks, drivers and client, for example, cloud foundry, Java client in protocols. Uh, some, for example, where to the DC and the red socket that, uh, I already explained in the previous slides. We have three components and the reactor. We have the reactor card. That is the main part of this library.
The other models depending on the reactor card. The after car provides reactive types that implement the publisher that provided flux and mono. Reactor net is the server for our NIO application user for development high scale, scalable servers. And now I have some in my screen for the other screen. Just a moment. Let me check. All right. Let me just increase the size of the ladder.
So this is a very simple example of reactive programming. I will explain what the pain is I use in here and what steps I use it for made this CRUD using WebFlux. So what's the difference for a spring WebFlux application from a spring MVC application. First is the dependence. For example, instead of using the springy starter web, if I not forgot, we use in the springy boot starter WebFlux that contains the net embedded in other factors.
Instead of using, how can I say, a blocking driver for database. In this application, I use MongoDB in a Docker container that is already running. I use a reactive driver for MongoDB that for all databases, I think we have a reactive driver. So we have the dependence, the spring boot starter data MongoDB reactive. Other dependence that is exclusive of spring WebFlux is the spring doc.
We have the spring doc for MPC. And when we use in spring WebFlux, we need to use the spring doc open API WebFlux UI. For tests, we have this embedded reactor test that has a test and reactive applications. So let's go see the code. First, let's talk about the model. The model doesn't have many difference for a spring MVC example.
Now here we have a class that's the model up table of speakers that have the fields ID name and stack. We have some constraints here. And now there is the repository. In repository, we have some difference. For example, we extends from the reactive Mongo repository. That have some methods that you have insert to find out and others methods.
Reactive Mongo repository extends from reactive certain repository and also extends from the reactive query by example executor. You always see the reactive word in this dependence. And the class that has some details that I need to explain is the controller. Here I'm using REST controller that is part of the servlet API. I made the mix. In my work, I used REST controller instead of outer functions.
But using WebFlux. So I can use this servlet and WebFlux at the same time. So let's talk about the structure of this class. We have the flux and the mono. For example, when I have a point that return our speakers. That is a speaker crude. That return our speakers. How I am using zero to end speakers. Many speakers in this.
In this endpoint, we work with a flux. When I use a post that I'm just creating one speaker. I use a mono. When I am getting by ID that I just returned one speaker also. I am using mono. Delete. I am also using mono. And when I work with strings that return the data in other format. That not is JSON is other format.
We work with a flux because it's a flux of various speakers. Let's see if this demo is working. I have some minutes to the end. Yeah, it's working. Okay. I think I don't have a speaker created. I will share the postman screen now. Let me change this screen. Here we have the postman. The application is running. In other window here.
Let's try to create some speakers and get the speakers. Okay. request. in another window here let's try to create some speakers and get the speakers request it's a post you have a body let's part 8080 let me check the field names we have a name and a stack right name camilla and the stack is let's see if it works i hope that works and the request oh attp not found let me check nice speaker let's try again yes i created the new speakers the id is auto generated with the name camille so i call this this is the create endpoint that is a mono because we just can create a one speaker let's get the speaker speaker sorry right right let's send the request let's create other speakers
let's try to define by id this id this is working i will share with you um on the end of events uh get but and delete let's try the delete endpoint okay let's create other just to show how a stream returns the informations women text speaker right right let me check what's the end point of stream remember that is a flux of screen we have uh various speakers uh strangers of speakers let me try oh speaker uh the difference between get using json and using a string is that in json i'll change this let me get this id to bring the other speakers in json we have the data returning in this ways with this json format and when you're using a string and the attorney is in other formats let me check when how can
oh not not shows uh the response will uh come with this data on the beginning and have this other format of response but have the same um we don't use the screen in the work generally but this is a way to to show what uh contains in the stream uh in streams uh mainly component of reactive programming so just for curiosity uh and show you how uh a structure of the strings the strings are another type of return oh sorry uh strings uh don't work with application json and that is a this media type text event uh so let me return to the presentation all right uh just uh remember the example at springboot starter web flux and springboot starter that among the b reactives
in this repository the main difference that extends from reactive among the b repository in the endpoints the difference and story of uh using response entity or just uh the name of some response class we must pass and that if the return of the response of this endpoint will be a flux or a mono and what are the benefits of reactive programming reactive programming is non-blocking which generates a certain performance gain uh reactive programs works with fewer threats less use it and spend memory reactive programming follow the principles of the reactive manifest just uh remember uh responsibly resilient elastic and message driving applications and what the problems cause nothing's perfect the problems is a different form of programming uh is a declarative way of programming uh mainly if you're using um halter functions you will see many
difference from the normal way of programming java and you need to learn another forms of work you need to learn how this base of reactive programming when you are working with web flex so sometimes we don't have a sufficient time to learn a new paradigm in the work or other situation so it's a problem of reactive programming in my opinion another uh problem is the the way of the air horse are informed because the debugging in the stack tracing of spring web flux is many different of spring mvc so it's another problem you need to learn how to analyze uh errors and stack traces in another way but uh other other topics is just benefits using spring web flux uh here i have with some reference that i use in
in this this presentation i will share the slides with the organization and in my social networks after this and here we have the my linkedin profile and my twitter profile feel free to connect to talk about reactive programming our other topic and thanks for asking and thanks for opportunity to stay here
Transcribed automatically; names checked against the speaker record. Select a time to jump there.
Article based on this talk
What does it take to go reactive in Java?
Kamila Oliveira walks Java developers from the Reactive Manifesto to a working Spring WebFlux API, and is honest about the trade-offs.
In short
Reactive programming in Java rests on a small set of ideas: data and events flow asynchronously from publishers to subscribers, and subscribers can push back when they are overloaded. Kamila Oliveira, Backend Developer at Ame Digital and Microsoft MVP, shows how those ideas grew from the Reactive Manifesto and the Reactive Streams standard into Spring WebFlux and Project Reactor, then builds a reactive CRUD API on MongoDB. Her verdict: reactive code uses fewer threads and less memory, but it asks developers to learn a new, declarative way of programming and debugging.
Key takeaways
Explain the four Reactive Manifesto principles: responsive, resilient, elastic and message driven.
Distinguish the Publisher, Subscriber, Subscription and Processor interfaces defined by Reactive Streams.
Choose Flux for endpoints that return zero to many items and Mono for zero or one item.
Identify the dependencies and repository changes needed to move from Spring MVC to Spring WebFlux.
Anticipate the learning curve and different stack-trace debugging that reactive code brings.
What makes a system reactive
Oliveira opens by defining the reactive paradigm as programming oriented to data and event flows that run asynchronously. That makes it a fit for systems facing large volumes and constant change in real time, and she points to social networks, mobile apps and streaming services, naming Netflix as an example of an application with many requests.
"Reactive paradigm is also widely used in social networks, front-end and back-end, because it works oriented to user actions that result in events." (0:46)
The foundation is the Reactive Manifesto and its four principles. A system should respond in a timely manner, stay responsive in the face of failure, stay responsive under a variable workload (whether that means one request or ten million) and rely on asynchronous messages to keep components isolated. From there she introduces RxJava, an implementation of ReactiveX for the JVM built on the observer pattern, and walks through three operators with code: map to transform each emitted item, scan to apply a function sequentially and emit each successive value, and filter to pass only items that meet a condition.
The vocabulary: publishers, subscribers and backpressure
The next layer is Reactive Streams, which Oliveira describes as a set of rules that libraries across languages follow for asynchronous stream processing with non-blocking I/O. She covers its interfaces: a Publisher that produces events, a Subscriber with onSubscribe, onNext, onError and onComplete, a Subscription that links the two and supports request and cancel, and a Processor that extends both sides.
The concept that ties these together is backpressure.
"It is a feedback from the receiver to the producer or from the subscriber to the publisher that he is not supporting the load." (10:17)
She then contrasts the two types every WebFlux developer meets daily. "In the flux, we can emit zero to n events." (12:15) A Mono, by contrast, emits zero or one. Using marble-style timelines, she shows items passing through an operator, being transformed, and ending in either onComplete or onError. She also briefly covers cold observables (which run only when something subscribes) and hot observables (which broadcast regardless), the RSocket binary protocol, and R2DBC, which brings reactive APIs to relational databases.
Why Spring WebFlux exists
"Spring Web Flux is the most used framework about reactive programming in Java." (15:23) Oliveira presents it as a parallel to Spring MVC, available since version 5.0 of the Spring framework, with Netty embedded by default instead of a servlet container (Jetty and Undertow are also options). Teams can use the servlet stack, the reactive stack, or both.
The motivation was architectural. "Spring Web Flux was developed because we need the non-blocking application." (18:04) The servlet API is blocking by definition, and the NIO API added in Servlet 3.1 did not match the rest of the contract. In the Spring MVC model, she explains, a high volume of requests can slow an application and even cause an out-of-memory error. The reactive request flow is different: a request passes through Netty's event loop, a reactive streams adapter and a dispatcher handler before reaching the endpoint. Underneath sits Project Reactor, the library she says she uses in all her work, with Reactor Core providing Flux and Mono and Reactor Netty serving as the non-blocking server.
From slides to a working API, and the trade-offs
The demo is a speaker CRUD service backed by MongoDB in Docker. Oliveira highlights what actually changes from a Spring MVC project: the WebFlux starter instead of the web starter, a reactive MongoDB driver, the WebFlux variant of springdoc for API documentation, reactor-test for testing, and a repository that extends ReactiveMongoRepository. She keeps familiar REST controllers rather than router functions, which she considers hard to adopt at the start. "So I can use this servlet and WebFlux at the same time." (26:34)
The return types follow the cardinality of the data. Listing all speakers returns a Flux; creating, fetching by ID and deleting return a Mono. "When I use a post that I'm just creating one speaker. I use a mono." (27:01) In Postman she creates and fetches speakers, then shows a streaming endpoint that returns a text event stream instead of JSON, to make the stream visible.
She closes with an honest balance. Reactive programming is non-blocking, works with fewer threads and uses less memory, and it follows the Manifesto's principles. But it is a declarative, different way of programming Java, teams do not always have time to learn a new paradigm at work, and stack traces in WebFlux look very different from Spring MVC, so developers must learn to analyse errors in a new way.
Watch the talk
"First steps with reactive programming in Java" by Kamila Oliveira, 37 minutes: https://www.womentech.net/video/first-steps-reactive-programming-in-java
About the speaker
Kamila Oliveira is a Microsoft MVP and Backend Developer at Ame Digital, holds a bachelor's degree in computer science and co-organizes the WoMakersCode, DevsJavaGirl and PerifaCode communities. She has spoken at Java Global Summit 2020, JLove Conference and The Developers Conference, writes tech articles on dev.to and is a co-author of the book Jornada Java.
Questions this talk answers
What are the principles of the Reactive Manifesto?
What is backpressure?
What is the difference between Flux and Mono?
Why was Spring WebFlux created alongside Spring MVC?
What changes when building an API with Spring WebFlux instead of Spring MVC?
Drafted with AI from the talk transcript. Editor review pending.
Frameworks and ideas mentioned
Reactive Manifesto
Reactive Streams specification
Observer pattern
Resources mentioned
Jornada Java (book)
Reactive Streams JVM GitHub repository
Cite this talk
Kamila Oliveira. "First steps with reactive programming in Java." WomenTech Network, 2021. https://www.womentech.net/video/first-steps-reactive-programming-in-java