Talking with messages: reliability in distributed systems

How do several services of the same system talk to each other without falling together? This architecture course starts from the guarantees, not the technologies: it first explains what a message promises (and does not), then shows how RabbitMQ and Kafka, its two archetypes, keep those promises. Coupling, delivery semantics, ordering and idempotence, the transactional outbox, poison messages, backpressure, sagas: each chapter closes a reliability gap opened by the previous one. The examples are real (Hexeract, the Rust messaging framework) and compared against a second .NET lens (Wolverine). Running thread: placing an e-commerce order, hardened chapter after chapter.

1. 00
   Why talk with messages

   When one service calls five others to confirm an order, a single one going down makes everything fail. The asynchronous message changes that: here is why, and what it really promises.
   18 min
2. 01
   The three families of messages

   The previous chapter set the command against the event. But asking for information is neither. Here is the third family, and the clean line that separates all three.
   19 min
3. 02
   Broker versus log

   The previous chapter treated the mailbox as a black box. We open it. There are two ways to build it, and the whole difference comes down to one question: who remembers what has already been read?
   22 min
4. 03
   Delivery semantics

   The previous chapter dropped a word without digging into it: the acknowledgement. Everything turns on its timing. Acknowledge too early and you risk losing a message; acknowledge too late and you risk processing it twice. There is no third door, and this chapter explains why.
   22 min
5. 04
   Ordering and idempotency

   The previous chapter promised a consumer that recognizes an already-processed message, without saying how. Here it is. But while building it, we discover that redelivery does not only bring duplicates: it can also put everything out of order, and idempotence alone is not enough.
   24 min
6. 05
   Dual write and the transactional outbox

   We hardened the consumer in the previous chapter. But it all rested on a promise from the producer: to publish the message when the business state changes. Yet publishing touches two worlds at once, its database and the broker, and nothing makes them atomic together. This chapter fixes that last gap.
   25 min