BestHub
Sign in
Tagged articles

event-driven

255 articles · Page 1 of 3
Thought Artisan
Thought Artisan
Sep 12, 2026 · Fundamentals

Software Architecture Styles: Pipe-Filter, OO, Event-Driven, Layers, Repositories & Interpreters

This article defines software architectural styles through components, connectors, constraints, and computational models, detailing six classic styles—Pipe-and-Filter, Object-Oriented, Event-Driven, Layered, Repository, and Interpreter—with their invariants, examples, advantages, disadvantages, and specializations, plus heterogeneous architecture combinations.

architectural stylesevent-driveninterpreter pattern
0 likes · 16 min read
Software Architecture Styles: Pipe-Filter, OO, Event-Driven, Layers, Repositories & Interpreters
Code Farming
Code Farming
Sep 11, 2026 · Backend Development

DDD-Driven Microservice Splitting: 3 Key Steps to Avoid Coupling Pitfalls

This article explains how Domain-Driven Design (DDD) guides microservice splitting through three steps: enforcing high cohesion and low coupling principles, dividing systems into core, supporting, and generic domains via bounded contexts, and using message queues for asynchronous event-driven decoupling, illustrated with an online food ordering example.

DDDbounded-contextdomain modeling
0 likes · 8 min read
DDD-Driven Microservice Splitting: 3 Key Steps to Avoid Coupling Pitfalls
Cambridge Mofang Notes
Cambridge Mofang Notes
Sep 7, 2026 · Backend Development

Points System Architecture: Concurrency, Batch Expiration & Idempotent Reconciliation

This article walks through designing a points system architecture, starting from a concrete scenario of consuming 80 points across two batches with retries and refunds, covering data models, idempotency keys, local transactions, cache-aside, event-driven reconciliation, scaling strategies, and evolutionary deployment phases.

batch expirationcache-asideevent-driven
0 likes · 27 min read
Points System Architecture: Concurrency, Batch Expiration & Idempotent Reconciliation
Java Companion
Java Companion
Sep 1, 2026 · Backend Development

How RocketMQ’s LiteTopic Empowers Million-Scale AI Conversations

The article explains how RocketMQ 5.5.0 introduces the LiteTopic model to support AI workloads, detailing its lightweight two‑layer topic design, automatic creation, RocksDB indexing, event‑driven consumption, precise flow control, and provides step‑by‑step setup and code examples.

AIConsume SuspendLiteTopic
0 likes · 9 min read
How RocketMQ’s LiteTopic Empowers Million-Scale AI Conversations
Ray's Galactic Tech
Ray's Galactic Tech
Aug 24, 2026 · Backend Development

Decoupling Payments and Wallets: From Order Domain to a Unified Accounting Center

The article walks through why embedding a wallet in the order service leads to boundary violations and failures under load, and presents a step‑by‑step evolution from an order‑centric wallet to a dedicated, event‑driven accounting center that ensures consistency, auditability, and high‑throughput scalability.

Domain-Driven DesignHigh ConcurrencyOutbox Pattern
0 likes · 42 min read
Decoupling Payments and Wallets: From Order Domain to a Unified Accounting Center
Open Source Tech Hub
Open Source Tech Hub
Aug 24, 2026 · Backend Development

Implementing Event-Driven Architecture for Async PHP SaaS AI Applications

This article shows how to use Laravel’s event‑driven architecture—events, listeners, and queue jobs—to decouple slow AI calls in a SaaS product, delivering instant HTTP responses, background processing, real‑time WebSocket updates, robust retry/failure handling, and fast, isolated testing.

@AsyncAILaravel
0 likes · 12 min read
Implementing Event-Driven Architecture for Async PHP SaaS AI Applications
Mike Chen Rui
Mike Chen Rui
Aug 5, 2026 · Backend Development

How Can a Gateway Sustain Million‑Level Concurrency in High‑Traffic Scenarios?

The article explains why a gateway is the first traffic entry in microservice systems and how Spring Cloud Gateway achieves million‑level concurrent handling through a reactive model, non‑blocking I/O, event‑driven scheduling, zero‑copy transmission, and built‑in rate‑limiting mechanisms.

High ConcurrencyRate LimitingSpring Cloud Gateway
0 likes · 3 min read
How Can a Gateway Sustain Million‑Level Concurrency in High‑Traffic Scenarios?
Golang Shines
Golang Shines
Jul 26, 2026 · Backend Development

Building a High‑Concurrency Student Authentication System with Go‑Zero

The article details a production‑grade student verification system built on the Go‑Zero microservice framework, covering business challenges, a layered API/RPC/Model architecture, state‑machine management, AES encryption, dual‑channel OCR failover, event‑driven design with Redis Streams, and a push‑pull WebSocket notification scheme.

OCRWebSocketencryption
0 likes · 13 min read
Building a High‑Concurrency Student Authentication System with Go‑Zero
Java Tech Workshop
Java Tech Workshop
Jul 21, 2026 · Backend Development

A Lighter‑Than‑MQ Async Solution: Spring’s Hidden Transactional Event Feature

The article explains how Spring’s built‑in @Async and TransactionalEventListener mechanisms provide a lightweight, zero‑dependency alternative to external message queues for local asynchronous processing, detailing their advantages, limitations, and production‑grade enhancements such as custom thread pools, dead‑letter persistence, and clustering strategies.

@AsyncJavaSpring
0 likes · 17 min read
A Lighter‑Than‑MQ Async Solution: Spring’s Hidden Transactional Event Feature
webdream
webdream
Jul 18, 2026 · Backend Development

Java Architecture Overview: 7 Key Patterns from Layered to DDD

The article explains why solid architecture matters for Java projects, outlines seven mainstream architectural patterns—including layered, DDD, hexagonal, clean, CQRS, event‑driven, and microkernel—and provides a decision guide to help teams choose the most suitable approach based on complexity, experience, performance, and evolution needs.

