FS
Uploaded byFlorian Stefan
PDF, PPTX206 views

Reactive Streams in the Web

The document discusses the integration of reactive streams within distributed systems, emphasizing concepts over implementation details. It covers topics like concurrent remote calls, event-driven systems, and various reactive extensions including Reactor, RxJava, and Akka Streams. Additionally, it explores strategies for efficient HTML rendering, backpressure management, and the reactive manifesto principles in modern web applications.

Embed presentation

Download as PDF, PPTX
1 / 293
2 / 293
3 / 293
4 / 293
5 / 293
6 / 293
7 / 293
8 / 293
9 / 293
10 / 293
11 / 293
12 / 293
13 / 293
14 / 293
15 / 293
16 / 293
17 / 293
18 / 293
19 / 293
20 / 293
21 / 293
22 / 293
23 / 293
24 / 293
25 / 293
26 / 293
27 / 293
28 / 293
29 / 293
30 / 293
31 / 293
32 / 293
33 / 293
34 / 293
35 / 293
36 / 293
37 / 293
38 / 293
39 / 293
40 / 293
41 / 293
42 / 293
43 / 293
44 / 293
45 / 293
46 / 293
47 / 293
48 / 293
49 / 293
50 / 293
51 / 293
52 / 293
53 / 293
54 / 293
55 / 293
56 / 293
57 / 293
58 / 293
59 / 293
60 / 293
61 / 293
62 / 293
63 / 293
64 / 293
65 / 293
66 / 293
67 / 293
68 / 293
69 / 293
70 / 293
71 / 293
72 / 293
73 / 293
74 / 293
75 / 293
76 / 293
77 / 293
78 / 293
79 / 293
80 / 293
81 / 293
82 / 293
83 / 293
84 / 293
85 / 293
86 / 293
87 / 293
88 / 293
89 / 293
90 / 293
91 / 293
92 / 293
93 / 293
94 / 293
95 / 293
96 / 293
97 / 293
98 / 293
99 / 293
100 / 293
101 / 293
102 / 293
103 / 293
104 / 293
105 / 293
106 / 293
107 / 293
108 / 293
109 / 293
110 / 293
111 / 293
112 / 293
113 / 293
114 / 293
115 / 293
116 / 293
117 / 293
118 / 293
119 / 293
120 / 293
121 / 293
122 / 293
123 / 293
124 / 293
125 / 293
126 / 293
127 / 293
128 / 293
129 / 293
130 / 293
131 / 293
132 / 293
133 / 293
134 / 293
135 / 293
136 / 293
137 / 293
138 / 293
139 / 293
140 / 293
141 / 293
142 / 293
143 / 293
144 / 293
145 / 293
146 / 293
147 / 293
148 / 293
149 / 293
150 / 293
151 / 293
152 / 293
153 / 293
154 / 293
155 / 293
156 / 293
157 / 293
158 / 293
159 / 293
160 / 293
161 / 293
162 / 293
163 / 293
164 / 293
165 / 293
166 / 293
167 / 293
168 / 293
169 / 293
170 / 293
171 / 293
172 / 293
173 / 293
174 / 293
175 / 293
176 / 293
177 / 293
178 / 293
179 / 293
180 / 293
181 / 293
182 / 293
183 / 293
184 / 293
185 / 293
186 / 293
187 / 293
188 / 293
189 / 293
190 / 293
191 / 293
192 / 293
193 / 293
194 / 293
195 / 293
196 / 293
197 / 293
198 / 293
199 / 293
200 / 293
201 / 293
202 / 293
203 / 293
204 / 293
205 / 293
206 / 293
207 / 293
208 / 293
209 / 293
210 / 293
211 / 293
212 / 293
213 / 293
214 / 293
215 / 293
216 / 293
217 / 293
218 / 293
219 / 293
220 / 293
221 / 293
222 / 293
223 / 293
224 / 293
225 / 293
226 / 293
227 / 293
228 / 293
229 / 293
230 / 293
231 / 293
232 / 293
233 / 293
234 / 293
235 / 293
236 / 293
237 / 293
238 / 293
239 / 293
240 / 293
241 / 293
242 / 293
243 / 293
244 / 293
245 / 293
246 / 293
247 / 293
248 / 293
249 / 293
250 / 293
251 / 293
252 / 293
253 / 293
254 / 293
255 / 293
256 / 293
257 / 293
258 / 293
259 / 293
260 / 293
261 / 293
262 / 293
263 / 293
264 / 293
265 / 293
266 / 293
267 / 293
268 / 293
269 / 293
270 / 293
271 / 293
272 / 293
273 / 293
274 / 293
275 / 293
276 / 293
277 / 293
278 / 293
279 / 293
280 / 293
281 / 293
282 / 293
283 / 293
284 / 293
285 / 293
286 / 293
287 / 293
288 / 293
289 / 293
290 / 293
291 / 293
292 / 293
293 / 293
Reactive Streams in the Web Florian Stefan | eBay Classifieds Group | JUG Saxony 2017
Who am I? § Florian Stefan § mobile.de (eBay Classifieds Group) § https://ebaytech.berlin/ § fstefan@ebay.com | @f_s_t_e_f_a_n § https://github.com/florian-stefan/
Contents 1) Motivation: Distributed Systems 2) Reactive Streams with Reactor 3) Progressive HTML Rendering with Spring 5 It‘s about concepts rather than details!
Why are we here?
Why are we here? It’s a distributed world!
Why are we here? Service A Service B
Why are we here? Service A Service B
Service B Service B Service A Service A Why are we here? Service A Service B
Service B Service B Service A Service A Why are we here? Service A Service B
BFF BFF Service B Service B Service A Service A Why are we here? Service A Service B BFF
BFF BFF Service B Service B Service A Service A Why are we here? Service A Service B BFF
How are we doing this?
How are we doing this? Service A
How are we doing this? Service A Database
HTTP How are we doing this? Service A Database
HTTP How are we doing this? Service A Database Topic
HTTP How are we doing this? Service A Database Topic
HTTP How are we doing this? Service A Database Topic Service B Topic
HTTP How are we doing this? Service A Database Topic Service B Topic BFF
HTTP How are we doing this? Service A Database Topic Service B Topic BFF Event-Driven Systems
HTTP How are we doing this? Service A Database Topic Service B Topic BFF Event-Driven Systems Concurrent Remote Calls
HTML Rendering BFF Widget Widget Widget Widget Widget Concurrent Remote Calls
HTML Rendering BFF Widget Widget Widget Widget Widget Concurrent Remote Calls
HTML Rendering BFF Widget Widget Widget Widget Widget Concurrent Remote Calls
HTML Rendering Server-Side Rendering BFF Widget Widget Widget Widget Widget Concurrent Remote Calls
HTML Rendering Server-Side Rendering AJAX BFF Widget Widget Widget Widget Widget Concurrent Remote Calls
HTML Rendering
HTML Rendering
HTML Rendering
HTML Rendering
Server-Side Rendering § Time To First Byte § Prerendering / Caching HTML Rendering
Server-Side Rendering § Time To First Byte § Prerendering / Caching HTML Rendering
HTML Rendering
HTML Rendering
HTML Rendering
HTML Rendering
AJAX § Head-of-line blocking § Multiplexing with HTTP/2 HTML Rendering
AJAX § Head-of-line blocking § Multiplexing with HTTP/2 HTML Rendering
Can we do better?
Can we do better? How expensive will it be?
The Reactive Landscape
Distributed Systems
Concurrent Remote Calls Event-Driven Systems Distributed Systems
Concurrent Remote Calls Event-Driven Systems Distributed Systems Reactive Streams
Concurrent Remote Calls Event-Driven Systems Distributed Systems Reactive Streams Backpressure
Concurrent Remote Calls Event-Driven Systems Distributed Systems Reactive Streams Reactive Extensions Akka Streams Backpressure
Concurrent Remote Calls Event-Driven Systems Distributed Systems Reactive Streams Reactive Extensions RxJava Reactor Akka Streams Backpressure
Concurrent Remote Calls Event-Driven Systems Distributed Systems Reactive Streams Reactive Extensions Marble Diagrams RxJava Reactor Akka Streams Backpressure
Concurrent Remote Calls Event-Driven Systems Distributed Systems Reactive Streams Reactive Extensions Marble Diagrams RxJava Reactor Akka Streams Backpressure Higher-Order Functions
Concurrent Remote Calls Event-Driven Systems Distributed Systems Reactive Streams Reactive Extensions Marble Diagrams RxJava Reactor Akka Streams Backpressure Declarative Programming Higher-Order Functions
Concurrent Remote Calls Event-Driven Systems Distributed Systems Reactive Systems Reactive Streams Reactive Extensions Marble Diagrams RxJava Reactor Akka Streams Backpressure Declarative Programming Higher-Order Functions
Concurrent Remote Calls Event-Driven Systems Distributed Systems Reactive Systems Reactive Manifesto Reactive Streams Reactive Extensions Marble Diagrams RxJava Reactor Akka Streams Backpressure Declarative Programming Higher-Order Functions
Concurrent Remote Calls Event-Driven Systems Distributed Systems Reactive Systems Reactive Manifesto Reactive Streams Reactive Extensions Marble Diagrams RxJava Reactor Akka Streams Backpressure Declarative Programming Higher-Order Functions
The Reactive Manifesto
Responsive
Responsive Elastic
Responsive Elastic Resilient
Responsive Elastic Resilient Message Driven
Responsive Elastic Resilient Message Driven React to User
Responsive Elastic Resilient Message Driven React to User React to Load
Responsive Elastic Resilient Message Driven React to User React to Load React to Failure
Responsive Elastic Resilient Message Driven React to User React to Load React to Failure React to Events
Paths to Reactive Systems
Concurrent Remote Calls Event-Driven Systems Distributed Systems Reactive Systems Reactive Manifesto Reactive Streams Reactive Extensions Marble Diagrams RxJava Reactor Akka Streams Backpressure Declarative Programming Higher-Order Functions
Reactive Extensions
Reactive Extensions Service
Reactive Extensions Service some thing
Reactive Extensions API Service some thing
public interface Somethings { Something loadById(int id); } Reactive Extensions API Service some thing
Reactive Extensions API Service some thing public Something loadById(int id) { return somethings.loadById(id); }
Reactive Extensions API Service some thing Service
Reactive Extensions API Service some thing Service API
Reactive Extensions API Service some thing Service API Resource
Reactive Extensions API Service some thing Service API Resource Network Boundary
Reactive Extensions API Service some thing Service API Resource Network Boundary
Reactive Extensions API Service some thing Service API Resource Network Boundary
Reactive Extensions API Service some thing Service API Resource Network Boundary
Reactive Extensions API Service some thing Service API Resource Network Boundary
Reactive Extensions API Service some thing
Reactive Extensions API Service some thing public CompletableFuture<Something> loadById(int id) { return supplyAsync(() -> somethings.loadById(id), executor); }
Reactive Extensions API Service some thing Network Boundary ResourceService API
Reactive Extensions API Service some thing Network Boundary ResourceService API
Reactive Extensions API Service some thing Network Boundary ResourceService API
Reactive Extensions API Service some thing Network Boundary ResourceService API
Reactive Extensions API Service some thing
public interface Somethings { void loadById(int id, BiConsumer<Exception, Something> callback); } Reactive Extensions API Service some thing
public CompletableFuture<Something> loadById(int id) { CompletableFuture<Something> eventualSomething = new CompletableFuture<>(); somethings.loadById(id, (error, something) -> { if (error != null) { eventualSomething.completeExceptionally(error); } else { eventualSomething.complete(something); } }); return eventualSomething; } Reactive Extensions API Service some thing
Network Boundary ResourceService API Reactive Extensions API Service some thing
Network Boundary ResourceService API Reactive Extensions API Service some thing
Network Boundary ResourceService API Reactive Extensions API Service some thing
Network Boundary ResourceService API Reactive Extensions API Service some thing
Reactive Extensions
Reactive Extensions CompletableFuture<T> represents an already scheduled task completes only once
Reactive Extensions CompletableFuture<T> represents an already scheduled task completes only once
Reactive Extensions CompletableFuture<T> represents an already scheduled task completes only once Mono<T> represents a building plan (caller has to subscribe) emits at most one value
Reactive Extensions CompletableFuture<T> represents an already scheduled task completes only once Flux<T> represents a building plan (caller has to subscribe) emits many values Mono<T> represents a building plan (caller has to subscribe) emits at most one value
Reactive Extensions CompletableFuture<T> represents an already scheduled task completes only once Flux<T> represents a building plan (caller has to subscribe) emits many values Mono<T> represents a building plan (caller has to subscribe) emits at most one value
Reactive Extensions CompletableFuture<T> represents an already scheduled task completes only once Flux<T> represents a building plan (caller has to subscribe) emits many values Mono<T> represents a building plan (caller has to subscribe) emits at most one value subscribe { , }✘
Reactive Extensions CompletableFuture<T> represents an already scheduled task completes only once Flux<T> represents a building plan (caller has to subscribe) emits many values Mono<T> represents a building plan (caller has to subscribe) emits at most one value subscribe { , }✘
Reactive Extensions CompletableFuture<T> represents an already scheduled task completes only once Flux<T> represents a building plan (caller has to subscribe) emits many values Mono<T> represents a building plan (caller has to subscribe) emits at most one value subscribe { , }✘
Reactive Extensions CompletableFuture<T> represents an already scheduled task completes only once Flux<T> represents a building plan (caller has to subscribe) emits many values Mono<T> represents a building plan (caller has to subscribe) emits at most one value subscribe { , }✘
Reactive Extensions CompletableFuture<T> represents an already scheduled task completes only once Flux<T> represents a building plan (caller has to subscribe) emits many values Mono<T> represents a building plan (caller has to subscribe) emits at most one value subscribe { , }✘
Reactive Extensions CompletableFuture<T> represents an already scheduled task completes only once Flux<T> represents a building plan (caller has to subscribe) emits many values Mono<T> represents a building plan (caller has to subscribe) emits at most one value subscribe { , }✘
Reactive Extensions CompletableFuture<T> represents an already scheduled task completes only once Flux<T> represents a building plan (caller has to subscribe) emits many values Mono<T> represents a building plan (caller has to subscribe) emits at most one value subscribe { , }✘
Reactive Extensions CompletableFuture<T> represents an already scheduled task completes only once Flux<T> represents a building plan (caller has to subscribe) emits many values Mono<T> represents a building plan (caller has to subscribe) emits at most one value subscribe { , }✘
Reactive Extensions
Publisher Reactive Extensions fromArray { } [ , , ]
Operator Publisher Reactive Extensions map { } fromArray { } [ , , ]
Operator Subscriber Publisher Reactive Extensions map { } subscribe { } fromArray { } [ , , ]
Operator Subscriber Publisher Reactive Extensions map { } subscribe { } fromArray { } [ , , ] wraps
Operator Subscriber Publisher Reactive Extensions map { } subscribe { } fromArray { } [ , , ] wraps
Operator Subscriber Publisher Reactive Extensions map { } subscribe { } fromArray { } [ , , ] wraps subscribes to
Reactive Extensions
Reactive Extensions Circle[] circles = { Circle.of(BLUE), ... };
Reactive Extensions Circle[] circles = { Circle.of(BLUE), ... }; Flux.fromArray(circles)
Reactive Extensions Circle[] circles = { Circle.of(BLUE), ... }; Flux.fromArray(circles) .map(circle -> Square.of(circle.getColor()))
Reactive Extensions Circle[] circles = { Circle.of(BLUE), ... }; Flux.fromArray(circles) .map(circle -> Square.of(circle.getColor())) .log()
Reactive Extensions Circle[] circles = { Circle.of(BLUE), ... }; Flux.fromArray(circles) .map(circle -> Square.of(circle.getColor())) .subscribe(...); .log()
Reactive Extensions Circle[] circles = { Circle.of(BLUE), ... }; Flux.fromArray(circles) .map(circle -> Square.of(circle.getColor())) .subscribe(...); .log() [main] INFO - | onSubscribe()
Reactive Extensions Circle[] circles = { Circle.of(BLUE), ... }; Flux.fromArray(circles) .map(circle -> Square.of(circle.getColor())) .subscribe(...); .log() [main] INFO - | onSubscribe() [main] INFO - | ?
Reactive Extensions Circle[] circles = { Circle.of(BLUE), ... }; Flux.fromArray(circles) .map(circle -> Square.of(circle.getColor())) .subscribe(...); .log() [main] INFO - | onSubscribe() [main] INFO - | ? [main] INFO - | onNext(Square(BLUE))
Reactive Extensions Circle[] circles = { Circle.of(BLUE), ... }; Flux.fromArray(circles) .map(circle -> Square.of(circle.getColor())) .subscribe(...); .log() [main] INFO - | onSubscribe() [main] INFO - | ? [main] INFO - | onNext(Square(BLUE)) [main] INFO - | onNext(Square(YELLOW))
Reactive Extensions Circle[] circles = { Circle.of(BLUE), ... }; Flux.fromArray(circles) .map(circle -> Square.of(circle.getColor())) .subscribe(...); .log() [main] INFO - | onSubscribe() [main] INFO - | ? [main] INFO - | onNext(Square(BLUE)) [main] INFO - | onNext(Square(YELLOW)) [main] INFO - | onNext(Square(GREEN))
Reactive Extensions Circle[] circles = { Circle.of(BLUE), ... }; Flux.fromArray(circles) .map(circle -> Square.of(circle.getColor())) .subscribe(...); .log() [main] INFO - | onSubscribe() [main] INFO - | ? [main] INFO - | onNext(Square(BLUE)) [main] INFO - | onNext(Square(YELLOW)) [main] INFO - | onNext(Square(GREEN)) [main] INFO - | onComplete()
Concurrency
Concurrent Remote Calls Event-Driven Systems Distributed Systems Reactive Systems Reactive Manifesto Reactive Streams Reactive Extensions Marble Diagrams RxJava Reactor Akka Streams Backpressure Declarative Programming Higher-Order Functions
Concurrency Calling Thread map { }
Concurrency subscribe { } Calling Thread map { }
Concurrency subscribe { } Calling Thread map { }
Concurrency subscribe { } Calling Thread map { }
Concurrency subscribe { } Calling Thread map { }
Concurrency subscribe { } Calling Thread map { }
Concurrency subscribe { } Calling Thread map { }
Concurrency subscribe { } Calling Thread map { }
Concurrency Calling Thread map { }
Concurrency Calling Thread Scheduler subscribeOn { } map { }
Concurrency subscribe { } Calling Thread Scheduler subscribeOn { } map { }
Concurrency subscribe { } Calling Thread Scheduler subscribeOn { } map { }
Concurrency subscribe { } Calling Thread Scheduler subscribeOn { } map { }
Concurrency subscribe { } Calling Thread Scheduler subscribeOn { } map { }
Concurrency subscribe { } Calling Thread Scheduler subscribeOn { } map { }
Concurrency subscribe { } Calling Thread Scheduler subscribeOn { } map { }
Concurrency subscribe { } Calling Thread Scheduler subscribeOn { } map { }
Concurrency Calling Thread flatMap { }
Concurrency Calling Thread Scheduler flatMap { } subscribeOn { }
Concurrency subscribe { } Calling Thread Scheduler flatMap { } subscribeOn { }
Concurrency subscribe { } Calling Thread Scheduler flatMap { } subscribeOn { }
Concurrency subscribe { } Calling Thread Scheduler flatMap { } subscribeOn { }
Concurrency subscribe { } Calling Thread Scheduler flatMap { } subscribeOn { }
Concurrency subscribe { } Calling Thread Scheduler flatMap { } subscribeOn { }
Concurrency subscribe { } Calling Thread Scheduler flatMap { } subscribeOn { }
Concurrency subscribe { } Calling Thread Scheduler flatMap { } subscribeOn { }
Concurrency
Concurrency API Service some thing
Concurrency API Service some thing Scheduler scheduler = Schedulers.newParallel("pool", 8);
Concurrency Flux.fromIterable(ids) API Service some thing Scheduler scheduler = Schedulers.newParallel("pool", 8);
Concurrency Flux.fromIterable(ids) API Service some thing Scheduler scheduler = Schedulers.newParallel("pool", 8); .flatMap(id -> Mono.just(id) .map(somethings::loadById) .subscribeOn(scheduler))
Concurrency Flux.fromIterable(ids) API Service some thing Scheduler scheduler = Schedulers.newParallel("pool", 8); .flatMap(id -> Mono.just(id) .map(somethings::loadById) .subscribeOn(scheduler)) .log()
Concurrency Flux.fromIterable(ids) API Service some thing Scheduler scheduler = Schedulers.newParallel("pool", 8); .flatMap(id -> Mono.just(id) .map(somethings::loadById) .subscribeOn(scheduler)) .log() .subscribe();
Concurrency Flux.fromIterable(ids) API Service some thing Scheduler scheduler = Schedulers.newParallel("pool", 8); [main] INFO - onSubscribe() .flatMap(id -> Mono.just(id) .map(somethings::loadById) .subscribeOn(scheduler)) .log() .subscribe();
Concurrency Flux.fromIterable(ids) API Service some thing Scheduler scheduler = Schedulers.newParallel("pool", 8); [main] INFO - onSubscribe() .flatMap(id -> Mono.just(id) .map(somethings::loadById) .subscribeOn(scheduler)) .log() .subscribe(); [main] INFO - ?
Concurrency Flux.fromIterable(ids) API Service some thing Scheduler scheduler = Schedulers.newParallel("pool", 8); [main] INFO - onSubscribe() .flatMap(id -> Mono.just(id) .map(somethings::loadById) .subscribeOn(scheduler)) .log() .subscribe(); [main] INFO - ? [pool-1] INFO - onNext(Something(id=1))
Concurrency Flux.fromIterable(ids) API Service some thing Scheduler scheduler = Schedulers.newParallel("pool", 8); [main] INFO - onSubscribe() .flatMap(id -> Mono.just(id) .map(somethings::loadById) .subscribeOn(scheduler)) .log() .subscribe(); [main] INFO - ? [pool-1] INFO - onNext(Something(id=1)) [pool-2] INFO - onNext(Something(id=2))
Concurrency Flux.fromIterable(ids) API Service some thing Scheduler scheduler = Schedulers.newParallel("pool", 8); [main] INFO - onSubscribe() .flatMap(id -> Mono.just(id) .map(somethings::loadById) .subscribeOn(scheduler)) .log() .subscribe(); [main] INFO - ? [pool-1] INFO - onNext(Something(id=1)) [pool-2] INFO - onNext(Something(id=2)) [pool-3] INFO - onNext(Something(id=3))
Concurrency Flux.fromIterable(ids) API Service some thing Scheduler scheduler = Schedulers.newParallel("pool", 8); [main] INFO - onSubscribe() .flatMap(id -> Mono.just(id) .map(somethings::loadById) .subscribeOn(scheduler)) .log() .subscribe(); [main] INFO - ? [pool-1] INFO - onNext(Something(id=1)) [pool-2] INFO - onNext(Something(id=2)) [pool-3] INFO - onNext(Something(id=3)) [pool-3] INFO - onComplete()
Concurrent Remote Calls Event-Driven Systems Distributed Systems Reactive Systems Reactive Manifesto Reactive Streams Reactive Extensions Marble Diagrams RxJava Reactor Akka Streams Backpressure Declarative Programming Higher-Order Functions
Backpressure
Backpressure Publisher
Backpressure Publisher Subscriber
Backpressure Publisher Subscriber subscribe
Backpressure Publisher Subscriber
Backpressure Publisher Subscriber 1onNext( )
Backpressure Publisher Subscriber onNext( )2
Backpressure Publisher Subscriber onNext( )3
Backpressure Publisher Subscriber onNext( )4
Backpressure Publisher Subscriber onNext( )5
5 Backpressure Publisher Subscriber onNext( )
5 Backpressure Publisher Subscriber onNext( ) ExecutorService executorService = new ThreadPoolExecutor( nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(capacity) );
5 Backpressure Publisher Subscriber onNext( ) ExecutorService executorService = new ThreadPoolExecutor( nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(capacity) ); ids.stream() .map(id -> executorService .submit(() -> somethings.loadById(id))) .collect(toList()) .stream() .map(waitForSomething()) .forEach(handleSomething());
5 Backpressure Publisher Subscriber onNext( ) ExecutorService executorService = new ThreadPoolExecutor( nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(capacity) ); ids.stream() .map(id -> executorService .submit(() -> somethings.loadById(id))) .collect(toList()) .stream() .map(waitForSomething()) .forEach(handleSomething()); java.util.concurrent.RejectedExecutionException: Task rejected from ThreadPoolExecutor [ Running, pool size = 2, active threads = 2, queued tasks = 4, completed tasks = 0 ]
Backpressure
Backpressure Publisher
Backpressure Publisher Subscriber
Backpressure Publisher Subscriber subscribe
Backpressure Publisher Subscriber
Backpressure Publisher Subscriber request(3)
Backpressure Publisher Subscriber
Backpressure Publisher Subscriber 1onNext( )
Backpressure Publisher Subscriber onNext( )2
Backpressure Publisher Subscriber onNext( )3
Backpressure Publisher Subscriber
Backpressure Publisher Subscriber request(2)
Backpressure Publisher Subscriber
Backpressure Publisher Subscriber onNext( )4
Backpressure Publisher Subscriber onNext( )5
5 Backpressure Publisher Subscriber onNext( )
5 Backpressure Publisher Subscriber onNext( ) ExecutorService executorService = new ThreadPoolExecutor( nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(capacity) );
5 Backpressure Publisher Subscriber onNext( ) ExecutorService executorService = new ThreadPoolExecutor( nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(capacity) ); Scheduler scheduler = Schedulers .fromExecutorService(executorService);
5 Backpressure Publisher Subscriber onNext( ) ExecutorService executorService = new ThreadPoolExecutor( nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(capacity) ); Flux.fromIterable(ids) .log() .flatMap(id -> Mono.just(id) .map(somethings::loadById) .subscribeOn(scheduler), 3) .doOnNext(handleSomething()) .subscribe(); Scheduler scheduler = Schedulers .fromExecutorService(executorService);
5 Backpressure Publisher Subscriber onNext( ) ExecutorService executorService = new ThreadPoolExecutor( nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(capacity) ); Flux.fromIterable(ids) .log() .flatMap(id -> Mono.just(id) .map(somethings::loadById) .subscribeOn(scheduler), 3) .doOnNext(handleSomething()) .subscribe(); Scheduler scheduler = Schedulers .fromExecutorService(executorService); [main] INFO - | onSubscribe() [main] INFO - | ?
5 Backpressure Publisher Subscriber onNext( ) ExecutorService executorService = new ThreadPoolExecutor( nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(capacity) ); Flux.fromIterable(ids) .log() .flatMap(id -> Mono.just(id) .map(somethings::loadById) .subscribeOn(scheduler), 3) .doOnNext(handleSomething()) .subscribe(); Scheduler scheduler = Schedulers .fromExecutorService(executorService); [main] INFO - | onSubscribe() [main] INFO - | ?
5 Backpressure Publisher Subscriber onNext( ) ExecutorService executorService = new ThreadPoolExecutor( nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(capacity) ); Flux.fromIterable(ids) .log() .flatMap(id -> Mono.just(id) .map(somethings::loadById) .subscribeOn(scheduler), 3) .doOnNext(handleSomething()) .subscribe(); Scheduler scheduler = Schedulers .fromExecutorService(executorService); [main] INFO - | onSubscribe() [main] INFO - | request(3)
5 Backpressure Publisher Subscriber onNext( ) ExecutorService executorService = new ThreadPoolExecutor( nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(capacity) ); Flux.fromIterable(ids) .log() .flatMap(id -> Mono.just(id) .map(somethings::loadById) .subscribeOn(scheduler), 3) .doOnNext(handleSomething()) .subscribe(); Scheduler scheduler = Schedulers .fromExecutorService(executorService); [main] INFO - | onSubscribe() [main] INFO - | request(3)
5 Backpressure Publisher Subscriber onNext( ) ExecutorService executorService = new ThreadPoolExecutor( nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(capacity) ); Flux.fromIterable(ids) .log() .flatMap(id -> Mono.just(id) .map(somethings::loadById) .subscribeOn(scheduler), 3) .doOnNext(handleSomething()) .subscribe(); Scheduler scheduler = Schedulers .fromExecutorService(executorService); [main] INFO - | onSubscribe() [main] INFO - | request(3) [main] INFO - | onNext(1) [main] INFO - | onNext(2) [main] INFO - | onNext(3)
5 Backpressure Publisher Subscriber onNext( ) ExecutorService executorService = new ThreadPoolExecutor( nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(capacity) ); Flux.fromIterable(ids) .log() .flatMap(id -> Mono.just(id) .map(somethings::loadById) .subscribeOn(scheduler), 3) .doOnNext(handleSomething()) .subscribe(); Scheduler scheduler = Schedulers .fromExecutorService(executorService); [main] INFO - | onSubscribe() [main] INFO - | request(3) [main] INFO - | onNext(1) [main] INFO - | onNext(2) [main] INFO - | onNext(3) [pool-1] INFO - | request(1)
5 Backpressure Publisher Subscriber onNext( ) ExecutorService executorService = new ThreadPoolExecutor( nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(capacity) ); Flux.fromIterable(ids) .log() .flatMap(id -> Mono.just(id) .map(somethings::loadById) .subscribeOn(scheduler), 3) .doOnNext(handleSomething()) .subscribe(); Scheduler scheduler = Schedulers .fromExecutorService(executorService); [main] INFO - | onSubscribe() [main] INFO - | request(3) [main] INFO - | onNext(1) [main] INFO - | onNext(2) [main] INFO - | onNext(3) [pool-1] INFO - | request(1) [pool-1] INFO - | onNext(4)
5 Backpressure Publisher Subscriber onNext( ) ExecutorService executorService = new ThreadPoolExecutor( nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(capacity) ); Flux.fromIterable(ids) .log() .flatMap(id -> Mono.just(id) .map(somethings::loadById) .subscribeOn(scheduler), 3) .doOnNext(handleSomething()) .subscribe(); Scheduler scheduler = Schedulers .fromExecutorService(executorService); [main] INFO - | onSubscribe() [main] INFO - | request(3) [main] INFO - | onNext(1) [main] INFO - | onNext(2) [main] INFO - | onNext(3) [pool-1] INFO - | request(1) [pool-1] INFO - | onNext(4) [pool-2] INFO - | request(1)
5 Backpressure Publisher Subscriber onNext( ) ExecutorService executorService = new ThreadPoolExecutor( nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(capacity) ); Flux.fromIterable(ids) .log() .flatMap(id -> Mono.just(id) .map(somethings::loadById) .subscribeOn(scheduler), 3) .doOnNext(handleSomething()) .subscribe(); Scheduler scheduler = Schedulers .fromExecutorService(executorService); [main] INFO - | onSubscribe() [main] INFO - | request(3) [main] INFO - | onNext(1) [main] INFO - | onNext(2) [main] INFO - | onNext(3) [pool-1] INFO - | request(1) [pool-1] INFO - | onNext(4) [pool-2] INFO - | request(1) [pool-2] INFO - | onNext(5)
5 Backpressure Publisher Subscriber onNext( ) ExecutorService executorService = new ThreadPoolExecutor( nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(capacity) ); Flux.fromIterable(ids) .log() .flatMap(id -> Mono.just(id) .map(somethings::loadById) .subscribeOn(scheduler), 3) .doOnNext(handleSomething()) .subscribe(); Scheduler scheduler = Schedulers .fromExecutorService(executorService); [main] INFO - | onSubscribe() [main] INFO - | request(3) [main] INFO - | onNext(1) [main] INFO - | onNext(2) [main] INFO - | onNext(3) [pool-1] INFO - | request(1) [pool-1] INFO - | onNext(4) [pool-2] INFO - | request(1) [pool-2] INFO - | onNext(5) [pool-2] INFO - | onComplete()
Backpressure HTTP Service A Database Topic Service B Topic BFF
Backpressure HTTP Service A Database Topic Service B Topic BFF
HTTP Service A Database Topic Service B Topic BFF
Progressive HTML Rendering
Progressive HTML RenderingProgressive
Progressive HTML Rendering BFF Widget Widget Widget Widget Widget Concurrent Remote Calls
Progressive HTML Rendering Transfer-Encoding: chunked BFF Widget Widget Widget Widget Widget Concurrent Remote Calls
Progressive HTML Rendering
Progressive HTML Rendering <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency>
Progressive HTML Rendering <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-webflux</artifactId> </dependency>
Progressive HTML Rendering @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } }
Progressive HTML Rendering @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } @RestController @GetMapping(value = "hello") public Flux<String> sayHello() { return Flux.interval(Duration.ofMillis(500)).map(tick -> "Hellon"); }
Progressive HTML Rendering @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } curl -i -N localhost:8080/hello @RestController @GetMapping(value = "hello") public Flux<String> sayHello() { return Flux.interval(Duration.ofMillis(500)).map(tick -> "Hellon"); }
Progressive HTML Rendering @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } curl -i -N localhost:8080/hello @RestController @GetMapping(value = "hello") public Flux<String> sayHello() { return Flux.interval(Duration.ofMillis(500)).map(tick -> "Hellon"); } HTTP/1.1 200 Content-Type: text/plain Transfer-Encoding: chunked
Progressive HTML Rendering @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } curl -i -N localhost:8080/hello @RestController @GetMapping(value = "hello") public Flux<String> sayHello() { return Flux.interval(Duration.ofMillis(500)).map(tick -> "Hellon"); } HTTP/1.1 200 Content-Type: text/plain Transfer-Encoding: chunked Hello
Progressive HTML Rendering @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } curl -i -N localhost:8080/hello @RestController @GetMapping(value = "hello") public Flux<String> sayHello() { return Flux.interval(Duration.ofMillis(500)).map(tick -> "Hellon"); } HTTP/1.1 200 Content-Type: text/plain Transfer-Encoding: chunked Hello Hello
Progressive HTML Rendering @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } curl -i -N localhost:8080/hello @RestController @GetMapping(value = "hello") public Flux<String> sayHello() { return Flux.interval(Duration.ofMillis(500)).map(tick -> "Hellon"); } HTTP/1.1 200 Content-Type: text/plain Transfer-Encoding: chunked Hello Hello Hello
Progressive HTML Rendering @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } curl -i -N localhost:8080/hello @RestController @GetMapping(value = "hello") public Flux<String> sayHello() { return Flux.interval(Duration.ofMillis(500)).map(tick -> "Hellon"); } HTTP/1.1 200 Content-Type: text/plain Transfer-Encoding: chunked Hello Hello Hello Hello
Baking an HTML stream
Spring 5 WebClient
Spring 5 WebClient WidgetService
Spring 5 WebClient WidgetService WebClient
Spring 5 WebClient WidgetServerWidgetService WebClient
Spring 5 WebClient Network Boundary WidgetServerWidgetService WebClient
Spring 5 WebClient Network Boundary WidgetServerWidgetService WebClient
Spring 5 WebClient Network Boundary WidgetServerWidgetService WebClient WebClient.create()
Spring 5 WebClient Network Boundary WidgetServerWidgetService WebClient WebClient.create() .get()
Spring 5 WebClient Network Boundary WidgetServerWidgetService WebClient WebClient.create() .get() .uri("http://widget-server")
Spring 5 WebClient Network Boundary WidgetServerWidgetService WebClient WebClient.create() .get() .uri("http://widget-server") .retrieve()
Spring 5 WebClient Network Boundary WidgetServerWidgetService WebClient WebClient.create() .get() .uri("http://widget-server") .retrieve() .bodyToFlux(String.class)
Spring 5 WebClient Network Boundary WidgetServerWidgetService WebClient WebClient.create() .get() .uri("http://widget-server") .retrieve() .bodyToFlux(String.class) .subscribe(this::onNext);
Spring 5 WebClient Network Boundary WidgetServerWidgetService WebClient WebClient.create() .get() .uri("http://widget-server") .retrieve() .bodyToFlux(String.class) .subscribe(this::onNext);
Spring 5 WebClient Network Boundary WidgetServerWidgetService WebClient WebClient.create() .get() .uri("http://widget-server") .retrieve() .bodyToFlux(String.class) .subscribe(this::onNext);
Spring 5 WebClient Network Boundary WidgetServerWidgetService WebClient WebClient.create() .get() .uri("http://widget-server") .retrieve() .bodyToFlux(String.class) .subscribe(this::onNext);
Spring 5 WebClient Network Boundary WidgetServerWidgetService WebClient WebClient.create() .get() .uri("http://widget-server") .retrieve() .bodyToFlux(String.class) .subscribe(this::onNext);
HTML Rendering
HTML Rendering HTTP Request
HTML Rendering HTTP Request Accepter Thread
HTML Rendering HTTP Request Accepter Thread Connection Queue
HTML Rendering HTTP Request Accepter Thread Connection Queue Request Thread
HTML Rendering HTTP Request Accepter Thread Connection Queue Request Thread Model
HTML Rendering HTTP Request Accepter Thread Connection Queue Request Thread Model TemplateHttpResponse.getWriter() Output Buffer
HTML Rendering HTTP Request Accepter Thread HTTP Response Connection Queue Request Thread Model TemplateHttpResponse.getWriter() Output Buffer
Model Reactive-Friendly Template Engine Template
Model Reactive-Friendly Template Engine Flux<T> Template th:each="..."
Model Reactive-Friendly Template Engine Flux<T> Template th:each="..."
Model Reactive-Friendly Template Engine Flux<T> Template th:each="..." Reactive Web Server
Model Reactive-Friendly Template Engine Flux<T> Template th:each="..." Reactive Web Server subscribes
Model Reactive-Friendly Template Engine Flux<T> Template th:each="..." requests DataBuffer Reactive Web Server subscribes
Processor<T, DataBuffer> Model Reactive-Friendly Template Engine Flux<T> Template th:each="..." requests DataBuffer Reactive Web Server subscribes
Processor<T, DataBuffer> Model Reactive-Friendly Template Engine Flux<T> Template th:each="..." requests DataBuffer Reactive Web Server subscribes HTML rendered as values are published
Progressive HTML Rendering
Progressive HTML Rendering Processor Subscriber Publisher
Progressive HTML Rendering Processor Subscriber Publisher Spring 5 WebClient
Progressive HTML Rendering Processor Subscriber Publisher Spring 5 WebClient Reactive-Friendly Thymeleaf View
Progressive HTML Rendering Processor Subscriber Publisher Spring 5 WebClient Reactive-Friendly Thymeleaf View Reactive Web Server
Progressive HTML Rendering Publisher Spring 5 WebClient
URI uri = ... String name = ... Mono<Pagelet> pageletMono = webClient.get().uri(uri).exchange() .flatMap(res -> res.bodyToMono(String.class)) .map(body -> new Pagelet(name, body)); List<Mono<Pagelet>> pageletMonos = ...; ... = Flux.merge(pageletMonos); Progressive HTML Rendering Publisher Spring 5 WebClient
Progressive HTML Rendering Processor Reactive Thymeleaf View
@GetMapping(value = "/widgets") public String widgets(Model model) { List<String> pageletNames = widgetService.getPageletNames(); Flux<Pagelet> pagelets = widgetService.loadPagelets(); model.addAttribute("pageletNames", pageletNames); model.addAttribute("pagelets", new ReactiveDataDriverContextVariable(pagelets, 1)); return "widgets"; } Progressive HTML Rendering Processor Reactive Thymeleaf View
@GetMapping(value = "/widgets") public String widgets(Model model) { List<String> pageletNames = widgetService.getPageletNames(); Flux<Pagelet> pagelets = widgetService.loadPagelets(); model.addAttribute("pageletNames", pageletNames); model.addAttribute("pagelets", new ReactiveDataDriverContextVariable(pagelets, 1)); return "widgets"; } Progressive HTML Rendering Processor Reactive Thymeleaf View ReactiveDataDriverContextVariable
<article th:each="pagelet: ${pagelets}" class="..."> <section class="..."> <div class="..."> <div th:utext="${pagelet.content}" class="..."></div> </div> </section> </article> Progressive HTML Rendering Processor Reactive Thymeleaf View
<article th:each="pagelet: ${pagelets}" class="..."> <section class="..."> <div class="..."> <div th:utext="${pagelet.content}" class="..."></div> </div> </section> </article> Progressive HTML Rendering Processor Reactive Thymeleaf View List<Mono<Pagelet>> pageletMonos = ...; ... = Flux.merge(pageletMonos);
<article th:each="pagelet: ${pagelets}" class="..."> <section class="..."> <div class="..."> <div th:utext="${pagelet.content}" class="..."></div> </div> </section> </article> Progressive HTML Rendering Processor Reactive Thymeleaf View List<Mono<Pagelet>> pageletMonos = ...; ... = Flux.merge(pageletMonos);Flux.merge(pageletMonos)
<article th:each="pageletName: ${pageletNames}" class="..."> <section class="..."> <div th:id="${pageletName}" class="..."> <div class="...">...</div> </div> </section> </article> Progressive HTML Rendering Processor Reactive Thymeleaf View
<script th-inline="javascript" th:each="pagelet : ${pagelets}"> (function() { var element = document.getElementById("[[${pagelet.name}]]"); if(element) { element.innerHTML = "[(${pagelet.content})]"; } })(); </script> Progressive HTML Rendering Processor Reactive Thymeleaf View
Does it work?
Progressive HTML Rendering
Progressive HTML Rendering
Progressive HTML Rendering
Progressive HTML Rendering
Progressive HTML Rendering
What‘s more? § Cold Streams vs. Hot Streams § Reactive Database Drivers § Backpressure Strategies § Threaded vs. Evented Server Model § WebSockets and Server-Sent Events
Thank you!
Questions?

