BestHub
Sign in
Tagged articles
223 articles
Page 2 of 3
Tencent Cloud Developer
Tencent Cloud Developer
Mar 29, 2022 · Fundamentals

Deep Dive into the Linux epoll Mechanism and Its Kernel Implementation

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.

CEvent-drivenIO Multiplexing
0 likes · 24 min read
Deep Dive into the Linux epoll Mechanism and Its Kernel Implementation
Top Architect
Top Architect
Mar 5, 2022 · Databases

Understanding Redis’s Single‑Threaded Model and File Event Handler (FEH)

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.

Event-drivenI/O MultiplexingSingle‑threaded
0 likes · 9 min read
Understanding Redis’s Single‑Threaded Model and File Event Handler (FEH)
MaGe Linux Operations
MaGe Linux Operations
Jan 1, 2022 · Backend Development

Mastering Asynchronous Programming: From Sync/Async Basics to I/O Models

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.

Event-drivenI/O ModelsPython
0 likes · 12 min read
Mastering Asynchronous Programming: From Sync/Async Basics to I/O Models
Architect
Architect
Dec 30, 2021 · Backend Development

Avoiding the Distributed Monolith Trap: Combining Command and Event Patterns in Microservice Architecture

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.

Command PatternEvent-drivenMicroservices
0 likes · 11 min read
Avoiding the Distributed Monolith Trap: Combining Command and Event Patterns in Microservice Architecture
Architects' Tech Alliance
Architects' Tech Alliance
Nov 29, 2021 · Fundamentals

Common Software Architecture Patterns and Their Characteristics

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.

Design PatternsEvent-drivenMVC
0 likes · 10 min read
Common Software Architecture Patterns and Their Characteristics
Python Programming Learning Circle
Python Programming Learning Circle
Nov 25, 2021 · Backend Development

Understanding Asynchronous Programming, I/O Models, and Event‑Driven Architecture in Python

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.

Event-drivenI/O ModelsPython
0 likes · 9 min read
Understanding Asynchronous Programming, I/O Models, and Event‑Driven Architecture in Python
Alibaba Terminal Technology
Alibaba Terminal Technology
Oct 15, 2021 · Mobile Development

How Xianyu Built a High‑Performance Stream‑Based Page Container in Flutter

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.

Event-drivenFlutterMVVM
0 likes · 14 min read
How Xianyu Built a High‑Performance Stream‑Based Page Container in Flutter
21CTO
21CTO
Oct 13, 2021 · Backend Development

When to Adopt CQRS? Balancing Read/Write Models for Scalable Backend Systems

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.

Backend ArchitectureCQRSEvent-driven
0 likes · 11 min read
When to Adopt CQRS? Balancing Read/Write Models for Scalable Backend Systems
TAL Education Technology
TAL Education Technology
Aug 5, 2021 · Backend Development

Understanding epoll Programming and Its Use in Redis Server

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.

CEvent-drivenNetwork programming
0 likes · 13 min read
Understanding epoll Programming and Its Use in Redis Server
IT Architects Alliance
IT Architects Alliance
Jul 31, 2021 · Fundamentals

Common Software Architecture Patterns and Their Considerations

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.

Design PatternsEvent-drivenMicroservices
0 likes · 14 min read
Common Software Architecture Patterns and Their Considerations
Architects Research Society
Architects Research Society
Jul 24, 2021 · Fundamentals

Overview of Application Architecture and Moving Beyond Traditional Three‑Tier Assumptions

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.

Event-drivenSOAapplication architecture
0 likes · 12 min read
Overview of Application Architecture and Moving Beyond Traditional Three‑Tier Assumptions
Liangxu Linux
Liangxu Linux
Jul 17, 2021 · Operations

Mastering Linux epoll: How IO Multiplexing Powers High‑Performance Servers

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.

Event-drivenIO Multiplexingepoll
0 likes · 17 min read
Mastering Linux epoll: How IO Multiplexing Powers High‑Performance Servers
Baidu Geek Talk
Baidu Geek Talk
Jul 14, 2021 · Backend Development

Understanding Nginx Architecture, Process Model, and Module Design

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.

Backend DevelopmentEvent-drivenNGINX
0 likes · 18 min read
Understanding Nginx Architecture, Process Model, and Module Design
Java High-Performance Architecture
Java High-Performance Architecture
Jul 14, 2021 · Backend Development

When to Choose RPC vs Event‑Driven: Decoding Service Coupling in Microservices

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.