CQRSDomain-Driven DesignJava
0 likes · 11 min read
Java Architecture Overview: 7 Key Patterns from Layered to DDD
YiSu Grain
YiSu Grain
Jul 17, 2026 · Fundamentals

Day 25 – Five Classic Software Architecture Styles: Focus on System Organization

This article introduces the five classic software architecture styles—data‑flow, call/return, data‑centric, virtual‑machine, and independent component—explaining their core mechanisms, advantages, drawbacks, real‑world examples, and a five‑step method for selecting the appropriate style in system design and exams.

Rule Enginearchitecture stylesblackboard
0 likes · 28 min read
Day 25 – Five Classic Software Architecture Styles: Focus on System Organization
Ray's Galactic Tech
Ray's Galactic Tech
Jul 15, 2026 · Artificial Intelligence

Scalable Knowledge Base with High‑Concurrency Crawling and Vector Search

The article explains why a production‑grade enterprise knowledge base requires more than just dumping PDFs into a vector store, detailing a distributed, event‑driven architecture with separate collection, processing, retrieval, and governance layers that handle high‑concurrency crawling, real‑time cleaning, versioned indexing, permission filtering, and feedback‑driven updates.

Data PipelineRAGdistributed systems
0 likes · 39 min read
Scalable Knowledge Base with High‑Concurrency Crawling and Vector Search
Architect Chen
Architect Chen
Jul 13, 2026 · Databases

How I/O Multiplexing Gives Redis a 10× Performance Boost

Redis achieves its high speed not only because it is an in‑memory, single‑threaded database with efficient data structures, but primarily thanks to I/O multiplexing, which lets a single thread manage tens of thousands of client connections, dramatically cutting thread‑switch overhead and boosting throughput up to tenfold.

EpollHigh ConcurrencyI/O multiplexing
0 likes · 4 min read
How I/O Multiplexing Gives Redis a 10× Performance Boost
Cloud Architecture
Cloud Architecture
Jul 8, 2026 · Backend Development

High‑Concurrency Order System Architecture: How Redis, MySQL, and Elasticsearch Collaborate Without Overstepping

This article presents a production‑grade, high‑concurrency order system design that separates responsibilities among Redis for traffic control, MySQL as the single source of truth, Kafka for event propagation, and Elasticsearch for search, while detailing state‑machine modeling, outbox patterns, seckill flow, and comprehensive observability and deployment practices.

ElasticsearchHigh ConcurrencyMySQL
0 likes · 31 min read
High‑Concurrency Order System Architecture: How Redis, MySQL, and Elasticsearch Collaborate Without Overstepping
Cloud Architecture
Cloud Architecture
Jun 27, 2026 · Backend Development

Enterprise Messaging System Deep Dive: Core Engine to High‑Concurrency

This guide explains how enterprise messaging systems reliably propagate state changes across distributed services, covering core concepts, outbox patterns, topic/tag modeling, consumer idempotency, dead‑letter handling, high‑concurrency engineering, monitoring, and Kubernetes deployment to build a production‑grade, observable platform.

High ConcurrencyKafkaOutbox
0 likes · 44 min read
Enterprise Messaging System Deep Dive: Core Engine to High‑Concurrency
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jun 25, 2026 · Backend Development

Why Nginx Can Handle Tens of Millions of Requests

The article explains how Nginx’s event‑driven, asynchronous non‑blocking model, master‑worker multi‑process design, efficient I/O multiplexing (epoll/kqueue), and lightweight resource‑control architecture enable it to sustain extremely high concurrency with minimal overhead.

High ConcurrencyI/O multiplexingNginx
0 likes · 5 min read
Why Nginx Can Handle Tens of Millions of Requests
CodeSmart Hoops
CodeSmart Hoops
Jun 3, 2026 · Backend Development

Spring Event-Driven Architecture: Interview Self-Test with Observer Pattern and Decoupling Design

This article provides a comprehensive interview self‑test on Spring's event‑driven mechanism, covering the three core components, synchronous vs asynchronous handling, the role and default implementation of ApplicationEventMulticaster, adapter flow, async configuration options, @TransactionalEventListener phases, exception propagation, @Order ordering, SpEL condition filtering, a comparison with MQ, POJO events, and the listenerCache optimization.

BackendSpELSpring
0 likes · 21 min read
Spring Event-Driven Architecture: Interview Self-Test with Observer Pattern and Decoupling Design
CodeSmart Hoops
CodeSmart Hoops
May 31, 2026 · Backend Development

Hands‑On Unit Testing of Spring’s Full Event‑Driven Architecture

This guide walks through comprehensive unit tests for Spring Boot 3.x / Spring Framework 6.x event‑driven features—covering @EventListener, ApplicationListener, @Order, @Async, TransactionalEventListener, exception propagation, multiple event publishing, POJO events, and a comparison of three asynchronous handling approaches—using JDK 17+, JUnit 5, and Spring Boot Test.

@Async@TransactionalJava
0 likes · 25 min read
Hands‑On Unit Testing of Spring’s Full Event‑Driven Architecture
Cloud Architecture
Cloud Architecture
May 22, 2026 · Operations

Kafka vs Pulsar: Choosing the Right Messaging System for Architecture and Production

Kafka and Pulsar are both mature distributed messaging platforms, but they differ fundamentally in architecture, performance, scalability, and operational complexity; this article analyzes their core designs, benchmarks, engineering trade‑offs, and real‑world scenarios to guide architects in making a reliable technology selection.

KafkaKubernetesPerformance
0 likes · 36 min read
Kafka vs Pulsar: Choosing the Right Messaging System for Architecture and Production
LuTiao Programming
LuTiao Programming
May 20, 2026 · Backend Development

Why Underrated API Architecture Patterns Give Experts Unmatched Scalability

The article analyzes various API architecture patterns—monolithic API, microservice API, API Gateway, BFF, Service Mesh, API Mesh, Strangler Pattern, event‑driven API, and GraphQL Federation—explaining their origins, trade‑offs, hidden costs, and suitability for different team sizes and business scenarios, ultimately showing how the right pattern ensures long‑term system evolution and scalability.