More Related Content

PPTX
Allegograph
byUniversity of New South Wales
 
PDF
Reactive Applications in Java
byAlexander Mrynskyi
 
PDF
Reactive Programming in Java and Spring Framework 5
byRichard Langlois P. Eng.
 
PDF
Guide to Spring Reactive Programming using WebFlux
byInexture Solutions
 
PDF
Springone2gx 2014 Reactive Streams and Reactor
byStéphane Maldini
 
PPTX
Reactive solutions using java 9 and spring reactor
byOrenEzer1
 
PDF
EAI design patterns/best practices
byAjit Bhingarkar
 
PDF
NCUG 2019: Super charge your API’s with Reactive streams
byFrank van der Linden
 
Allegograph
byUniversity of New South Wales
 
Reactive Applications in Java
byAlexander Mrynskyi
 
Reactive Programming in Java and Spring Framework 5
byRichard Langlois P. Eng.
 
Guide to Spring Reactive Programming using WebFlux
byInexture Solutions
 
Springone2gx 2014 Reactive Streams and Reactor
byStéphane Maldini
 
Reactive solutions using java 9 and spring reactor
byOrenEzer1
 
EAI design patterns/best practices
byAjit Bhingarkar
 
NCUG 2019: Super charge your API’s with Reactive streams
byFrank van der Linden
 