Event-drivenRPCarchitecture
0 likes · 20 min read
When to Choose RPC vs Event‑Driven: Decoding Service Coupling in Microservices
Architecture Digest
Architecture Digest
Jul 8, 2021 · Backend Development

Understanding Service Calls in Microservice Architecture: RPC vs Event‑Driven, Coupling Types, and Design Strategies

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.

Event-drivenRPCservice coupling
0 likes · 21 min read
Understanding Service Calls in Microservice Architecture: RPC vs Event‑Driven, Coupling Types, and Design Strategies
Sohu Tech Products
Sohu Tech Products
Jul 7, 2021 · Backend Development

Understanding Linux epoll: IO Multiplexing, Kernel Mechanisms, and Efficient Event Handling

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.

Event-drivenIO MultiplexingLinux kernel
0 likes · 16 min read
Understanding Linux epoll: IO Multiplexing, Kernel Mechanisms, and Efficient Event Handling
IT Architects Alliance
IT Architects Alliance
Jun 27, 2021 · Backend Development

Why Nginx’s Modular, Event‑Driven Architecture Powers High‑Performance Servers

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.

BackendEvent-drivenNGINX
0 likes · 10 min read
Why Nginx’s Modular, Event‑Driven Architecture Powers High‑Performance Servers
Youzan Coder
Youzan Coder
Jun 25, 2021 · Operations

Building an Event-Driven Automated Operations Platform (Whale)

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.

DevOpsEvent-drivenOperations Automation
0 likes · 7 min read
Building an Event-Driven Automated Operations Platform (Whale)
Architect
Architect
Jun 24, 2021 · Backend Development

Nginx Architecture Overview: Modular Design, Event‑Driven Model, Multi‑Stage Asynchronous Processing, and Master‑Worker Process Management

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.

BackendEvent-drivenNGINX
0 likes · 10 min read
Nginx Architecture Overview: Modular Design, Event‑Driven Model, Multi‑Stage Asynchronous Processing, and Master‑Worker Process Management
Top Architect
Top Architect
Jun 14, 2021 · Backend Development

Microservice Communication: RPC vs Event‑Driven, Event Sourcing, and Design Strategies

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.

API-gatewayDDDEvent-driven
0 likes · 19 min read
Microservice Communication: RPC vs Event‑Driven, Event Sourcing, and Design Strategies
IT Architects Alliance
IT Architects Alliance
Jun 14, 2021 · Backend Development

When Should You Choose RPC vs Event‑Driven in Microservices?

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.

Event SourcingEvent-drivenMicroservices
0 likes · 21 min read
When Should You Choose RPC vs Event‑Driven in Microservices?
Zhongtong Tech
Zhongtong Tech
May 28, 2021 · Operations

Why Locust Is the Python Powerhouse for Load Testing: Features, Tips, and Real‑World Insights

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.

Distributed TestingEvent-drivenLoad Testing
0 likes · 10 min read
Why Locust Is the Python Powerhouse for Load Testing: Features, Tips, and Real‑World Insights
DataFunTalk
DataFunTalk
May 18, 2021 · Big Data

Evolution and Architecture of Beike Real-Time Computing Platform

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.

Data WarehouseEvent-drivenFlink
0 likes · 14 min read
Evolution and Architecture of Beike Real-Time Computing Platform
Programmer DD
Programmer DD
May 18, 2021 · Backend Development

How Nginx’s Multi‑Process Architecture Powers High‑Performance Web Serving

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.

Event-drivenIO MultiplexingNGINX
0 likes · 10 min read
How Nginx’s Multi‑Process Architecture Powers High‑Performance Web Serving
iQIYI Technical Product Team
iQIYI Technical Product Team
May 7, 2021 · Cloud Native

iTech Talk – Cloud‑Native Serverless Practice at iQIYI

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.

AirworkflowCloud NativeEvent-driven
0 likes · 13 min read
iTech Talk – Cloud‑Native Serverless Practice at iQIYI
Architects Research Society
Architects Research Society
Apr 26, 2021 · Cloud Native

Asynchronous Messaging and Event‑Driven Communication in Microservices

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.

Event-drivenasynchronous messagingeventual consistency
0 likes · 11 min read
Asynchronous Messaging and Event‑Driven Communication in Microservices
macrozheng
macrozheng
Apr 13, 2021 · Fundamentals

Master the Observer Pattern in Java: Theory, Code, and Real‑World Example

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.

Design PatternsEvent-drivenJDK
0 likes · 10 min read
Master the Observer Pattern in Java: Theory, Code, and Real‑World Example
Open Source Linux
Open Source Linux
Apr 9, 2021 · Backend Development