API GatewayAPI architectureBFF
0 likes · 13 min read
Why Underrated API Architecture Patterns Give Experts Unmatched Scalability
Subtle Storm
Subtle Storm
May 19, 2026 · Fundamentals

Essential Classic Software Architecture Styles Every Architect Must Know

The article explains the definition of software architecture styles, enumerates classic styles such as data‑flow (batch and pipeline‑filter), call/return, object‑oriented, layered, independent component (process‑communication and event‑driven), virtual‑machine (interpreter and rule‑based), and repository (database and blackboard), and provides concrete examples and a mnemonic to help remember their characteristics and suitable application scenarios.

Virtual Machinearchitecture stylesdata flow
0 likes · 9 min read
Essential Classic Software Architecture Styles Every Architect Must Know
Cloud Architecture
Cloud Architecture
May 6, 2026 · Backend Development

Why Polling Breaks at Scale and How Spring Boot Webhooks Enable High‑Concurrency Event‑Driven Architecture

The article explains why traditional polling becomes unsustainable under high load, contrasts polling with webhook‑based event delivery, and provides a complete Spring Boot implementation—including outbox pattern, Kafka integration, retry logic, security, observability, and operational best practices—to build a production‑grade, scalable webhook platform.

High ConcurrencyKafkaOutbox
0 likes · 36 min read
Why Polling Breaks at Scale and How Spring Boot Webhooks Enable High‑Concurrency Event‑Driven Architecture
AI Engineer Programming
AI Engineer Programming
Apr 29, 2026 · Fundamentals

Balancing Core Stability and Extensibility: Design and Implementation of pi Agent’s Extension System

The article explains how the pi agent’s extension system resolves the tension between core stability and capability extensibility by using inversion of control, dependency injection, adapter and event‑driven patterns, two‑phase initialization, and concrete Python implementations, while comparing it with other plugin architectures.

AI AgentDependency InjectionPlugin Architecture
0 likes · 26 min read
Balancing Core Stability and Extensibility: Design and Implementation of pi Agent’s Extension System
AI Tech Publishing
AI Tech Publishing
Apr 17, 2026 · Artificial Intelligence

Why Your AI Agent Crashes: 7 Hosting Patterns Compared

The article explains why AI agents fail when deployed with the wrong hosting model, presents a systematic comparison of seven patterns—Cron, Reactive, Daemon, Pipeline, Service, Adaptive, and Mesh—detailing their problem scope, typical scenarios, concrete Python or TypeScript implementations, when to choose each, and the trade‑offs, while warning against the common mistake of over‑engineering from the start.

AI agentsCronMulti-Agent Mesh
0 likes · 21 min read
Why Your AI Agent Crashes: 7 Hosting Patterns Compared
Architect's Tech Stack
Architect's Tech Stack
Apr 10, 2026 · Backend Development

Replace RabbitMQ with Spring Events for Cleaner Order Processing

This article explains how to refactor a monolithic order‑creation method by using Spring's built‑in ApplicationEvent mechanism, separating core logic from side‑effects such as SMS, points, and notifications, and clarifies when to choose Spring events over a message queue.

JavaMQ AlternativeSpring
0 likes · 7 min read
Replace RabbitMQ with Spring Events for Cleaner Order Processing
Java Companion
Java Companion
Apr 7, 2026 · Backend Development

A Lighter‑Than‑MQ Asynchronous Solution: Spring’s Hidden Event‑Driven Feature

The article explains how Spring’s built‑in ApplicationEvent and @EventListener mechanism provides a lightweight, zero‑dependency alternative to external message queues for decoupling logic within the same JVM, covering core components, implementation styles, async execution, transactional listeners, pitfalls, performance comparison, and production best practices.

Best PracticesSpringSpring Boot
0 likes · 23 min read
A Lighter‑Than‑MQ Asynchronous Solution: Spring’s Hidden Event‑Driven Feature
AI Waka
AI Waka
Mar 13, 2026 · Artificial Intelligence

How Event‑Driven AI Agents Eliminate Manual Skill Calls

This article explains how event‑driven AI agents replace static, manually‑triggered skill lists with deterministic, context‑aware switches, detailing the shortcomings of static references, the architecture of a skill‑switch engine, file‑based activation, additional activation modes, and the resulting productivity gains.

AI agentsSkill Activationautomation
0 likes · 10 min read
How Event‑Driven AI Agents Eliminate Manual Skill Calls
phodal
phodal
Feb 24, 2026 · Artificial Intelligence

How Routa Turns Multi‑Agent AI Coding into an Engineered Collaboration Framework

Routa is an engineering‑focused multi‑agent framework that separates tasks, state, events, and execution into controllable modules, enabling open‑ecosystem AI coding agents to collaborate through structured specifications, event‑driven coordination, and verifiable tool interfaces rather than fragile prompt stitching.

AI collaborationAgent CoordinationMulti-agent
0 likes · 12 min read
How Routa Turns Multi‑Agent AI Coding into an Engineered Collaboration Framework
Huolala Tech
Huolala Tech
Jan 30, 2026 · Backend Development

How HuoLala Built a Scalable Todo Center to Handle Billions of Requests

To support HuoLala’s massive driver workflow, the team designed a platform‑wide Todo Center that standardizes tasks, optimizes performance, decouples services, and ensures strong and eventual consistency, while employing traffic‑shaping, asynchronous processing, and robust monitoring to sustain billions of daily queries with low latency.

System Designevent-drivenmicroservices
0 likes · 14 min read
How HuoLala Built a Scalable Todo Center to Handle Billions of Requests
Data STUDIO
Data STUDIO
Jan 29, 2026 · Fundamentals

10 Python Design Patterns to Eliminate Spaghetti Code and Build Maintainable Projects