Similar to Reactive Streams in the Web

PDF
Reactive Card Magic: Understanding Spring WebFlux and Project Reactor
byVMware Tanzu
 
PDF
Microservices with Spring 5 Webflux - jProfessionals
byTrayan Iliev
 
PPT
Reactive programming with examples
byPeter Lawrey
 
PDF
Java & JavaScipt Reactive Robotics and IoT 2016 @ jProfessionals
byTrayan Iliev
 
PDF
Intro To Reactive Programming
byRossen Stoyanchev
 
PPTX
Reactive programming with Spring Webflux.pptx
byJoão Esperancinha
 
PDF
Designing for Distributed Systems with Reactor and Reactive Streams
byStéphane Maldini
 
PDF
Reactor, Reactive streams and MicroServices
byStéphane Maldini
 
PDF
Reactive mesh
byKalin Maldzhanski
 
PDF
Spring 5 Webflux - Advances in Java 2018
byTrayan Iliev
 
PDF
NGRX Apps in Depth
byTrayan Iliev
 
PDF
Event Sourcing in less than 20 minutes - With Akka and Java 8
byJ On The Beach
 
PDF
Full Stack Reactive In Practice
byLightbend
 
PDF
Reactive Everywhere
bytrion development GmbH
 
PDF
Intro to Reactive Programming
byStéphane Maldini
 