Why Nginx Beats Apache in High‑Concurrency Environments

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.

ApacheEvent-drivenNGINX
0 likes · 11 min read
Why Nginx Beats Apache in High‑Concurrency Environments
New Oriental Technology
New Oriental Technology
Mar 22, 2021 · Backend Development

Introduction to Node.js: History, Core Features, and Ecosystem

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.

BackendEvent-drivenJavaScript
0 likes · 11 min read
Introduction to Node.js: History, Core Features, and Ecosystem
iQIYI Technical Product Team
iQIYI Technical Product Team
Mar 19, 2021 · Cloud Native

Building a Serverless Workflow Platform with Knative: Architecture and Implementation

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.

Cloud NativeEvent-drivenKnative
0 likes · 12 min read
Building a Serverless Workflow Platform with Knative: Architecture and Implementation
NetEase Smart Enterprise Tech+
NetEase Smart Enterprise Tech+
Mar 17, 2021 · Backend Development

How to Evolve Business Architecture: Service Boundaries, Splitting, and Governance

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.

Backend ArchitectureEvent-drivenMicroservices
0 likes · 16 min read
How to Evolve Business Architecture: Service Boundaries, Splitting, and Governance
IT Architects Alliance
IT Architects Alliance
Mar 14, 2021 · Fundamentals

Common Software Architecture Patterns: Layered, Multi‑Layer, Pipe‑Filter, Client‑Server, MVC, Event‑Driven, and Microservices

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.

Design PatternsEvent-drivenMVC
0 likes · 10 min read
Common Software Architecture Patterns: Layered, Multi‑Layer, Pipe‑Filter, Client‑Server, MVC, Event‑Driven, and Microservices
Architecture Digest
Architecture Digest
Mar 10, 2021 · Fundamentals

Overview of Common Software Architecture Patterns

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.

Event-drivenMVCarchitecture
0 likes · 10 min read
Overview of Common Software Architecture Patterns
MaGe Linux Operations
MaGe Linux Operations
Mar 2, 2021 · Backend Development

Why Is Nginx So Fast? Inside Its Process and Event Model

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.

Event-drivenIO MultiplexingProcess Model
0 likes · 10 min read
Why Is Nginx So Fast? Inside Its Process and Event Model
Architects' Tech Alliance
Architects' Tech Alliance
Feb 19, 2021 · Backend Development

Strategies for Decoupling Microservices: Asynchronous Calls, Message Middleware, Event‑Driven Architecture, and CQRS

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.

AsynchronousCQRSDecoupling
0 likes · 20 min read
Strategies for Decoupling Microservices: Asynchronous Calls, Message Middleware, Event‑Driven Architecture, and CQRS
Big Data Technology & Architecture
Big Data Technology & Architecture
Feb 19, 2021 · Big Data

A Comprehensive Guide to Learning Apache Flink: Background, Core Concepts, Modules, Source Code, and Industry Applications

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.

Apache FlinkEvent-drivenReal-time analytics
0 likes · 9 min read
A Comprehensive Guide to Learning Apache Flink: Background, Core Concepts, Modules, Source Code, and Industry Applications
Liangxu Linux
Liangxu Linux
Feb 12, 2021 · Backend Development

Why Is Nginx So Fast? A Deep Dive into Its Process and Event Model

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.

BackendEvent-drivenNGINX
0 likes · 11 min read
Why Is Nginx So Fast? A Deep Dive into Its Process and Event Model
Top Architect
Top Architect
Feb 10, 2021 · Fundamentals

Common Software Architecture Patterns and Their Characteristics

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.

Event-drivenMicroserviceslayered architecture
0 likes · 10 min read
Common Software Architecture Patterns and Their Characteristics
Xianyu Technology
Xianyu Technology
Jan 26, 2021 · Mobile Development

Streaming Page Container Architecture for Xianyu's Flutter Home Page

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.

DSLDynamic UIEvent-driven
0 likes · 14 min read
Streaming Page Container Architecture for Xianyu's Flutter Home Page
Selected Java Interview Questions
Selected Java Interview Questions
Jan 18, 2021 · Backend Development

Transaction Management in Traditional Applications and Microservices: From Local Transactions to BASE and TCC

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.

BASEEvent-driventcc
0 likes · 17 min read
Transaction Management in Traditional Applications and Microservices: From Local Transactions to BASE and TCC
Architects' Tech Alliance
Architects' Tech Alliance
Jan 16, 2021 · Cloud Native