The article explains why architecture matters, introduces ten essential Python design patterns—such as Dependency Injection, Strategy, Builder, Event‑Driven, Repository, Mapper, Pipeline, Command, Specification, and Plugin Registry—with concrete code examples and practical advice to transform messy scripts into clean, scalable applications.

Builder PatternDependency InjectionDesign Patterns
0 likes · 44 min read
10 Python Design Patterns to Eliminate Spaghetti Code and Build Maintainable Projects
php Courses
php Courses
Jan 19, 2026 · Backend Development

How to Build Smart Self‑Aware Data Expiration in PHP

This article explains why fixed TTLs are insufficient for modern PHP applications and presents several intelligent cache‑expiration techniques—including usage‑based adaptive TTLs, content‑aware policies, event‑driven invalidation, multi‑stage lifecycles, and predictive machine‑learning models—along with practical implementation tips and monitoring tools.

PHPadaptive ttldata expiration
0 likes · 13 min read
How to Build Smart Self‑Aware Data Expiration in PHP
Code Wrench
Code Wrench
Jan 6, 2026 · Backend Development

When to Move from Hooks to Events: A Practical Evolution Guide

This article examines how business scale and system boundaries evolve, explaining when hooks are optimal, why they become problematic, and how to transition smoothly to event‑driven architectures with concrete examples, signals, and a step‑by‑step migration path.

HooksSoftware EngineeringSystem Design
0 likes · 9 min read
When to Move from Hooks to Events: A Practical Evolution Guide
Ray's Galactic Tech
Ray's Galactic Tech
Jan 5, 2026 · Backend Development

How We Replaced HTTP Polling with MQTT for Real‑Time, Low‑Latency Messaging

This article recounts the migration from a simple HTTP polling approach to an MQTT‑based real‑time communication architecture, detailing the motivations, technical comparisons, implementation steps, performance gains, operational challenges, and future directions for scalable event‑driven systems.

MQTTReal-time messagingbackend architecture
0 likes · 8 min read
How We Replaced HTTP Polling with MQTT for Real‑Time, Low‑Latency Messaging
Architect
Architect
Dec 21, 2025 · Backend Development

Mastering Spring Event Listeners: From Coffee Shop Analogy to High‑Throughput Architecture

This article uses a coffee‑shop analogy to explain Spring event listeners, demonstrates how to define, publish, and handle events, presents three techniques for handling massive traffic, shares real‑world incidents and lessons, compares listeners with MQ, and offers performance‑tuning tips and best‑practice rules.

Best PracticesJavaPerformance
0 likes · 10 min read
Mastering Spring Event Listeners: From Coffee Shop Analogy to High‑Throughput Architecture
Tech Freedom Circle
Tech Freedom Circle
Dec 13, 2025 · Backend Development

What’s Wrong with Delayed Double Delete? How Top Tech Companies Elegantly Avoid It

The article explains the delayed double‑delete cache‑invalidation pattern, its four major drawbacks in high‑concurrency environments, and presents four production‑grade alternatives—event‑driven binlog updates, distributed‑lock with versioning, write‑through proxy layers, and logical‑delete with async cleanup—used by leading Chinese internet firms to achieve reliable data consistency.

CachingRedisdatabase consistency
0 likes · 21 min read
What’s Wrong with Delayed Double Delete? How Top Tech Companies Elegantly Avoid It
LuTiao Programming
LuTiao Programming
Dec 12, 2025 · Backend Development

20 Must‑Know Architecture Patterns for Java Engineers Before 2026

This article enumerates twenty essential Java and Spring Boot architecture patterns—from monoliths and layered designs to microservices, event‑driven, cloud‑native, and AI‑driven systems—explaining their structure, typical use cases, advantages, drawbacks, and when to choose each for building stable, fast, and scalable applications.

Spring Bootarchitecturecloud-native
0 likes · 11 min read
20 Must‑Know Architecture Patterns for Java Engineers Before 2026
Deepin Linux
Deepin Linux
Nov 27, 2025 · Backend Development

How epoll Scales to Millions of Connections Using Red‑Black Trees and Ready Lists

This article explains the inner workings of Linux's epoll mechanism, detailing how red‑black trees manage registered file descriptors and how a ready‑list delivers events in O(1) time, covering core APIs, data structures, insertion‑deletion logic, and the full kernel‑space to user‑space flow.

EpollLinuxRed-Black Tree
0 likes · 54 min read
How epoll Scales to Millions of Connections Using Red‑Black Trees and Ready Lists
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 18, 2025 · Backend Development

Understanding Nginx’s Core Concurrency Model: Multi‑Process, Event‑Driven, and Non‑Blocking I/O

This article explains Nginx’s core concurrency mechanisms—including its multi‑process architecture, event‑driven model, I/O multiplexing techniques like epoll, and non‑blocking I/O—highlighting how they provide high stability, low resource consumption, and excellent performance for high‑traffic network services.

BackendConcurrencyIO Multiplexing
0 likes · 5 min read
Understanding Nginx’s Core Concurrency Model: Multi‑Process, Event‑Driven, and Non‑Blocking I/O
Deepin Linux
Deepin Linux
Nov 16, 2025 · Fundamentals

Unlock Asynchronous Power: Master Callback Functions in 3 Minutes

This article explains what callback functions are, how they enable asynchronous programming across languages, demonstrates their implementation with JavaScript, C/C++, Python and HTML examples, and discusses practical use‑cases, advantages, pitfalls like callback hell, and modern alternatives such as Promises and async/await.

C++CallbackJavaScript
0 likes · 23 min read
Unlock Asynchronous Power: Master Callback Functions in 3 Minutes
Liangxu Linux
Liangxu Linux
Oct 30, 2025 · Fundamentals

Boost Embedded Performance with the Lightweight C Event Library lwevt

This article introduces lwevt, a lightweight C event‑management library for embedded systems, covering its design goals, key features, X‑Macro‑based type definitions, thread‑safety considerations, and step‑by‑step usage examples with full source code snippets.

