The article examines microservice communication methods, comparing event‑driven (including event notification and event sourcing) with RPC, discussing API gateways, service coupling, design limits, internal microservice design, and provides practical guidance on choosing the appropriate approach.
This article explains the principles, advantages, and classifications of microkernel (plugin) architecture, demonstrates three common plugin patterns—pipeline, onion, and event‑driven—with real‑world examples such as VS Code, Gulp, and webpack, and shares practical implementation steps and best practices for applying microkernel design in front‑end projects.
Bilibili’s railgun platform transforms its high‑traffic like service into a scalable, fault‑tolerant system by moving writes to an asynchronous, Kafka‑driven pipeline, applying CQRS, partitioned processing, idempotency, hot‑key isolation, rate‑limiting, and unified SDKs, dramatically reducing database load and achieving ten‑fold throughput gains.
This article explains the principles of event‑driven programming and state‑machine design for microcontrollers, compares them with interrupt handling, introduces a message‑based architecture with concrete data structures and APIs, and shows how to build a reusable framework that solves ordering and loss problems in embedded applications.
This article guides readers through the evolution from monolithic to event‑driven microservice architectures, covering design patterns, scalability, reliability, communication strategies such as API gateways, BFF, service aggregation, asynchronous messaging, CQRS, event sourcing, and technology choices like Kafka and RabbitMQ to build highly available, scalable, and maintainable systems.
This article explains the fundamentals of event‑driven architecture, contrasts events with commands, outlines its four key characteristics, compares integration patterns, and details the capabilities and technical design of RocketMQ EventBridge, including standards, event hubs, schemas, and serverless integration.
A multi‑expert panel shares experiences, challenges, and best practices for building, operating, and evolving large‑scale event‑driven systems using technologies like Kafka, covering architecture decisions, domain modeling, observability, handling unordered events, and advice for day‑two operations.
This article examines microservice communication, comparing RPC and event‑driven approaches, explains different types of coupling, explores event notification and event sourcing, discusses API gateways and internal microservice design, and offers guidance on choosing the right integration method and managing service count.
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.
The article explains Apache's three MPMs (prefork, worker, event), how Nginx's event‑driven architecture and epoll model improve concurrency handling, and provides performance comparisons showing Nginx handling tens of thousands of connections with far lower memory usage than Apache.
This article examines Node.js’s strengths and weaknesses, its event‑driven architecture, practical code examples, middleware usage, impact on front‑end development, and forecasts its role in future trends such as cloud‑native, serverless, IoT, and AI applications.
This article compares Nginx and Apache, showing how Nginx’s event‑driven, single‑threaded architecture and efficient memory usage enable it to handle tens of thousands of concurrent connections with far less resources, and explains the underlying Apache work modes and I/O models.
The article explains Apache’s three processing models (prefork, worker, event), compares their resource usage with Nginx, and demonstrates how Nginx’s event‑driven, single‑threaded architecture achieves far higher concurrent connection capacity and better performance for web services.
The article examines how microservices interact, compares RPC and event‑driven approaches, analyzes different types of coupling, discusses event notification, event sourcing, API gateways, versioning, and offers practical guidance on reducing tight coupling and deciding the appropriate microservice architecture.
This article explains Scrapy's comprehensive crawling framework and Twisted's event‑driven networking engine, detailing their core concepts, workflow, code execution process, and how to debug Scrapy spiders using breakpoint tracing, providing a deep technical overview for backend developers.
This article examines the trade‑offs between RPC and event‑driven communication in microservice architectures, detailing different types of coupling, the benefits and drawbacks of event notification and event sourcing, practical examples, and strategies such as API gateways and internal microservice design to reduce tight coupling.
Learn how to use Spring's Application Event mechanism to separate main and sub‑processes in Java applications, covering custom event and listener creation, publishing events, abstract base event design, singleton manager, and a real‑world order‑cancellation SMS notification case.
The article explains how microservices communicate, comparing RPC and event‑driven approaches, describing event notification and event sourcing, discussing API gateways, coupling types, internal microservice design, and practical guidelines for limiting service count and reducing tight coupling.
AGEIPort is Alibaba's event‑driven, high‑throughput data import‑export framework that handles hundreds of billions of rows monthly, offering transparent concurrency, decentralized clustering, GitOps‑based delivery, and standardized domain‑model APIs to simplify complex B2B scenarios.
The article examines Kubernetes architecture from a software‑design viewpoint, showing how its declarative API and extensible ecosystem outpace Swarm and Mesos, and detailing core concepts, control‑plane components, identified design patterns such as microkernel, event‑driven and CQRS, key architectural decisions, and the resulting strengths and trade‑offs.
The article examines Baidu's Contract Advertising Platform, detailing its shift from a monolithic, siloed design to a DDD‑driven microservices architecture using COLA, CQRS, and layered governance, and shares best practices for handling complex B2B advertising scenarios, service iteration, and evolving business needs.
The article explains the different kinds of coupling in microservice communication, compares RPC and event‑driven (event notification and event sourcing) approaches, discusses API gateways, service versioning, and offers practical guidance on when to use each method while highlighting the challenges of tight coupling and internal microservice design.
The article explains the different types of service coupling in microservice architectures, compares RPC and event‑driven approaches—including event notification and event sourcing—provides practical examples, discusses API gateways and strategies to reduce tight coupling, and concludes with guidance on internal microservice design and when to adopt microservices.
The article explores event‑driven architecture in microservices, detailing transaction consistency challenges, eventual consistency solutions, domain‑driven design, bounded contexts, and practical patterns such as local transaction tables, event sourcing, and materialized views to achieve reliable distributed systems.
The article explains how traditional ACID transaction guarantees break down in microservice environments, discusses the challenges of distributed transactions, and presents event‑driven architectures, eventual consistency, domain services, materialized views, and practical patterns such as local transaction tables and event sourcing to achieve reliable consistency across services.
This article explains the different types of coupling in microservice architectures, compares RPC and event‑driven communication, discusses event notification and event sourcing, and offers practical guidance on reducing tight coupling, designing service gateways, and deciding the appropriate number of microservices.
This article explains how organizations can evolve from monolithic applications to microservices using service mesh patterns, Kubernetes sidecar proxies, event‑driven designs, and practical migration strategies such as incremental extraction, Lego‑style integration, and full rebuilds, while addressing latency, security, and observability concerns.
This article introduces the concept of software architectural patterns, explains why they are essential, and details five popular patterns—layered, microkernel, event‑driven, microservices, and space‑based—along with guidance on when and where to apply each.
This comprehensive guide explains how to transform a small e‑commerce monolith into a highly scalable, low‑latency, fault‑tolerant event‑driven microservice system by applying layered architecture, SOA, design patterns, API‑gateway strategies, CQRS, event sourcing, and appropriate cloud‑native technologies.
This article explains how epoll solves the inefficiencies of select/poll by using a kernel‑side red‑black tree and ready‑list, details its API, internal structures, trigger modes, reactor model, and provides a complete C demo for building a scalable TCP server.
This article examines the challenges of traditional data feature acquisition and presents Ant Group’s ultra‑real‑time client feature center, detailing its architecture, data collection, streaming and script computation, backflow mechanisms, and monitoring to deliver rich, timely, and easy‑to‑use features for AI models.
This article explains why traditional select/poll struggle with massive connections, how epoll's event-driven design using a red‑black tree and ready‑list dramatically improves scalability, details its two trigger modes, and provides a complete C demo illustrating a high‑performance reactor model.
This article explains how Domain-Driven Design is applied to a hotel transaction platform, detailing a four‑layer loose DDD architecture, the responsibilities of each layer, code implementation examples, and strategies for maintaining consistency across aggregates using events and factories.
This article examines the challenges faced by a transaction middleware platform, introduces a finite‑state‑machine (FSM) solution for order state flows, and compares traditional serial processing with future‑based staged concurrency and event‑driven concurrency models, highlighting their benefits and trade‑offs.
This article examines common Serverless anti‑patterns such as monolithic Lambdas, Lambda orchestration, Lambda‑to‑Lambda calls, and event loops, then presents six proven Serverless design patterns—including Command, Messaging, Priority Queue, Fan‑out, and Pipeline‑Filter—to help architects build cost‑effective, highly available, and maintainable cloud applications.
This article guides readers through the evolution from a monolithic e‑commerce application to a highly available, scalable, low‑latency event‑driven microservices architecture, covering design patterns, principles, API gateway, BFF, service aggregation, CQRS, event sourcing, and technology stack choices such as Kafka and Cassandra.
This comprehensive guide teaches how to design scalable, highly available microservice architectures by applying design patterns, principles, and best practices, covering the evolution from monolithic to event‑driven systems, communication strategies, data management techniques, and technology choices such as API gateways, BFF, CQRS, and Kafka.
The article dissects Linux’s epoll I/O multiplexing, tracing the flow from socket creation with accept through epoll_create, epoll_ctl registration, and epoll_wait sleeping, detailing the kernel’s eventpoll object, red‑black tree, per‑socket wait‑queue callbacks that enable O(log N) registration and O(1) event delivery for tens of thousands of connections.
The article explains how Redis implements a high‑performance single‑threaded architecture by using a Reactor‑style file‑event handler (FEH) built on I/O multiplexing, detailing socket events, the I/O multiplexing program, dispatcher, handler mapping, and the overall client‑server communication flow.
This article explains the differences between synchronous and asynchronous execution, explores various I/O programming models—including blocking, non‑blocking, multiplexed, signal‑driven, and asynchronous I/O—and describes how event‑driven architectures apply these concepts in server‑side development.
The article explains how the misconception of treating distribution as the whole of microservices leads to a distributed‑monolith trap, and shows how mixing command‑driven and event‑driven communication can decouple services, improve reliability, and guide a smooth migration from monolith to microservices.
This article introduces seven widely used software architecture patterns—layered, multi‑layer, pipe‑filter, client‑server, MVC, event‑driven, and microservices—explaining their contexts, problems they solve, typical structures, advantages, drawbacks, and suitable application scenarios.
This article explains the differences between synchronous and asynchronous calls, describes various I/O models—including blocking, non‑blocking, multiplexed, signal‑driven, and asynchronous I/O—and outlines how event‑driven programming works in Python back‑end frameworks such as Tornado, Twisted, Gevent, and asyncio.
This article explains how Xianyu tackled the challenges of rapidly delivering lightweight, dynamic pages by designing a stream‑based page container architecture that combines a platform‑side building system, MVVM client side, three‑layer protocols, event‑driven communication, and high‑performance list rendering in Flutter.
This article examines the challenges of evolving data models in large applications, explains the Command Query Responsibility Segregation (CQRS) pattern, and outlines when to adopt or avoid it to balance read/write performance, scalability, and system complexity.
This article explains the basic network programming pattern, introduces epoll as an I/O multiplexing solution for high‑concurrency servers, and demonstrates how Redis 5.0 integrates epoll through its event‑loop abstraction with detailed code examples and debugging tips.
This article introduces several fundamental software architecture patterns—including layered, event‑driven (mediator and broker), microkernel, microservices, and space‑based architectures—explaining their structures, key concepts, real‑world examples, and the trade‑offs developers should evaluate when choosing a pattern.
This article explains seven common software architecture patterns—layered, multi‑layer, pipe‑filter, client‑server, MVC, event‑driven, and microservices—detailing their context, the problems they address, typical solutions, drawbacks, and suitable application scenarios.
The article reviews modern application‑architecture trends, explains why traditional three‑tier designs are insufficient for cloud, mobile, social and big‑data environments, and proposes service‑oriented, micro‑service, event‑driven and open‑computing approaches together with architectural paradigms, models and organizational considerations.
This article explains the fundamentals of IO multiplexing in Linux, compares naive loop‑based approaches with kernel‑provided mechanisms, dives deep into epoll's three system calls, its internal red‑black‑tree and ready‑list design, and shows which file descriptors can be efficiently managed with epoll.
The article explains Nginx’s high‑performance, event‑driven architecture, detailing its master‑worker process model, asynchronous non‑blocking I/O, CPU affinity, accept‑mutex load balancing, and the modular design built around ngx_module_t, covering core and HTTP modules, configuration parsing, data structures, and compilation guidelines for developers.
Microservice communication can be handled via tightly‑coupled RPC calls or loosely‑coupled event‑driven messaging; this article examines various coupling types, compares RPC and event‑notification, explores event sourcing, API gateways, internal microservice design, and offers practical guidance on selecting the appropriate approach for different business scenarios.
The article explains how microservices communicate through RPC and event‑driven approaches, analyzes different coupling types, discusses event notification and event sourcing, examines API gateways and service composition, and offers practical guidance on reducing tight coupling and managing microservice scale.
This article explains the fundamentals of Linux epoll as a high‑performance IO multiplexing tool, compares it with select and poll, shows why non‑blocking file descriptors are required, and details the kernel‑level data structures and callbacks that make epoll efficient for backend services.
This article breaks down Nginx’s high‑performance architecture, covering its modular design, event‑driven processing, multi‑stage asynchronous request handling, master‑worker process model, and memory‑pool strategy, and explains how each component contributes to scalability, low latency, and efficient resource utilization.
Whale is an event‑driven automated operations platform that lets developers package atomic tasks, users compose workflows, and a rule‑matching engine trigger them in real time via an event center, employing a StackStorm‑based execution engine for fault‑tolerant, cross‑datacenter orchestration and future AI‑enhanced self‑healing.
This article summarizes Nginx's high‑performance architecture, covering its modular design, event‑driven processing, multi‑stage asynchronous request handling, master‑worker process model, and memory‑pool strategy, while illustrating each concept with diagrams and practical observations from recent reading notes.
The article examines microservice communication methods, comparing RPC and event‑driven approaches, explains different coupling types, introduces event notification and event sourcing, discusses API gateways, service composition, internal microservice design, and offers practical guidance for reducing tight coupling and managing service scale.
The article analyzes microservice communication patterns, comparing RPC and event‑driven approaches, explains different types of coupling, explores event notification and event sourcing, discusses API gateways, versioning strategies, and offers guidance on sizing microservice architectures and internal microservice design.
This article explains the observer and listener design patterns, shows how to implement both in Java with concrete code examples, compares their differences, and demonstrates how Spring's event mechanism is a practical application of these patterns.
This article introduces the Python‑based Locust load‑testing framework, explains its event‑driven architecture, weight‑based task distribution, command‑line and web UI operation, distributed execution, and practical usage patterns, then evaluates its advantages, drawbacks, and suitability for performance testing projects.
Beike's real-time computing platform, led by Liu Liyun, has evolved from early Spark Streaming to a Flink-based system with SQL 1.0, 2.0, and upcoming 3.0, supporting a large-scale data warehouse, event-driven processing, extensive monitoring, and diverse business scenarios across the company's operations.
This article explains Nginx’s multi‑process model, worker management, request handling flow, event‑driven architecture, module types, comparison with Apache, and I/O multiplexing mechanisms such as select, poll and epoll, providing a comprehensive understanding of its high‑concurrency capabilities and configuration limits.
At iQIYI’s April 10 technical salon, experts detailed the company’s private‑cloud serverless journey—from early adoption of Oracle’s Fn for FaaS, through the creation of the Airworkflow engine for event‑driven orchestration, to plans for an internal Dev App Store that eases integration and highlights the distinct needs of private‑cloud environments.
This article explains the importance of asynchronous messaging and event‑driven communication for coordinating changes across multiple microservices and bounded contexts, covering single‑receiver and multi‑receiver patterns, message brokers, eventual consistency, publishing/subscribing mechanisms, and practical implementation considerations.
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 why Nginx outperforms Apache under heavy load by comparing their architectures, work modes, memory usage, event‑driven design, and scalability techniques, and shows how Nginx can handle tens of thousands of concurrent connections with far less resources.
This article introduces Node.js by recounting its creator Ryan Dahl's background, explaining its core characteristics of single‑threaded, event‑driven, non‑blocking I/O architecture, describing suitable use cases, and reviewing basic code examples and popular frameworks such as Express, Koa, Nest, and Egg.
The article describes how the team built a production‑grade serverless workflow platform on Knative by creating four modules—a dashboard, API, operator, and syncer—that generate Kubernetes resources, automate CI/CD, monitor via Prometheus, and aim to cut boilerplate while supporting future extensions such as richer constructs, multi‑language support, and synchronous invocations.
This article explores the evolution of business architecture from functional to domain‑based microservice splitting, outlines service grading, identifies code coupling and unreasonable dependencies, and presents practical governance techniques such as on‑demand loading, event‑driven design, and anti‑corruption layers to improve stability and maintainability.
The article explains seven widely used software architecture patterns—layered, multi‑layer, pipe‑filter, client‑server, MVC, event‑driven, and microservices—detailing their contexts, problems they solve, typical structures, strengths, weaknesses, and suitable application scenarios.
This article introduces seven widely used software architecture patterns—layered, multi‑layer, pipe‑filter, client‑server, MVC, event‑driven, and microservices—explaining their context, problems they address, core solutions, drawbacks, and typical application scenarios.
This article explains Nginx's high performance by detailing its master‑worker process architecture, asynchronous event‑driven I/O model, modular design, and how it handles HTTP connections, requests, and concurrency compared to traditional servers like Apache.
The article explores how enterprises can reduce tight coupling in microservice architectures by converting synchronous calls to asynchronous messaging, adopting message‑oriented middleware, applying event‑driven analysis, and leveraging CQRS patterns, while also offering practical refactoring tactics for overly coupled services.
This article provides a detailed learning roadmap for Apache Flink, covering its theoretical background, key research papers, fundamental concepts, core modules, source‑code exploration, real‑time data‑warehouse use cases, event‑driven applications, and emerging trends in the big‑data ecosystem.
This article explains Nginx's high performance by examining its multi‑process architecture, asynchronous event‑driven design, modular components, and I/O multiplexing mechanisms such as epoll, while also comparing it with Apache and detailing connection limits and request handling flow.
The article explains seven fundamental software architecture patterns—layered, multi‑layer, pipe‑filter, client‑server, MVC, event‑driven, and microservices—detailing their contexts, problems solved, advantages, drawbacks, and typical use cases for developers.
Xianyu’s streaming page container architecture redesigns the Flutter home page with an MVVM‑based, event‑driven framework, DinamicX DSL templates, and the PowerScrollView list container, eliminating duplicated layout logic, accelerating A/B testing and releases, and enabling dynamic, lightweight pages with partial UI refreshes.
This article explains the evolution of transaction management from local and distributed (2PC/3PC) transactions in monolithic systems to the challenges in microservices, introduces the BASE theory, and details four microservice‑compatible consistency patterns—reliable event notification, max‑effort notification, business compensation, and TCC—along with their trade‑offs.
The article explains cloud‑native architecture as a set of principles and design patterns that offload non‑functional concerns to cloud services, and it details major patterns such as service‑oriented, mesh, serverless, storage‑compute separation, distributed transactions, observability, and event‑driven architectures.
KEDA 2.0, now a CNCF sandbox project, adds many new event‑driven triggers, introduces a dedicated ScaledJob resource, supports both Deployments and Jobs, and provides fresh scalers such as Azure Log Analytics, IBM MQ, a CPU scaler, and a Metrics API extender, making Kubernetes autoscaling far more responsive to external workloads.
This article introduces seven common software architecture patterns—layered, multilayer, pipe‑filter, client‑server, MVC, event‑driven, and microservices—explaining their context, typical problems they address, core solutions, inherent drawbacks, and suitable application scenarios for developers and system designers.
The article explains how monolithic drawbacks—complexity, technical debt, and scaling issues—drive the shift to microservices, then details applying Domain‑Driven Design principles such as bounded contexts, aggregates, and layered architecture to design cohesive, loosely‑coupled services, illustrated with e‑commerce examples and code snippets.
This article explains the seven fundamental software architecture patterns—layered, multilayer, pipe‑filter, client‑server, MVC, event‑driven, and microservices—detailing their contexts, problems they solve, typical solutions, drawbacks, and suitable application scenarios.
This article provides a systematic overview of Nginx’s high‑performance architecture, covering its modular design, master/worker process model, event‑driven loop, HTTP request processing phases, location matching rules, upstream load‑balancing, FastCGI and proxy configurations, rate‑limiting mechanisms, and common 502 error troubleshooting, while offering practical tips for reading the source code.
This article explains seven fundamental software architecture patterns—layered, multilayer, pipe‑filter, client‑server, MVC, event‑driven, and microservices—detailing their contexts, problems they solve, typical solutions, weaknesses, and appropriate usage scenarios for developers and designers.
The PHP Event extension wraps the libevent library to provide an object‑oriented API for building event‑driven, non‑blocking HTTP servers and clients, timers, and signal handling, with example code and links to documentation and related extensions.
This article explains seven common software architecture patterns—layered, multi‑layer, pipe‑filter, client‑server, MVC, event‑driven, and microservices—detailing their context, problems they solve, typical solutions, drawbacks, and ideal usage scenarios for developers.
This article introduces the limitations of traditional local and distributed transactions for microservices, explains the BASE theory, and details four practical patterns—reliable event notification, maximum‑effort notification, business compensation, and TCC—providing code examples, diagrams, and a comparative table to guide developers in achieving eventual consistency across microservice architectures.
This article explains seven common software architecture patterns—layered, multi‑layer, pipe‑filter, client‑server, MVC, event‑driven, and microservices—detailing their contexts, problems they solve, typical structures, strengths, weaknesses, and suitable application scenarios to help developers choose the right architecture for their projects.
The article reviews microservice data consistency challenges, explains why traditional distributed transactions like 2PC/3PC are unsuitable, introduces the BASE theory, and details four implementation patterns—reliable event notification, maximum effort notification, business compensation, and TCC—to achieve eventual consistency.
The article analyzes common coupling problems in microservice architectures and presents practical decoupling techniques—including asynchronous messaging, event‑driven design, local caching, data landing, and CQRS—while also offering refactoring guidelines for tightly coupled services.
This article explains Nginx’s highly modular architecture, its multi‑process and asynchronous non‑blocking request handling, the event‑driven model, and the master/worker design, providing a comprehensive foundation for developers who want to understand or explore Nginx’s source code.
This article explains how to use Spring's event‑driven mechanism to decouple business operations such as saving a product and sending notifications, showing step‑by‑step code for custom events, publishing, asynchronous listeners, and custom thread‑pool configuration to improve resilience and maintainability.
This article analyzes the challenges of tightly coupled microservices and presents practical decoupling techniques—including asynchronous messaging, event‑driven architecture, CQRS, local caching, and service refactoring—to improve resilience and availability in modern backend systems.
This article compares five common software architecture patterns—layered, event‑driven, microkernel‑plugin, microservices, and cache—detailing their structures, advantages, drawbacks, and ideal use cases, helping architects choose the most suitable design for new or existing applications.
This article discusses how to reduce coupling between microservices by converting synchronous calls to asynchronous messaging, employing message middleware, event‑driven architecture, CQRS patterns, local caching, data landing, and refactoring techniques such as merging services, extracting common modules, and adjusting granularity.
This article explains Netty as an asynchronous event‑driven network framework, compares synchronous and asynchronous processing, describes event‑driven programming, details the differences among BIO, NIO and AIO I/O models, and outlines Netty's core components and architecture.
The article examines why tightly coupled microservices cause reliability issues, then presents practical techniques—such as converting synchronous calls to asynchronous messaging, adopting event‑driven architecture, using CQRS, caching, and strategic refactoring—to achieve loose coupling and improve system resilience.
This article examines the challenges of microservice communication, explains why REST APIs are unsuitable, and compares two messaging broker solutions—Kafka and Mosquitto—highlighting their architectures, persistence, scalability, and suitability for high‑traffic, reliable event‑driven systems.