Understanding Cloud‑Native Architecture and Its Key Patterns

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.

Event-drivenMicroservicesObservability
0 likes · 10 min read
Understanding Cloud‑Native Architecture and Its Key Patterns
Full-Stack DevOps & Kubernetes
Full-Stack DevOps & Kubernetes
Jan 15, 2021 · Cloud Native

What’s New in KEDA 2.0? Expanded Triggers and ScaledJob Support

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.

CNCFCloud NativeEvent-driven
0 likes · 6 min read
What’s New in KEDA 2.0? Expanded Triggers and ScaledJob Support
Code Ape Tech Column
Code Ape Tech Column
Dec 13, 2020 · Fundamentals

Common Software Architecture Patterns and Their Characteristics

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.

Design PatternsEvent-drivenMVC
0 likes · 10 min read
Common Software Architecture Patterns and Their Characteristics
vivo Internet Technology
vivo Internet Technology
Dec 9, 2020 · Backend Development

Applying Domain‑Driven Design in Microservice Architecture: Practices and Principles

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.

AggregatesClean ArchitectureDomain-Driven Design
0 likes · 26 min read
Applying Domain‑Driven Design in Microservice Architecture: Practices and Principles
Liangxu Linux
Liangxu Linux
Dec 5, 2020 · Fundamentals

What Are the 7 Core Software Architecture Patterns and When to Use Them?

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.

Architecture PatternsEvent-drivenMVC
0 likes · 13 min read
What Are the 7 Core Software Architecture Patterns and When to Use Them?
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Nov 27, 2020 · Backend Development

Understanding Nginx: Core Architecture, Modules, and How to Dive into the Source Code

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.

BackendEvent-drivenNGINX
0 likes · 45 min read
Understanding Nginx: Core Architecture, Modules, and How to Dive into the Source Code
ITPUB
ITPUB
Nov 27, 2020 · Fundamentals

Understanding 7 Core Software Architecture Patterns and Their Trade‑offs

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.

Design PatternsEvent-drivenMVC
0 likes · 13 min read
Understanding 7 Core Software Architecture Patterns and Their Trade‑offs
ITPUB
ITPUB
Nov 4, 2020 · Fundamentals

What Are the 7 Core Software Architecture Patterns and When to Use Them?

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.

Design PatternsEvent-drivenarchitecture
0 likes · 14 min read
What Are the 7 Core Software Architecture Patterns and When to Use Them?
Architecture Digest
Architecture Digest
Nov 3, 2020 · Backend Development

Data Consistency in Microservices: Transaction Management and Implementation Patterns

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.

BASE theoryData ConsistencyDistributed Systems
0 likes · 19 min read
Data Consistency in Microservices: Transaction Management and Implementation Patterns
21CTO
21CTO
Oct 30, 2020 · Fundamentals

What Are the 7 Core Software Architecture Patterns and When to Use Them?

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.

Design PatternsEvent-drivenMVC
0 likes · 12 min read
What Are the 7 Core Software Architecture Patterns and When to Use Them?
Java Architect Essentials
Java Architect Essentials
Oct 13, 2020 · Backend Development

Data Consistency in Microservices: Transaction Management Patterns and Practices

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.

BASE theoryData ConsistencyEvent-driven
0 likes · 19 min read
Data Consistency in Microservices: Transaction Management Patterns and Practices
Architecture Digest
Architecture Digest
Sep 24, 2020 · Backend Development

Microservice Decoupling Strategies: From Synchronous Calls to Asynchronous Messaging, Event‑Driven Architecture, and CQRS

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.

AsynchronousBackendCQRS
0 likes · 20 min read
Microservice Decoupling Strategies: From Synchronous Calls to Asynchronous Messaging, Event‑Driven Architecture, and CQRS
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 23, 2020 · Backend Development

Understanding Nginx’s Modular Architecture and Event‑Driven Design

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.

AsynchronousBackendEvent-driven
0 likes · 9 min read
Understanding Nginx’s Modular Architecture and Event‑Driven Design
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 14, 2020 · Backend Development

Implementing Spring Event‑Driven Architecture with Asynchronous Listeners

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.

BackendEvent-drivenJava
0 likes · 5 min read
Implementing Spring Event‑Driven Architecture with Asynchronous Listeners
IT Architects Alliance
IT Architects Alliance
Sep 13, 2020 · Backend Development

How to Decouple Tight Microservices: Strategies, Messaging, and CQRS

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.