C++X-Macroevent-driven
0 likes · 6 min read
Boost Embedded Performance with the Lightweight C Event Library lwevt
Deepin Linux
Deepin Linux
Sep 12, 2025 · Backend Development

Mastering Linux I/O Multiplexing: select, poll, and epoll Explained with Real Code

This article explains the concepts, advantages, limitations, and practical usage of Linux I/O multiplexing mechanisms—select, poll, and epoll—through analogies, detailed explanations, code examples, and common interview questions, helping developers choose the right tool for high‑concurrency network programming.

EpollIO MultiplexingLinux
0 likes · 35 min read
Mastering Linux I/O Multiplexing: select, poll, and epoll Explained with Real Code
Su San Talks Tech
Su San Talks Tech
Sep 11, 2025 · Databases

Why Redis Handles Millions of Requests: Deep Dive into Its High‑Performance Architecture

This article explains how Redis achieves ultra‑high concurrency by combining a single‑threaded event‑driven core, highly optimized in‑memory data structures, efficient I/O multiplexing, smart memory management, asynchronous persistence, and scalable clustering, allowing it to comfortably serve hundreds of thousands of simultaneous requests.

ClusteringHigh ConcurrencyMemory Optimization
0 likes · 16 min read
Why Redis Handles Millions of Requests: Deep Dive into Its High‑Performance Architecture
dbaplus Community
dbaplus Community
Sep 10, 2025 · Databases

Inside Redis: How Commands Are Processed by Its Event‑Driven Engine

Redis, the high‑performance in‑memory key‑value store, uses a single‑threaded event‑driven architecture that handles client connections, command parsing, execution, and reply transmission; this article explains its deployment modes, core modules, and step‑by‑step command processing flow, including code snippets and key data structures.

BackendCommand ExecutionRedis
0 likes · 14 min read
Inside Redis: How Commands Are Processed by Its Event‑Driven Engine
IT Architects Alliance
IT Architects Alliance
Sep 10, 2025 · Cloud Native

How AI, Cloud‑Native, and Platform Engineering Redefine System Architecture in 2024

Amid rapid AI breakthroughs, mature cloud‑native infrastructure, and rising edge computing, architects must adopt platform engineering, event‑driven and composable architectures, and AI‑native designs, while evolving technical and soft skills to meet escalating business complexity and guide technology selection over the next five years.

AI architecturecloud-nativeedge computing
0 likes · 12 min read
How AI, Cloud‑Native, and Platform Engineering Redefine System Architecture in 2024
Architect Chen
Architect Chen
Sep 4, 2025 · Backend Development

How Nginx Achieves High Concurrency with Event‑Driven and Non‑Blocking I/O

This article explains Nginx's event‑driven architecture, asynchronous non‑blocking I/O, and master‑worker multi‑process model, showing how these techniques eliminate waiting, maximize resource utilization, and enable the server to handle massive concurrent connections efficiently.

BackendHigh ConcurrencyNginx
0 likes · 4 min read
How Nginx Achieves High Concurrency with Event‑Driven and Non‑Blocking I/O
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Sep 2, 2025 · Backend Development

Why Nginx’s Master‑Worker Architecture Powers High‑Performance Web Services

This article explains how Nginx achieves high‑performance web serving through its master‑worker multi‑process model, event‑driven mechanism, and asynchronous non‑blocking I/O, detailing each component’s role, configuration tips, and the reasons behind its superior concurrency handling.

High Performanceasynchronous IOevent-driven
0 likes · 5 min read
Why Nginx’s Master‑Worker Architecture Powers High‑Performance Web Services
Architect
Architect
Aug 22, 2025 · Databases

How Redis Executes Commands: Deep Dive into Its Architecture and Event Loop

This article explains how Redis, an open‑source in‑memory key‑value store, processes a client command from network reception through its event‑driven engine, command parsing, execution, and reply transmission, revealing the internal mechanisms behind its high performance and scalability.

Command ExecutionIn-Memory Databasearchitecture
0 likes · 14 min read
How Redis Executes Commands: Deep Dive into Its Architecture and Event Loop
mikechen
mikechen
Aug 14, 2025 · Backend Development

How Nginx Handles High Concurrency: Event‑Driven Model, Async I/O, and Tuning Tips

This article explains how Nginx achieves high‑concurrency handling through its event‑driven architecture, asynchronous non‑blocking I/O, modular design, and key configuration optimizations such as worker processes, connections, keepalive timeout, and sendfile, providing practical code examples and performance tips.

Backendasync I/Oevent-driven
0 likes · 6 min read
How Nginx Handles High Concurrency: Event‑Driven Model, Async I/O, and Tuning Tips
Open Source Tech Hub
Open Source Tech Hub
Jul 16, 2025 · Backend Development

Why epoll Beats select and poll: A Deep Dive into Linux’s High‑Performance I/O Multiplexing

This article explains the limitations of traditional I/O models such as blocking I/O, non‑blocking I/O, select and poll, introduces epoll’s design, core data structures, operation modes, system‑call interface, and provides practical code examples and optimisation tips for high‑concurrency network servers.

EpollI/O multiplexingLinux
0 likes · 45 min read
Why epoll Beats select and poll: A Deep Dive into Linux’s High‑Performance I/O Multiplexing
Big Data Technology Tribe
Big Data Technology Tribe
Jun 13, 2025 · Fundamentals

Mastering Software Architecture: 6 Essential Patterns Explained

This article explores six core software architecture patterns—Monolithic, Microservices, MVC, Controller‑Worker, Event‑Driven, and Layered—detailing their structures, typical use cases, advantages, and drawbacks to help developers choose the right design for scalable, maintainable applications.

Design PatternsMVCevent-driven
0 likes · 12 min read
Mastering Software Architecture: 6 Essential Patterns Explained
DeWu Technology
DeWu Technology
Jun 12, 2025 · Backend Development

How Componentized Architecture Transforms Activity Systems: From OOP to Rule Engines