PPTX
20160609 nike techtalks reactive applications tools of the trade
byshinolajla
 
PDF
Ten practical ways to improve front-end performance
byAndrew Rota
 
PPTX
Reactive for the Impatient - Mary Grygleski
byPolyglotMeetups
 
PDF
Lagom : Reactive microservice framework
byFabrice Sznajderman
 
PDF
ROMA User-Customizable NoSQL Database in Ruby
byRakuten Group, Inc.
 
Reactive Card Magic: Understanding Spring WebFlux and Project Reactor
byVMware Tanzu
 
Microservices with Spring 5 Webflux - jProfessionals
byTrayan Iliev
 
Reactive programming with examples
byPeter Lawrey
 
Java & JavaScipt Reactive Robotics and IoT 2016 @ jProfessionals
byTrayan Iliev
 
Intro To Reactive Programming
byRossen Stoyanchev
 
Reactive programming with Spring Webflux.pptx
byJoão Esperancinha
 
Designing for Distributed Systems with Reactor and Reactive Streams
byStéphane Maldini
 
Reactor, Reactive streams and MicroServices
byStéphane Maldini
 
Reactive mesh
byKalin Maldzhanski
 
Spring 5 Webflux - Advances in Java 2018
byTrayan Iliev
 
NGRX Apps in Depth
byTrayan Iliev
 