CQRSDecouplingEvent-driven
0 likes · 21 min read
How to Decouple Tight Microservices: Strategies, Messaging, and CQRS
Java Architect Essentials
Java Architect Essentials
Sep 13, 2020 · Backend Development

Which Software Architecture Fits Your Project? 5 Patterns Compared

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.

CacheEvent-drivenMicroservices
0 likes · 9 min read
Which Software Architecture Fits Your Project? 5 Patterns Compared
Architects' Tech Alliance
Architects' Tech Alliance
Sep 9, 2020 · Backend Development

Microservice Decoupling Strategies: Asynchronous Calls, Messaging, Event‑Driven Architecture, CQRS, and Refactoring

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.

CQRSDecouplingEvent-driven
0 likes · 19 min read
Microservice Decoupling Strategies: Asynchronous Calls, Messaging, Event‑Driven Architecture, CQRS, and Refactoring
IT Architects Alliance
IT Architects Alliance
Jul 29, 2020 · Backend Development

How to Decouple Microservices: From Sync Calls to Event‑Driven 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.

Backend ArchitectureCQRSDecoupling
0 likes · 21 min read
How to Decouple Microservices: From Sync Calls to Event‑Driven Architecture
Architects Research Society
Architects Research Society
Jul 19, 2020 · Backend Development

Comparing Kafka and Mosquitto for Microservice Communication

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.

BackendEvent-drivenKafka
0 likes · 6 min read
Comparing Kafka and Mosquitto for Microservice Communication
Top Architect
Top Architect
Jul 2, 2020 · Backend Development

Understanding Nginx Process Model and High‑Performance Architecture

This article explains Nginx's multi‑process, event‑driven design, its master‑worker model, modular architecture, I/O multiplexing mechanisms such as epoll, and how these factors together enable the server to achieve high performance and support massive concurrent connections.

Event-drivenIO MultiplexingProcess Model
0 likes · 11 min read
Understanding Nginx Process Model and High‑Performance Architecture
Programmer DD
Programmer DD
Jul 1, 2020 · Backend Development

Why Is Nginx So Fast? Inside Its Process and Event Model

This article explains Nginx's high performance by detailing its multi‑process architecture, asynchronous event‑driven I/O, request handling flow, module types, comparison with Apache, maximum connection calculations, HTTP request/response structure, and the differences among select, poll, and epoll.

Backend DevelopmentEvent-drivenProcess Model
0 likes · 9 min read
Why Is Nginx So Fast? Inside Its Process and Event Model
MaGe Linux Operations
MaGe Linux Operations
May 11, 2020 · Backend Development

Why Is Nginx So Fast? Inside Its Process Model and Event Architecture

This article explains Nginx’s high performance by dissecting its multi‑process architecture, event‑driven model, HTTP connection handling, modular design, and I/O mechanisms, comparing it with Apache, and clarifying common questions about worker processes, maximum connections, and concurrency.

Event-drivenIO MultiplexingNGINX
0 likes · 9 min read
Why Is Nginx So Fast? Inside Its Process Model and Event Architecture
JavaEdge
JavaEdge
May 6, 2020 · Backend Development

Why Netty Powers High‑Performance Java Network Applications

Netty, a Java‑based asynchronous event‑driven framework created in 2008, offers a unified API for multiple transports, a powerful reactor thread model, built‑in codecs, extensive protocol support, high throughput, low latency, robust error handling, and a vibrant ecosystem adopted by major tech companies and open‑source projects.

AsynchronousEvent-drivenJava
0 likes · 4 min read
Why Netty Powers High‑Performance Java Network Applications
Alibaba Cloud Native
Alibaba Cloud Native
Apr 26, 2020 · Cloud Native

How to Build Serverless Cloud‑Native Apps with RocketMQ and Knative

This article explains how to combine RocketMQ with Knative to create cloud‑native, event‑driven serverless applications, covering cloud‑native fundamentals, Knative architecture, RocketMQSource integration, a food‑delivery use case, deployment steps, command‑line examples, and additional scenarios.

Cloud NativeEvent-drivenKnative
0 likes · 11 min read
How to Build Serverless Cloud‑Native Apps with RocketMQ and Knative
Open Source Linux
Open Source Linux
Apr 7, 2020 · Backend Development

Why Is Nginx So Fast? Inside Its Process Model and Event Architecture

This article explores Nginx’s high performance by dissecting its multi‑process architecture, event‑driven model, modular design, and I/O handling, comparing it with Apache, and explaining connection limits, request flow, and concurrency mechanisms to reveal why Nginx excels under heavy load.