This article explores how DeWu's community activity platform evolved from ad‑hoc implementations to a componentized, event‑driven backend using OOP principles, modular design, rule engines, and observer‑hook mechanisms, while also outlining future AI‑driven optimizations and system‑wide standardization.

ComponentizationRule Enginebackend architecture
0 likes · 20 min read
How Componentized Architecture Transforms Activity Systems: From OOP to Rule Engines
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jun 6, 2025 · Backend Development

How to Split Services Effectively: Principles, Real Cases, and Domain Modeling

This article explains why overly fine‑grained service splitting hurts performance and debugging, shows best‑practice granularity aligned with team size, introduces evolutionary splitting based on model responsibilities, and walks through real‑world case studies, domain‑driven design concepts, architectural patterns such as hexagonal, CQRS, and event‑driven designs, and practical steps for building a robust service‑oriented system.

CQRSDomain-Driven DesignService Splitting
0 likes · 6 min read
How to Split Services Effectively: Principles, Real Cases, and Domain Modeling
Deepin Linux
Deepin Linux
Apr 25, 2025 · Backend Development

Understanding epoll: Linux I/O Multiplexing, Design, and Practical Usage

This article explains the limitations of traditional I/O models, introduces epoll as a high‑performance Linux I/O multiplexing mechanism, details its design principles, API usage, kernel data structures, and provides practical coding examples and optimization tips for building scalable backend services.

EpollHigh ConcurrencyI/O multiplexing
0 likes · 41 min read
Understanding epoll: Linux I/O Multiplexing, Design, and Practical Usage
Deepin Linux
Deepin Linux
Apr 18, 2025 · Backend Development

Deep Dive into Linux epoll: Design, Implementation, and Performance

epoll is a high‑performance Linux I/O multiplexing mechanism that replaces select/poll by using an event‑driven design with a red‑black tree and ready list, supporting edge‑ and level‑triggered modes, efficient data transfer via mmap, and providing superior scalability for high‑concurrency network applications.

EpollHigh ConcurrencyI/O multiplexing
0 likes · 85 min read
Deep Dive into Linux epoll: Design, Implementation, and Performance
Java Captain
Java Captain
Apr 16, 2025 · Backend Development

Design and Implementation of a Generic Asynchronous Processing SDK for Spring Applications

This article describes a generic asynchronous processing SDK built on Spring that leverages transaction events, AOP, and a combination of Kafka, XXL‑Job, and MySQL to provide non‑intrusive, reliable, and idempotent async execution with configurable strategies, security levels, and monitoring dashboards.

asynchronousevent-driventransaction
0 likes · 11 min read
Design and Implementation of a Generic Asynchronous Processing SDK for Spring Applications
Huolala Tech
Huolala Tech
Apr 11, 2025 · Operations

How Huolala’s Process Canvas Powers Scalable Marketing Automation

The article details Huolala’s Process Canvas, a data‑driven, end‑to‑end marketing automation platform that unifies user‑driver lifecycle management, multi‑channel reward distribution, and flexible strategy composition, describing its architecture, core trigger‑condition‑action model, challenges faced, and solutions implemented to ensure scalable, reliable operations.

Marketing AutomationStrategy Engineevent-driven
0 likes · 11 min read
How Huolala’s Process Canvas Powers Scalable Marketing Automation
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Feb 20, 2025 · Backend Development

How Nginx Handles Millions of Requests: Event‑Driven Model and Performance Tuning

This article explains how Nginx achieves high concurrency through its event‑driven architecture, asynchronous non‑blocking I/O, epoll‑based I/O multiplexing, and practical caching configurations that dramatically reduce memory usage and improve response speed in high‑traffic scenarios.

Cachingasynchronous I/Oevent-driven
0 likes · 5 min read
How Nginx Handles Millions of Requests: Event‑Driven Model and Performance Tuning
37 Interactive Technology Team
37 Interactive Technology Team
Feb 19, 2025 · Fundamentals

Domain-Driven Design (DDD) and Microservice Architecture: Concepts, Patterns, and Refactoring Strategies

The article explains how Domain‑Driven Design combined with microservice architecture can restructure a monolithic transaction system by defining bounded contexts, applying patterns such as layered architecture, CQRS and event‑driven communication, and refactoring domains to improve maintainability, scalability, and business clarity.

CQRSDomain-Driven Designbounded-context
0 likes · 9 min read
Domain-Driven Design (DDD) and Microservice Architecture: Concepts, Patterns, and Refactoring Strategies
Liangxu Linux
Liangxu Linux
Dec 29, 2024 · Backend Development

Master epoll: Boost Linux Server Performance with Event‑Driven I/O

This article explains how epoll works as Linux's high‑performance I/O multiplexer, compares it with select and poll, details its three‑step workflow, data structures, code examples, and the trade‑offs between level‑triggered and edge‑triggered modes for building scalable network servers.

ETEpollHigh Concurrency
0 likes · 22 min read
Master epoll: Boost Linux Server Performance with Event‑Driven I/O
JavaEdge
JavaEdge
Dec 16, 2024 · Backend Development

Why Nginx’s Event‑Driven Architecture Beats Traditional Thread‑Per‑Request Servers

Unlike traditional one‑request‑per‑process servers, Nginx uses a fixed number of worker processes with a non‑blocking, event‑driven model that reduces context switches, leverages epoll/kqueue, and handles thousands of connections efficiently, making it the preferred high‑performance web server.

Performanceevent-drivennon-blocking I/O
0 likes · 8 min read
Why Nginx’s Event‑Driven Architecture Beats Traditional Thread‑Per‑Request Servers
Alibaba Cloud Infrastructure
Alibaba Cloud Infrastructure
Dec 16, 2024 · Cloud Native

Understanding Event‑Driven Architecture with Knative Eventing, Serverless and EventBridge

