With Viktor Klang, Deputy CTO Lightbend, Inc. As software grows more and more interconnected, and with several generations of software having to interoperate, a new take on the integration of systems is needed—ad hoc, unversioned, and unreplicated scripts just won’t suffice, and the traditional Enterprise Service Bus (ESB) concept has experienced stability, reliability, performance, and scalability problems. In this webinar, Viktor explores a new take on Enterprise Integration Patterns: First, he will explore the Reactive Streams standard, an orchestration layer where transformations are standalone, composable, reusable, and—most importantly—using asynchronous flow-control—back pressure—to maintain predictable, stable, behavior over time. Furthermore, he will go through how one-off workloads relate to continuous, and batch, workloads, and how they can be addressed by that very same orchestration layer. Finally, he will review how this type of design achieves resilience, scalability, and ultimately—responsiveness.

1. Revitalizing
Enterprise Integration
with Reactive Streams
√
Deputy CTO at Lightbend
@viktorklang / v@lightbend.com / http://viktorklang.com

3. What to expect from this talk?

4. The most common programming tasks?
4 Naming things
4 Design the Perfect Bikeshed
4 Receive inputs
4 Transform data
4 Produce outputs

5. code.demo()

6. Systems

7. Step 1: connect(ALL THE THINGS)
Step 2: Ship it!

8. ||

9. The past and present of
Enterprise Integration

10. Now playing: «Why SOA failed (Klang remix)»
4 WS
4 Schema evolution
4 Service Discovery
4 Testing
4 ESBs

11. The rise of
Enterprise Integration Patterns1
1
Gregor Hohpe and Bobby Woolf, 2003

12. Breaking the Camel's Back?

13. What if…

14. Reactive Enterprise Integration?
4 Streaming as a first-class concept
4 Flow control built-in
4 Reusable shapes for integration

15. Flow Control Facts
4 Buffers hide latency
4 Buffers do not solve overload problems
4 Load shedding does not inform sender
4 Blocking creates a low upper limit on concurrency
4 Blocking makes fan-in and fan-out problematic

16. Flow Control Done Right
4 Support potentially unbounded sequences
4 Sender runs independently from receiver
4 Rate of reception may vary from rate of sending
4 Dropping data should be a choice and not a necessity
4 Minimal—if any—overhead in terms of latency and
throughput

17. Reactive Streams2
&
java.util.concurrent.Flow
4 Publisher<Output>
4 Subscriber<Input>
4 Processor<Input, Output>
4 Subscription
2
www.reactive-streams.org

18. Reactive Streams

19. Reactive Streams &
java.util.concurrent.Flow
4 «push» when subscriber is faster
4 «pull» when publisher is faster
4 switches dynamically between both
4 smart prefetch made possible

20. 4 immutable
4 reusable
4 composable
4 coordinated
4 asynchronous
4 distributed
4 transformations

21. Akka Stream building blocks3
3
Non-exhaustive list

22. Medium
Codec
Protocol
Combinator

23. Riding the Alpakka4
Reactive Enterprise Integration based
on Akka Streams—for Java and Scala.
4
https://github.com/akka/alpakka (Apache v2)

24. code.demo()

25. Connectors currently found in
Alpakka5
AMQP, Apache Geode, Apache Solr, AWS DynamoDB,
AWS Kinesis, AWS Lambda, AWS S3, AWS SNS, AWS SQS,
Azure Storage Queue, Cassandra, Elasticsearch,
File IO, FTP, Google Cloud Pub/Sub, HBase, IronMq,
JMS, MongoDB, MQTT, OrientDB, Server-sent Events,
Slick (JDBC), Spring Web, Unix Domain Socket
5
And also HTTP, TCP, Apache Kafka, and many more…

26. Further reading
Transforming enterprise integration
with reactive streams
https://www.oreilly.com/ideas/transforming-enterprise-integration-with-reactive-streams
Reactive Programming vs Reactive
Systems
https://www.oreilly.com/ideas/reactive-programming-vs-reactive-systems

27. References
4 The example: https://github.com/lightbend/
reactive-integration-examples/tree/master/
integration-webinar
4 Akka Streams documentation: https://doc.akka.io/
docs/akka/current/stream/index.html?
language=java
4 Alpakka documentation: https://
developer.lightbend.com/docs/alpakka/current/

28. Thank you!