BackendEvent-drivenProcess Model
0 likes · 11 min read
Why Is Nginx So Fast? Inside Its Process Model and Event Architecture
ITPUB
ITPUB
Mar 20, 2020 · Backend Development

How Nginx’s Modular Architecture Powers High‑Performance Web Serving

This article explains Nginx’s highly modular design, its core, optional and third‑party modules, the multi‑process and asynchronous non‑blocking request handling, the event‑driven model, and the master‑worker interaction that together enable efficient, scalable web server performance.

BackendEvent-drivenNGINX
0 likes · 9 min read
How Nginx’s Modular Architecture Powers High‑Performance Web Serving
Architect's Tech Stack
Architect's Tech Stack
Mar 18, 2020 · Backend Development

Service Calls in Microservice Architecture: RPC vs Event‑Driven, Coupling Types, and Design Strategies

The article explains how microservices communicate via RPC or event‑driven approaches, analyzes different coupling types, compares event notification and event sourcing, discusses API‑gateway and service composition, and offers practical guidance on limiting microservice count and using internal microservice design.

CouplingEvent SourcingEvent-driven
0 likes · 19 min read
Service Calls in Microservice Architecture: RPC vs Event‑Driven, Coupling Types, and Design Strategies
Python Programming Learning Circle
Python Programming Learning Circle
Mar 3, 2020 · Backend Development

Event‑Driven Programming and I/O Models in Python

This article explains the principles of event‑driven programming, compares traditional linear execution with event‑driven models, and details various I/O models—including blocking, non‑blocking, multiplexing, signal‑driven, and asynchronous—providing Python code examples and discussing their advantages and use cases.

AsynchronousEvent-drivenIO Model
0 likes · 26 min read
Event‑Driven Programming and I/O Models in Python
Java Backend Technology
Java Backend Technology
Feb 28, 2020 · Operations

Why Nginx Is So Fast: Inside Its Process Model and High‑Performance Architecture

This article explains why Nginx delivers high performance and concurrency, covering its multi‑process architecture, master‑worker model, event‑driven I/O (select, poll, epoll), module system, HTTP request handling, and comparison with Apache, while providing practical insights into configuration and scalability.

Event-drivenIO MultiplexingNGINX
0 likes · 11 min read
Why Nginx Is So Fast: Inside Its Process Model and High‑Performance Architecture
Architects' Tech Alliance
Architects' Tech Alliance
Feb 27, 2020 · Cloud Computing

What Is Serverless Computing? A Deep Dive into FaaS, BaaS, Benefits & Challenges

This article explains the fundamentals of serverless computing, distinguishes between Function as a Service (FaaS) and Backend as a Service (BaaS), describes how the model works, outlines ideal use cases, and discusses its limitations such as cold starts, vendor lock‑in, debugging difficulties, and configuration complexity.

BaaSEvent-drivenFaaS
0 likes · 14 min read
What Is Serverless Computing? A Deep Dive into FaaS, BaaS, Benefits & Challenges
Efficient Ops
Efficient Ops
Jan 12, 2020 · Backend Development

How Nginx’s Multi‑Process Architecture Powers High‑Performance Web Serving

This article explains Nginx’s multi‑process model, detailing the roles of master and worker processes, the HTTP connection lifecycle, event‑driven architecture, module types, and performance comparisons with Apache, while also covering I/O models like select, poll, and epoll.

Backend DevelopmentEvent-drivenIO Multiplexing
0 likes · 11 min read
How Nginx’s Multi‑Process Architecture Powers High‑Performance Web Serving
Java High-Performance Architecture
Java High-Performance Architecture
Jan 7, 2020 · Backend Development

How to Build a Scalable Reporting Service in a Microservice Architecture

To generate a user‑enriched order report in a microservice system, the article compares four approaches—direct DB access, REST data aggregation, batch pulling, and an event‑driven model—highlighting their trade‑offs in coupling, performance, scalability, and resilience, and recommends the event‑push solution.

Data IntegrationEvent-drivenKafka
0 likes · 5 min read
How to Build a Scalable Reporting Service in a Microservice Architecture
360 Tech Engineering
360 Tech Engineering
Dec 20, 2019 · Fundamentals

Deep Dive into Linux epoll: Data Structures, Core Functions, and Implementation Details

This article provides a comprehensive analysis of Linux's epoll mechanism, covering its fundamental data structures, key kernel functions, wait‑queue handling, event insertion, wake‑up logic, and the differences between edge‑triggered and level‑triggered modes, while including full source code excerpts for reference.