This article explains the fundamentals of event‑driven architecture, introduces Knative Eventing as a cloud‑native serverless framework, details its broker/trigger model, event sources, orchestration patterns such as Sequence and Parallel, and shows how to integrate it with Alibaba Cloud EventBridge while comparing it to KEDA.

EventBridgeKEDAServerless
0 likes · 16 min read
Understanding Event‑Driven Architecture with Knative Eventing, Serverless and EventBridge
Programmer DD
Programmer DD
Dec 5, 2024 · Backend Development

Key Microservice Patterns: Service Discovery, API Gateways, Event‑Driven Architecture

This article consolidates a series of ByteMonk videos covering essential microservice architecture patterns—including service registration and discovery with Eureka, API gateway design, event‑driven architecture, service mesh, aggregator pattern, per‑service databases, bulkhead and strangler patterns, and monolith decomposition case studies—providing practical insights for building scalable, resilient systems.

API Gatewayarchitecture patternsevent-driven
0 likes · 7 min read
Key Microservice Patterns: Service Discovery, API Gateways, Event‑Driven Architecture
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Dec 4, 2024 · Backend Development

How Nginx Achieves Million-Connection Concurrency: Architecture and Optimization Techniques

This article explains how Nginx uses an event‑driven, asynchronous non‑blocking I/O model together with epoll/kqueue and various optimization strategies such as keep‑alive, caching, efficient data structures and load balancing to handle millions of concurrent connections in large‑scale internet architectures.

EpollHigh Concurrencyasynchronous I/O
0 likes · 5 min read
How Nginx Achieves Million-Connection Concurrency: Architecture and Optimization Techniques
Alibaba Cloud Native
Alibaba Cloud Native
Oct 19, 2024 · Cloud Native

How ApsaraMQ’s Serverless Architecture Powers AI with Event‑Driven Messaging

The talk outlines ApsaraMQ’s journey to a fully serverless, cloud‑native messaging platform, detailing its compute‑storage separation, stateless proxy functions, RDMA‑enhanced performance, elastic scaling mechanisms, and how its event‑driven architecture empowers real‑time AI applications through seamless data vectorization.

AI IntegrationRDMAServerless
0 likes · 19 min read
How ApsaraMQ’s Serverless Architecture Powers AI with Event‑Driven Messaging
Alibaba Cloud Developer
Alibaba Cloud Developer
Oct 14, 2024 · Backend Development

How to Build an Event-Driven Strategy Center for Full-Chain Marketing

This article explains the design and implementation of an event‑driven strategy‑center system for full‑chain marketing, covering architecture choices, process flow, domain modeling, strategy templates, code examples, and idempotency handling to achieve scalable and extensible marketing workflows.

Strategy Patternarchitectureevent-driven
0 likes · 11 min read
How to Build an Event-Driven Strategy Center for Full-Chain Marketing
IT Architects Alliance
IT Architects Alliance
Sep 29, 2024 · Backend Development

Event-Driven Architecture: Core Concepts, Design Principles, and Practical Practices

This article explains the fundamentals of Event‑Driven Architecture, covering its core components, design principles such as event granularity and immutability, practical implementation steps, common use cases, and the challenges developers face when building loosely coupled, high‑response distributed systems.

CQRSevent-drivenevent-sourcing
0 likes · 9 min read
Event-Driven Architecture: Core Concepts, Design Principles, and Practical Practices
Deepin Linux
Deepin Linux
Sep 9, 2024 · Backend Development

Understanding epoll: Level‑Triggered vs Edge‑Triggered Modes and Kernel Implementation

This article explains the concepts of level‑triggered (LT) and edge‑triggered (ET) event notification in Linux epoll, describes epoll's core data structures such as the red‑black tree and ready‑list, details the three main APIs (epoll_create, epoll_ctl, epoll_wait), and examines the locking and internal kernel mechanisms that enable efficient I/O multiplexing.

EpollI/O multiplexingLinux kernel
0 likes · 69 min read
Understanding epoll: Level‑Triggered vs Edge‑Triggered Modes and Kernel Implementation
58 Tech
58 Tech
Aug 30, 2024 · Backend Development

Design and Implementation of 58.com Invitation Business System Architecture

This article details the architecture, core component design, and implementation techniques of 58.com’s invitation business system, covering background, technical challenges, modular backend design, event‑driven services, rule‑engine filtering, protocol conversion, and process orchestration to improve scalability, efficiency, and reusability.

BackendRecruitmentRule Engine
0 likes · 18 min read
Design and Implementation of 58.com Invitation Business System Architecture
Open Source Tech Hub
Open Source Tech Hub
Aug 25, 2024 · Backend Development

What Is Socket.IO? A Deep Dive into Features, Versions, and Cross‑Language Implementations

This article explains Socket.IO’s low‑latency, bi‑directional, event‑driven communication model, outlines version differences, lists server and client language implementations, clarifies common misconceptions, details core features such as fallback, reconnection and broadcasting, and provides a complete PHP server‑client example with custom events and workerStart handling.

Socket.IOWebSocketevent-driven
0 likes · 13 min read
What Is Socket.IO? A Deep Dive into Features, Versions, and Cross‑Language Implementations
Open Source Tech Hub
Open Source Tech Hub
Aug 8, 2024 · Backend Development

Mastering libevent: Install, Test, and Build High‑Performance Network Apps

This guide introduces libevent, a lightweight C library for high‑performance event notification, explains its core concepts and features, provides step‑by‑step installation and compilation instructions, demonstrates sample programs like hello‑world and http‑server, and outlines common use cases in networking.

C libraryHigh Performancecross-platform
0 likes · 12 min read
Mastering libevent: Install, Test, and Build High‑Performance Network Apps
Top Architecture Tech Stack
Top Architecture Tech Stack
Jul 4, 2024 · Backend Development

Service Communication in Microservices: RPC vs Event‑Driven, Coupling Types, and Design Patterns

The article explains how microservice architectures handle inter‑service calls using RPC or event‑driven approaches, analyzes different coupling types, compares event notification with event sourcing, and offers practical guidance on API gateways, service composition, and when to choose each communication style.