Event Sourcing in less than 20 minutes - With Akka and Java 8
byJ On The Beach
 
Full Stack Reactive In Practice
byLightbend
 
Reactive Everywhere
bytrion development GmbH
 
Intro to Reactive Programming
byStéphane Maldini
 
20160609 nike techtalks reactive applications tools of the trade
byshinolajla
 
Ten practical ways to improve front-end performance
byAndrew Rota
 
Reactive for the Impatient - Mary Grygleski
byPolyglotMeetups
 
Lagom : Reactive microservice framework
byFabrice Sznajderman
 
ROMA User-Customizable NoSQL Database in Ruby
byRakuten Group, Inc.
 

Recently uploaded

PPTX
apidays Australia 2025 | Building AI RAG Applications with No Code.pptx
byapidays
 
PPTX
Mastering SQL Server Replication: Types, Setup & Troubleshooting
byGeoPITS Global Pvt Ltd
 
PDF
Azure DevOps Managed Services: Driving Speed, Security, and Business Growth
byjohncarterjn
 
PDF
Kubernetes Cloud Native Indonesia Meetup - January 2026
byPrasta Maha
 
PDF
Skills to Pass the UiPath Agentic Automation Associate (UiAAA) Certification
byUiPathCommunity
 
PPTX
Code Like Bro -A guide for better Coding
byMadan Panthi
 
