Mastering Messaging for Scalable Event-Driven Systems
Struggling to Scale Your Distributed Systems Effectively?
As a senior engineer or architect, you’re familiar with the challenges of scaling applications and managing distributed systems. Integrating multiple services, navigating the limitations of traditional HTTP or RPC-based solutions, and ensuring smooth communication between systems can often feel like a never-ending struggle. You know that switching to messaging offers a more scalable, reliable, and event-driven approach, but where do you even begin?
Imagine your systems communicating seamlessly, reliably, and asynchronously. A future where your architecture is reactive, event-driven, and easily scalable. This future isn’t far off.
Ian Cooper’s Practical Messaging Workshop is here to help you bridge the gap between the complexity of distributed systems and the power of messaging. In just two days, Ian will guide you through the essential messaging patterns, best practices, and event-driven architecture principles that can transform your system architecture and help you tackle challenges like “lambda pinball” and other common anti-patterns.
Learning Objectives
- By the end of this workshop, you’ll be able to:
- Understand asynchronous communication in distributed systems for improved scalability.
- Master messaging patterns for event-driven architectures.
- Build scalable systems using messaging middleware like RabbitMQ and Kafka.
- Design reliable messaging solutions for high-performance systems.
The Trainer
Ian Cooper is a Principal Engineer based in London, a polyglot coding architect, and an internationally respected speaker with more than 20 years of experience delivering high-performance software solutions across domains such as government, healthcare, finance, and e-commerce.
Known for his deep expertise in designing scalable and reliable distributed systems, Ian is an experienced systems architect with a strong knowledge of OO, TDD/BDD, Domain-Driven Design, event-driven architecture, CQRS/ES, REST, Messaging, Design Patterns, Architectural Styles, ATAM, and Agile Engineering Practices.
He’s the creator and maintainer of Brighter, a .NET framework for building resilient, message-based applications.
Target Audience
This workshop is designed for Senior Engineers and Architects tasked with:
- Designing and implementing event-driven systems within their organization.
- Upgrading their messaging systems for more scalable, reliable communication.
- Solving common anti-patterns like “lambda pinball” and dealing with integration challenges in distributed systems.
If you’re working on building scalable distributed systems or just want to deepen your understanding of messaging and event-driven architectures, this workshop will help you take your skills to the next level.
Topics
In this workshop, we will dive deep into the following topics:
- Why Distribute? – Why do we need distributed systems?
- The Price of Distribution – The downsides of distribution and how to mitigate them.
- Integration Styles – Exploring different options for interoperability in distributed systems.
- Messaging Patterns – The essential building blocks of messaging, explained with exercises.
- Queues and Streams – The different types of messaging and how to use them.
- Reliable Messaging – The outbox pattern and how to ensure reliability in your messaging.
- Managing Asynchronous APIs – How to document and version asynchronous endpoints.
- Conversation Patterns – Understanding the different messaging endpoint patterns.
- Fat and Skinny Messages – Exploring Event Carried State Transfer (ECST).
- Domain and Summary Events – Why are they different and when to use them?
- Paper Workflows – How to model asynchronous systems using pre-automation office workflows.
- Reactive Architectures – How reactive approaches leverage messaging at their core.
- Process Automation – Modeling processes using choreography and orchestration.
Agenda
The material is presented in two parts: an introduction to messaging middleware (including hands-on exercises in RabbitMQ and Kafka) and the fundamentals of constructing event-driven architectures.
Hands-on exercises are offered in C#, Java, JavaScript, Python, and Go.
Day 1: Messaging Architectures and Simple Patterns
- Distributed Systems and Integration Styles
- Messaging Patterns for Scalable Systems
- Reliable Messaging and Messaging Middleware.
Day 2: Distributed Systems Advanced Patterns
- Event-Driven Design with Reactive Architectures
- Asynchronous APIs and Managing Communication Flow
- Process Automation and Control Flow in Event-Driven Systems.
How it works
This is an in-person, two-day workshop designed to provide both theoretical knowledge and hands-on experience. You will leave with practical skills you can apply immediately.
- Lecture Material – explaining the core concepts
- Hands-on Exercises – writing code for core messaging concepts
- Discussions – discussions amongst participants on their experiences
FAQ
Do I need to know something beforehand in order to participate in this workshop?
You need to be able to write code in C#, Python, Java, JavaScript, or Go. You do not need prior experience with messaging systems. We try to get everyone up to the same level on Day One.
Do I need to bring my laptop with me?
This is a Bring Your Own Device (BYOD) course. At BYOD courses delegates are required to bring their own laptop with the necessary software installed. In order to complete the exercises, you will need to be able to run Docker containers (through Docker Desktop, podman, etc.)