API GatewayEvent SourcingRPC
0 likes · 20 min read
Service Communication in Microservices: RPC vs Event‑Driven, Coupling Types, and Design Patterns
Deepin Linux
Deepin Linux
May 17, 2024 · Fundamentals

Comprehensive Overview of epoll Data Structures and Implementation in Linux

This article systematically explains epoll's core data structures—including a red‑black tree and a doubly linked ready list—its three main APIs, the kernel implementation details, thread‑safety mechanisms, ET vs. LT behavior, and how it improves over select/poll for high‑concurrency network programming.

EpollI/O multiplexingLinux kernel
0 likes · 68 min read
Comprehensive Overview of epoll Data Structures and Implementation in Linux
Code Ape Tech Column
Code Ape Tech Column
Apr 19, 2024 · Backend Development

Understanding Service Coupling: RPC vs Event‑Driven Approaches in Microservices

The article explains the different types of coupling in microservice architectures, compares RPC and event‑driven communication—including event notification and event sourcing—discusses their trade‑offs, and offers practical guidance on choosing and combining these approaches for scalable backend systems.

API Gatewayevent-drivenmicroservices
0 likes · 20 min read
Understanding Service Coupling: RPC vs Event‑Driven Approaches in Microservices
Liangxu Linux
Liangxu Linux
Apr 15, 2024 · Backend Development

How Nginx Handles Millions of Concurrent Connections: Architecture Explained

This article explains why Nginx is renowned for high performance and details the architectural components—master and worker processes, event‑driven non‑blocking I/O, memory pooling, load‑balancing, caching, modular design, and proxy mechanisms—that enable it to sustain millions of simultaneous connections.

CachingHigh ConcurrencyNginx
0 likes · 12 min read
How Nginx Handles Millions of Concurrent Connections: Architecture Explained
Architects Research Society
Architects Research Society
Feb 14, 2024 · Fundamentals

Overview of Modern Application Architecture Trends and Principles

The article outlines emerging forces such as cloud, mobile, social, and big data that drive modern application architecture, advocates moving beyond traditional three‑tier designs, and recommends adopting service‑oriented, microservice, event‑driven, and open‑standard approaches while considering paradigms, models, and organizational structures.

Cloud ComputingSOAapplication architecture
0 likes · 11 min read
Overview of Modern Application Architecture Trends and Principles
php Courses
php Courses
Nov 23, 2023 · Backend Development

Getting Started with Asynchronous PHP Programming Using Swoole

This tutorial introduces Swoole, a powerful PHP extension for event‑driven, non‑blocking programming, guiding readers through prerequisites, environment setup, event‑loop concepts, building a simple asynchronous HTTP server, and performance comparison with traditional synchronous scripts, demonstrating how to create high‑performance backend applications.

PHPSwooleevent-driven
0 likes · 6 min read
Getting Started with Asynchronous PHP Programming Using Swoole
Alibaba Cloud Native
Alibaba Cloud Native
Nov 8, 2023 · Cloud Native

How Apache RocketMQ Became a Cloud‑Native Unified Messaging Engine

The article outlines Apache RocketMQ's evolution from a traditional message queue to a cloud‑native, serverless‑ready unified engine that handles messaging, events, and streams, detailing its architectural milestones, edge‑cloud integration, and the new serverless‑focused features introduced in version 5.0.

Apache RocketMQIoTServerless
0 likes · 28 min read
How Apache RocketMQ Became a Cloud‑Native Unified Messaging Engine
Code Ape Tech Column
Code Ape Tech Column
Oct 29, 2023 · Backend Development

Understanding Service Coupling and Communication: RPC vs Event‑Driven in Microservices

This article explains the different types of coupling in microservice architectures, compares RPC and event‑driven communication methods, discusses event notification and event sourcing, and offers practical guidance on choosing and combining these approaches to reduce tight coupling while maintaining system flexibility.

RPCbackend architectureevent-driven
0 likes · 20 min read
Understanding Service Coupling and Communication: RPC vs Event‑Driven in Microservices
ITPUB
ITPUB
Oct 28, 2023 · Databases

Why Is Single‑Threaded Redis So Fast? Uncover the Secrets

This article explains why Redis, despite being described as single‑threaded, achieves extremely high performance by using a single thread for network I/O and command execution, avoiding multithreading overhead, and leveraging efficient in‑memory data structures together with an event‑driven multiplexing I/O model.

I/O multiplexingPerformanceRedis
0 likes · 12 min read
Why Is Single‑Threaded Redis So Fast? Uncover the Secrets
MoonWebTeam
MoonWebTeam
Aug 23, 2023 · Frontend Development

Unlocking Flexibility: How Microkernel Architecture Powers Modern Front‑End Plugin Systems

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.

MicrokernelPlugin Architecturecode modularity
0 likes · 32 min read
Unlocking Flexibility: How Microkernel Architecture Powers Modern Front‑End Plugin Systems
Bilibili Tech
Bilibili Tech
Aug 11, 2023 · Backend Development

Designing a High‑Performance Asynchronous Event System for Bilibili’s Like Service

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.

BackendCQRSKafka
0 likes · 21 min read
Designing a High‑Performance Asynchronous Event System for Bilibili’s Like Service
Liangxu Linux
Liangxu Linux
Jul 30, 2023 · Fundamentals

How Event‑Driven State Machines Power Embedded Systems: From ISR to Message Queues

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.

ISRembedded systemsevent-driven
0 likes · 33 min read
How Event‑Driven State Machines Power Embedded Systems: From ISR to Message Queues
Architects Research Society
Architects Research Society
Jun 20, 2023 · Backend Development

Designing Microservice Architecture: Patterns, Principles, and Best Practices

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.

API GatewayCQRSDesign Patterns
0 likes · 24 min read
Designing Microservice Architecture: Patterns, Principles, and Best Practices