Event-drivenI/O MultiplexingKernel
0 likes · 21 min read
Deep Dive into Linux epoll: Data Structures, Core Functions, and Implementation Details
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Oct 18, 2019 · Backend Development

Understanding Nginx Startup Process and Core Design Principles

This article explores Nginx’s elegant architecture, detailing its master‑worker process model, modular design, event‑driven engine, and the step‑by‑step initialization sequence—including command‑line parsing, cycle creation, container setup, configuration parsing, socket inheritance, and listening socket creation—based on version 1.15.8.1.

BackendCEvent-driven
0 likes · 25 min read
Understanding Nginx Startup Process and Core Design Principles
政采云技术
政采云技术
Oct 8, 2019 · Cloud Computing

Serverless Introduction for Front-End Engineers

This article explains the concept, evolution, architecture, advantages, disadvantages, and typical use cases of Serverless computing, highlighting its rapid growth, event‑driven model, and relevance for front‑end developers seeking to focus on business logic without managing underlying infrastructure.

BaaSEvent-drivenFaaS
0 likes · 9 min read
Serverless Introduction for Front-End Engineers
Tencent Cloud Developer
Tencent Cloud Developer
Aug 20, 2019 · Cloud Native

Why Serverless Is the Next Revolution in Cloud Computing

The article explains what Serverless (or Function as a Service) is, outlines its technical characteristics, business benefits, and ideal application scenarios, and argues that Serverless represents a fundamental shift toward cloud‑native architectures in modern software development.

Cloud NativeEvent-drivenUse Cases
0 likes · 10 min read
Why Serverless Is the Next Revolution in Cloud Computing
Node Underground
Node Underground
Aug 12, 2019 · Backend Development

Why Node.js? Origins, Architecture, and Ideal Use Cases Explained

This article introduces Node.js by covering its origins, core architecture, key features such as event‑driven non‑blocking I/O, and the scenarios where it excels, helping readers decide when and why to choose Node.js for backend development.

Event-drivenJavaScript runtimeNode.js
0 likes · 12 min read
Why Node.js? Origins, Architecture, and Ideal Use Cases Explained
Tencent Cloud Developer
Tencent Cloud Developer
Jun 28, 2019 · Cloud Computing

How Serverless 2.0 Redefines Cloud Development: Architecture, Features, and Tooling

The article analyzes the rapid growth of the serverless market, outlines the technical limitations of existing serverless solutions, and details Tencent Cloud's Serverless 2.0 architecture—including event functions, HTTP functions, HTTP services, developer tools, DevOps integration, and monitoring—while presenting real‑world use cases and performance improvements.

Cloud NativeDevOpsEvent-driven
0 likes · 15 min read
How Serverless 2.0 Redefines Cloud Development: Architecture, Features, and Tooling
58 Tech
58 Tech
Jun 14, 2019 · Backend Development

Introduction to Two IO Model Architectures: Thread‑Based and Event‑Driven Designs

This article explains the two main network I/O architectures—thread‑based designs such as one‑connection‑per‑thread, pre‑forked processes, and their pros and cons, as well as event‑driven designs like the Reactor pattern, thread pools, and multiple reactors—helping readers choose the appropriate model for different server workloads.

Event-drivenIO ModelReactor Pattern
0 likes · 11 min read
Introduction to Two IO Model Architectures: Thread‑Based and Event‑Driven Designs
Programmer DD
Programmer DD
Apr 14, 2019 · Cloud Native

Mastering Spring Cloud Stream: Build Event‑Driven Microservices with Ease

This article explains how Spring Cloud Stream leverages Spring Messaging and Spring Integration to create highly scalable, event‑driven microservices, covering core concepts, message channels, binders, code examples, and the underlying processing flow for both producers and consumers.

Event-drivenMicroservicesSpring Cloud Stream
0 likes · 13 min read
Mastering Spring Cloud Stream: Build Event‑Driven Microservices with Ease
Tencent Cloud Developer
Tencent Cloud Developer
Aug 29, 2018 · Cloud Computing

Introduction to Serverless Architecture and Cloud Functions (SCF)

This article introduces serverless architecture and Tencent Cloud's SCF, explains how function‑as‑a‑service abstracts servers with pay‑per‑use, automatic scaling and trigger‑driven execution, and showcases typical scenarios such as API services, object processing, log analysis, message handling, and scheduled jobs.

Cloud FunctionsEvent-drivenFaaS
0 likes · 20 min read
Introduction to Serverless Architecture and Cloud Functions (SCF)
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Aug 18, 2018 · Operations

