Typical talks I give
Process-oriented system integration
Companies need to automate processes. Therefore they need to integrate various systems, people, and devices. In the past, many initiatives to process automation struggled (maybe you remember BPM and SOA?) and local automations were applied instead, only automating certain tasks from within a process. At the same time, business departments started their own automation endeavors using low-code tooling, leading to their own challenges that very often arrived in IT sooner or later.
In this talk, I want to quickly recap the status quo of process automation possibilities from the developer’s point of view. I want to describe the role of process orchestration and make it concrete by some live coding using Java, Spring, and Camunda (without making it an advertorial for Camunda of course). At the same time, I want to sketch possibilities to leverage all of our modern achievements (like Cloud, SaaS, Github, changed developer experiences) to make orchestration easier and more fun to use. Expect a bit of live coding, but also real-life stories.
Complex event flows in distributed systems
Event-driven architectures enable nicely decoupled microservices and are fundamental for decentral data management. However, using peer-to-peer event chains to implement complex end-to-end logic crossing service boundaries can accidentally increase coupling. Extracting such business logic into dedicated services reduces coupling and allows to keep sight of larger-scale flows - without violating bounded contexts, harming service autonomy or introducing god services. Service boundaries get clearer and service APIs get smarter by focusing on their potentially long running nature. I will demonstrate how the new generation of lightweight and highly-scalable state machines ease the implementation of long running services. Based on my real-life experiences, I will share how to handle complex logic and flows which require proper reactions on failures, timeouts and compensating actions and provide guidance backed by code examples to illustrate alternative approaches.
- Exemplary slides: https://www.slideshare.net/BerndRuecker/2019-complex-event-flows-in-distributed-systems/
- Sample Recording: https://www.youtube.com/watch?v=O2-NHptllKQ&feature=youtu.be
- Related Articles: https://www.infoq.com/news/2019/03/event-driven-systems | https://www.infoq.com/articles/monitor-workflow-collaborating-microservices | https://www.infoq.com/articles/events-workflow-automation
Lost in transaction? Strategies to manage consistency in distributed systems
You probably work on a distributed system. Even if you don't yet face a serverless microservice architecture using fancy NoSQL databases, you might simply call some remote services via REST or SOAP. This leaves you in charge of dealing with consistency yourself. ACID transactions are only available locally within components and protocols like two-phase commit don’t scale. Many projects either risk adventurous inconsistencies or write a lot of code for consistency management in the application layer. In this talk I discuss these problems and go over possible solutions, including the Saga-Pattern. I will discuss recipes and frameworks that ease the management of the right level of consistency. This allows you write business logic code. Expect fun little live hacking sessions with open source components, but also real-life stories.
3 common pitfalls in microservice integration and how to avoid them
Integrating microservices and taming distributed systems is hard. In this talk I will present three challenges I've observed in real-life projects and discuss how to avoid them.
1. Communication is complex. With everything being distributed failures are normal so you need sophisticated failure handling strategies (e.g. stateful retry).
2. Asynchronicity requires you to handle timeouts. This is not only about milliseconds, systems get much more resilient when you can wait for minutes, hours or even longer.
3. Distributed transactions cannot simply be delegated to protocols like XA. So you need to solve the requirement to retain consistency in case of failures.
I will not only use slides but also demonstrate concrete source code examples available on GitHub.
- Exemplary slides: http://www.slideshare.net/BerndRuecker/2018-lost-in-transaction
- Sample recording: https://www.youtube.com/watch?v=O2-NHptllKQ&feature=youtu.be
- Related article: https://www.infoworld.com/article/3254777/application-development/3-common-pitfalls-of-microservices-integrationand-how-to-avoid-them.html