This article explains the concept of an Event Bus, when to apply it in frontend projects, provides a full JavaScript implementation, demonstrates its use with a login scenario, and outlines best practices and pitfalls for maintaining clean, decoupled code.
This article explains the lightweight publish/subscribe MQTT protocol, its origin, key features, usage scenarios, differences from traditional message queues, topic structures and wildcards, as well as practical client tools like Mosquitto and MQTTX with configuration examples.
This article shares hard‑won lessons from production incidents and provides practical guidelines—graceful shutdown, proper startup timing, suitable business scenarios, reliability patterns, and idempotent handling—to use Spring Event safely and effectively in Java backend systems.
This article explains MQTT’s lightweight publish‑subscribe protocol, its architecture, key features, QoS levels, typical IoT use cases, and why it’s preferred over HTTP for low‑bandwidth, low‑power applications, including examples from agriculture, industrial automation, transportation, and even social messaging platforms like Facebook Messenger.
This article explains the Observer and Publish‑Subscribe design patterns, compares their concepts and implementations, and provides ten practical Python code examples ranging from simple event notification to distributed messaging with libraries such as pubsub, redis, asyncio, Flask, threading, ZeroMQ, and PySide2.
This article explains the Observer design pattern, its intent, real‑world analogies, advantages and drawbacks, and provides a complete JavaScript example with prototype‑based code to illustrate how publishers and subscribers interact in an event‑driven system.
This article explains the concepts, differences, and implementation approaches of the Observer and Publish‑Subscribe design patterns, and provides ten practical Python code examples covering GUI, networking, asynchronous, and distributed scenarios.
MQTT is a lightweight, publish/subscribe messaging protocol ideal for IoT and mobile environments, offering low bandwidth usage, reliability, and TLS/SSL security, and the article provides a detailed PHP example demonstrating connection, subscription, publishing, message processing, and graceful disconnection.
This article explains how to design and implement a basic task system—covering task configuration, display, progress tracking, and reward collection—while using Kafka for decoupling services and a publish/subscribe event layer to keep task logic independent of event sources.
Learn how to effectively use React Context for state management, avoid props drilling, and eliminate redundant re‑renders by implementing a custom publish‑subscribe store, selector hooks, and performance optimizations similar to libraries like zustand.
This article explains the Observer (publish‑subscribe) pattern, illustrates it with a humorous dialogue, provides complete Go interface and struct implementations for subjects and observers, shows sample client code and output, and discusses practical refactoring using the pattern for configuration changes.
RTMS (Real Time Message Service) is a frame‑synchronization‑based real‑time communication solution that offloads logic from the server, uses in‑memory processing, and employs decentralized, non‑persistent, publish‑subscribe routing to dramatically improve latency, scalability, and interactivity for high‑frequency multi‑user scenarios.
This article explains the Observer pattern, compares it with the Publish‑Subscribe model, showcases Java's built‑in Observable and Observer classes, provides complete code examples, and discusses practical considerations such as memory leaks and performance optimizations.
This article explains how Kafka can be used for data ingestion and event distribution by illustrating production‑consumer and publish‑subscribe models, describing core concepts such as topics, partitions and consumer groups, and offering practical design options for handling different event scenarios.
Kafka is an Apache‑hosted distributed streaming platform that provides high‑throughput, durable, publish‑subscribe messaging, originally developed by LinkedIn; this article explains its core concepts, message system classifications, architecture components, APIs, replication, consumer groups, and guarantees, comparing it with other messaging solutions.
MQTT and CoAP are lightweight IoT communication protocols with distinct architectures—MQTT uses a publish/subscribe model ideal for WAN scenarios and bandwidth‑constrained devices, while CoAP follows a request/response pattern suited for local networks and HTTP compatibility, and the article explains their differences and appropriate use cases.
Zhihu’s infrastructure team designed a high‑performance, scalable long‑connection gateway that decouples business logic via publish‑subscribe, leverages OpenResty, Kafka, and Redis, implements fine‑grained ACL, sliding‑window flow control, and ensures message reliability and horizontal scalability for millions of concurrent devices.
This article explains how modern message middleware works by describing the two primary communication styles—message queuing and publish‑subscribe—illustrating each with examples, comparing their characteristics, and listing common middleware products to help developers choose the appropriate solution for their backend systems.
This article explains the motivations behind using message‑queue middleware, outlines its benefits such as decoupling, asynchronous processing and peak‑shaving, describes point‑to‑point and publish‑subscribe communication models, and provides a detailed overview of Kafka’s architecture, terminology, data flow, storage strategy, and consumer group mechanics.
MQTT is a lightweight, open‑source publish/subscribe protocol that powers the IoT’s global nervous system by delivering small‑header messages over TCP/IP with configurable QoS, low bandwidth, and optional TLS security, making it ideal for battery‑constrained devices, scalable deployments, and real‑time applications such as home monitoring.
This article introduces the MQTT protocol, outlines its key characteristics, explains the challenges it poses for IoT messaging, and details how JMQ addresses these challenges through a layered proxy‑broker architecture, subscription management, quality‑of‑service handling, and real‑world JD deployment.
This article explains how to apply Domain‑Driven Design's domain events to separate reply handling from push notification logic, discusses the shortcomings of embedding side‑effects directly, compares Spring and Guava event mechanisms, and provides a custom Guava‑based publisher implementation with synchronous and asynchronous buses.
This article explains the producer‑consumer and publish‑subscribe messaging patterns, introduces RabbitMQ’s core concepts such as exchanges, queues, routing keys, and reliability mechanisms, and demonstrates how to apply these patterns to data ingestion and event distribution scenarios with practical diagrams.
This article explains Kafka's core concepts and compares producer‑consumer and publish‑subscribe models, illustrating how to apply each pattern for data ingestion and event distribution in distributed backend systems, and offers practical design alternatives when Kafka’s native capabilities fall short.
MQTT, a lightweight publish/subscribe protocol designed for low‑bandwidth, unstable networks, has evolved since its 1999 IBM inception into an open‑standard IoT messaging solution, offering reliable delivery, three QoS levels, persistent sessions, and minimal overhead, addressing key IoT connectivity challenges.
This article explains how EventBus replaces explicit publisher‑subscriber registration for in‑process event dispatch in Java, provides a concise code example, a one‑minute migration guide, details on listeners and producers, a terminology table, and a comprehensive FAQ covering usage, design decisions, and testing considerations.