How Real-Time Performance Measurement Empowers Manufacturing Enterprises

This article explains why manufacturing firms need cross‑level real‑time performance metrics, outlines key enterprise roles, presents reference architectures for system integration, MES functions, event‑driven mechanisms, communication protocols, and data collection and aggregation components.

Event-drivenMESPerformance Monitoring
0 likes · 2 min read
How Real-Time Performance Measurement Empowers Manufacturing Enterprises
Baidu Intelligent Testing
Baidu Intelligent Testing
Jul 11, 2018 · Mobile Development

iOS Multi‑Device Remote Control: Technical Analysis and Implementation

This article analyzes the shortcomings of existing iOS remote‑control solutions, examines event‑driven and screen‑capture technologies, and presents a practical implementation that combines private APIs, optimized screenshot compression, and socket‑based real‑time streaming to achieve millisecond‑level event response and high‑frame‑rate video for multi‑device iOS control.

Event-drivenMobile AutomationiOS
0 likes · 11 min read
iOS Multi‑Device Remote Control: Technical Analysis and Implementation
Java Backend Technology
Java Backend Technology
Apr 14, 2018 · Backend Development

Why Nginx Beats Apache: Deep Dive into High‑Concurrency Architecture

This article compares Nginx and Apache, explains Apache's three processing models, details how Nginx achieves superior high‑concurrency performance through event‑driven, single‑threaded architecture and efficient memory usage, and outlines key techniques for building scalable web servers.

ApacheBackendEvent-driven
0 likes · 10 min read
Why Nginx Beats Apache: Deep Dive into High‑Concurrency Architecture
Architecture Digest
Architecture Digest
Nov 20, 2017 · Cloud Native

Evolution of Microservice Systems Toward a Reactive Microsystem Architecture

The article explains how traditional microservice architectures evolve into event‑driven reactive microsystems by adopting events‑first DDD, reactive design, and event‑based persistence, highlighting the role of the Actor model, asynchronous non‑blocking communication, event sourcing, and saga‑based distributed transaction handling.

DDDDistributed SystemsEvent Sourcing
0 likes · 9 min read
Evolution of Microservice Systems Toward a Reactive Microsystem Architecture
21CTO
21CTO
Nov 12, 2017 · Backend Development

Why Nginx’s Modular Architecture Powers High‑Performance Web Serving

This article explains Nginx’s modular architecture, core, standard and optional HTTP modules, mail service and third‑party extensions, then details its multi‑process and asynchronous non‑blocking request handling, event‑driven model, master‑worker design, and inter‑process communication, providing a solid foundation for deeper source‑code study.

AsynchronousBackendEvent-driven
0 likes · 8 min read
Why Nginx’s Modular Architecture Powers High‑Performance Web Serving
Architecture Digest
Architecture Digest
Nov 12, 2017 · Backend Development

Nginx Architecture Overview: Modular Design, Request Processing, and Event‑Driven Model

This article explains Nginx’s modular architecture, detailing core, HTTP, mail and third‑party modules, its multi‑process and asynchronous non‑blocking request handling, the event‑driven model with I/O multiplexing, and the master‑worker process interaction that together enable high‑performance web serving.

AsynchronousBackendEvent-driven
0 likes · 8 min read
Nginx Architecture Overview: Modular Design, Request Processing, and Event‑Driven Model
Hujiang Technology
Hujiang Technology
Sep 27, 2017 · Backend Development

Understanding Netty: Principles, Architecture, and Thread Model

This article introduces Netty, an asynchronous event‑driven network framework, covering its design goals, performance benefits, core components such as zero‑copy and unified APIs, advanced features like SSL/TLS and WebSocket support, and explains its single‑thread, multi‑thread, and master‑slave thread models for high‑concurrency backend development.

Backend DevelopmentEvent-drivenNetty
0 likes · 9 min read
Understanding Netty: Principles, Architecture, and Thread Model
Baidu Waimai Technology Team
Baidu Waimai Technology Team
Jul 24, 2017 · Backend Development

Transaction System Best Practices: Event‑Driven Architecture, Document Model, and Availability Guarantees

The article recaps a technical talk by Qunar’s accommodation trading system lead, covering event‑driven design, flexible document schemas, and reliability techniques such as circuit breaking, gray releases, and automated testing to improve scalability and maintainability of backend transaction platforms.

AvailabilityBackend ArchitectureDocument Model
0 likes · 3 min read
Transaction System Best Practices: Event‑Driven Architecture, Document Model, and Availability Guarantees