Adding content to 100-messaging

src/roadmaps/system-design/content/118-cloud-design-patterns/100-messaging/100-asynchronous-request-reply.md

@@ -1 +1,8 @@
-# Asynchronous request reply
+# Asynchronous Request Reply
+
+Asynchronous Request-Reply in system design refers to a pattern where a client sends a request to a server and the server responds asynchronously, allowing the client to continue processing other tasks or requests without waiting for the server's response. This can improve the performance and scalability of a system by allowing multiple requests to be processed concurrently. It can be implemented using callbacks, promises or event-based models.
+
+Learn more from the following links:
+
+- [Asynchronous Request-Reply pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/async-request-reply)
+- [Intro to Asynchronous Request-Response](https://codeopinion.com/asynchronous-request-response-pattern-for-non-blocking-workflows/)

src/roadmaps/system-design/content/118-cloud-design-patterns/100-messaging/101-claim-check.md

@@ -1 +1,8 @@
-# Claim check
+# Claim Check
+
+Claim check in system design is a pattern where large or complex data is replaced with a small token or reference, which is passed along with a message or request. This can help to reduce the size and complexity of messages, and improve the performance and scalability of a system. The large or complex data is stored in a separate location, and a token generator is used to create a unique token for the actual data.
+
+Learn more from the following links:
+
+- [An Introduction to Claim-Check Pattern and Its Uses](https://aws.plainenglish.io/an-introduction-to-claim-check-pattern-and-its-uses-b018649a380d)
+- [Claim Check - Cloud Design patterns](https://learn.microsoft.com/en-us/azure/architecture/patterns/)

src/roadmaps/system-design/content/118-cloud-design-patterns/100-messaging/102-choreography.md

@@ -1 +1,8 @@
-# Choreography
+# Choreography
+
+Choreography in system design refers to the design and coordination of interactions between autonomous systems or services, without the use of a central controlling entity. Each system or service is responsible for its own behavior and communication with other systems or services, and there is no central point of control or coordination. Choreography can be used to improve the scalability, flexibility, and resilience of a system, by allowing each service to evolve and scale independently. It can be implemented using event-based, message-based or API-based models.
+
+Learn more from the following links:
+
+- [Choreography pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/choreography)
+- [Service choreography](https://en.wikipedia.org/wiki/Service_choreography)

src/roadmaps/system-design/content/118-cloud-design-patterns/100-messaging/103-competing-consumers.md

@@ -1 +1,8 @@
-# Competing consumers
+# Competing Consumers
+
+Competing Consumers in system design is a pattern that allows multiple consumers to process messages concurrently from a shared message queue. This approach can be used to improve the performance and scalability of a system by allowing multiple consumers to process messages in parallel. This pattern can be used in scenarios like load balancing and fault tolerance. It can be implemented using a variety of messaging technologies such as message queues, message brokers, and publish-subscribe systems.
+
+Learn more from the following links:
+
+- [Competing Consumers pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/competing-consumers)
+- [Competing Consumers Pattern - Explained](https://medium.com/event-driven-utopia/competing-consumers-pattern-explained-b338d54eff2b)

src/roadmaps/system-design/content/118-cloud-design-patterns/100-messaging/104-pipes-and-filters.md

@@ -1 +1,8 @@
-# Pipes and filters
+# Pipes and Filters
+
+Pipes and Filters in system design is a pattern that separates the processing of a task into a series of smaller, independent components, connected together in a pipeline. Each component, or filter, performs a specific task, and the output of one filter is passed as the input to the next filter. This approach can be used to build modular and extensible systems, by allowing filters to be added, removed, or replaced easily. Pipes and Filters pattern can be used in scenarios like data processing and data transformation. It can be implemented using a variety of technologies such as streams, generators, and iterators.
+
+Learn more from the following links:
+
+- [Pipe and Filter Architectural Style](https://cs.uwaterloo.ca/~m2nagapp/courses/CS446/1181/Arch_Design_Activity/PipeFilter.pdf)
+- [Pipes and Filters pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/pipes-and-filters)

src/roadmaps/system-design/content/118-cloud-design-patterns/100-messaging/105-priority-queue.md

@@ -1 +1,7 @@
-# Priority queue
+# Priority Queue
+
+A priority queue in system design is a data structure that stores items with a priority value, and allows for efficient retrieval and manipulation of the items based on their priority. The items with the highest priority are retrieved first. This pattern is useful in situations where certain items or tasks are more important than others and should be processed first. Priority Queue can be used in scenarios like scheduling and real-time systems. It can be implemented using various data structures such as heap, linked list, and array.
+
+Learn more from the following links:
+
+- [Priority Queue pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/priority-queue)

src/roadmaps/system-design/content/118-cloud-design-patterns/100-messaging/106-publisher-subscriber.md

@@ -1 +1,8 @@
-# Publisher subscriber
+# Publisher Subscriber
+
+Publisher-Subscriber in system design is a pattern that allows multiple subscribers to receive updates from a single publisher, without the publisher and subscribers being aware of each other's existence. This pattern allows for decoupling of the publisher and subscribers, and can be used to build scalable and flexible systems. It can be used in scenarios like event-driven architecture and data streaming. It can be implemented using a variety of technologies such as message queues, message brokers, and event buses.
+
+Learn more from the following links:
+
+- [What is Pub/Sub Messaging?](https://aws.amazon.com/pub-sub-messaging/)
+- [Publisher Subscriber - Pattern](https://www.enjoyalgorithms.com/blog/publisher-subscriber-pattern)

src/roadmaps/system-design/content/118-cloud-design-patterns/100-messaging/107-queue-based-load-leveling.md

@@ -1 +1,8 @@
-# Queue based load leveling
+# Queue Based Load Leveling
+
+Queue-based load leveling in system design is a pattern that allows for the buffering of incoming requests, and the processing of those requests at a controlled rate. This pattern can be used to prevent overloading of a system, and to ensure that the system can handle a variable rate of incoming requests. It can be used in scenarios like traffic spikes and variable workloads. It can be implemented using various data structures such as linked list, array, and heap.
+
+Learn more from the following links:
+
+- [Queue-Based Load Leveling pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/queue-based-load-leveling)
+- [Design Patterns: Queue-Based Load Leveling Pattern](https://blog.cdemi.io/design-patterns-queue-based-load-leveling-pattern/)

src/roadmaps/system-design/content/118-cloud-design-patterns/100-messaging/108-scheduling-agent-supervisor.md

@@ -1 +1,7 @@
-# Scheduling agent supervisor
+# Scheduling Agent Supervisor
+
+Scheduling Agent Supervisor in system design is a pattern that allows for the scheduling and coordination of tasks or processes by a central entity, known as the Scheduling Agent. The Scheduling Agent is responsible for scheduling tasks, monitoring their execution, and handling errors or failures. This pattern can be used to build robust and fault-tolerant systems, by ensuring that tasks are executed as intended and that any errors or failures are handled appropriately.
+
+Learn more from the following links:
+
+- [Scheduler Agent Supervisor pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/scheduler-agent-supervisor)

src/roadmaps/system-design/content/118-cloud-design-patterns/100-messaging/109-sequential-convoy.md

@@ -1 +1,8 @@
-# Sequential convoy
+# Sequential Convoy
+
+Sequential Convoy in system design is a pattern that allows for the execution of a series of tasks, or convoy, in a specific order. This pattern can be used to ensure that a set of dependent tasks are executed in the correct order and to handle errors or failures during the execution of the tasks. It can be used in scenarios like workflow and transaction. It can be implemented using a variety of technologies such as state machines, workflows, and transactions.
+
+Learn more from the following links:
+
+- [What is Sequential Convoy?](https://learn.microsoft.com/en-us/biztalk/core/sequential-convoys)
+- [Overview - Sequential Convoy pattern](https://learn.microsoft.com/en-us/azure/architecture/patterns/sequential-convoy)

src/roadmaps/system-design/content/118-cloud-design-patterns/100-messaging/index.md

@@ -1 +1,8 @@
-# Messaging
+# Messaging
+
+Messaging in system design is a pattern that allows for the communication and coordination between different components or systems, using messaging technologies such as message queues, message brokers, and event buses. This pattern allows for decoupling of the sender and receiver, and can be used to build scalable and flexible systems. Messaging pattern can be used in scenarios like asynchronous communication, loose coupling, and scalability. It can be implemented using a variety of technologies such as message queues, message brokers, and event buses.
+
+Learn more from the following links:
+
+- [System Design — Message Queues](https://medium.com/must-know-computer-science/system-design-message-queues-245612428a22)
+- [Intro to System Design - Message Queues](https://dev.to/karanpratapsingh/system-design-message-queues-k9a)