PDF
What ONIX can do: Leveraging metadata to support the discoverability of First...
byBookNet Canada
 
PPTX
AI Meets DBA Transforming Database Administration with Intelligence
byGeoPITS Global Pvt Ltd
 
PDF
Teaching Robots how to Read 1/2: AI Center & Classic Document Understanding (...
byanabulhac
 
PDF
apidays Australia 2025 | The Strategic Role of APIs in Digital Transformation
byapidays
 
PDF
Computer Science Conferences 2026 | Research by SAI Conference
byHealth Conference 2026
 
PDF
How to Build a Crypto Wallet that Excels in 2026.pdf
byimoliviabennett
 
PPT
Database Management Systems: Basics, History, Data Models, etc.
byParithi Thamizh
 
PPTX
Advance Computer Architecture Lecture 4.pptx
byBottshikanBottshikan
 
PPTX
Understanding-Search-Algorithms_09-12-25.pptx
byshaikmahammedtauheed
 
DOCX
Mathematical reviewer gor mmw in theofern
byyeojlevantinojesalva
 
PPTX
Strategic Shelf Planning for the New Year Turning Resolutions into Revenue .pptx
byAnoop Ashok
 
PPTX
CRM for the Insurance Industry Lessons for Insurance CIOs and Digital Leaders...
byKerry Millar
 
PPTX
Spacecraft Guidance Quick Research Guide by Arthur Morgan
byArthur Morgan
 
PDF
Deploying Windows Clients & Managing Identities
byVICTOR MAESTRE RAMIREZ
 
apidays Australia 2025 | Building AI RAG Applications with No Code.pptx
byapidays
 
Mastering SQL Server Replication: Types, Setup & Troubleshooting
byGeoPITS Global Pvt Ltd
 
Azure DevOps Managed Services: Driving Speed, Security, and Business Growth
byjohncarterjn
 
Kubernetes Cloud Native Indonesia Meetup - January 2026
byPrasta Maha
 
Skills to Pass the UiPath Agentic Automation Associate (UiAAA) Certification
byUiPathCommunity
 
Code Like Bro -A guide for better Coding
byMadan Panthi
 
What ONIX can do: Leveraging metadata to support the discoverability of First...
byBookNet Canada
 
AI Meets DBA Transforming Database Administration with Intelligence
byGeoPITS Global Pvt Ltd
 
Teaching Robots how to Read 1/2: AI Center & Classic Document Understanding (...
byanabulhac
 
apidays Australia 2025 | The Strategic Role of APIs in Digital Transformation
byapidays
 
Computer Science Conferences 2026 | Research by SAI Conference
byHealth Conference 2026
 
How to Build a Crypto Wallet that Excels in 2026.pdf
byimoliviabennett
 
Database Management Systems: Basics, History, Data Models, etc.
byParithi Thamizh
 
Advance Computer Architecture Lecture 4.pptx
byBottshikanBottshikan
 
Understanding-Search-Algorithms_09-12-25.pptx
byshaikmahammedtauheed
 
Mathematical reviewer gor mmw in theofern
byyeojlevantinojesalva
 
Strategic Shelf Planning for the New Year Turning Resolutions into Revenue .pptx
byAnoop Ashok
 
CRM for the Insurance Industry Lessons for Insurance CIOs and Digital Leaders...
byKerry Millar
 
Spacecraft Guidance Quick Research Guide by Arthur Morgan
byArthur Morgan
 
Deploying Windows Clients & Managing Identities
byVICTOR MAESTRE RAMIREZ
 

Reactive Streams in the Web