BestHub
Sign in
Tagged articles

event-driven

255 articles · Page 2 of 3
Alibaba Cloud Native
Alibaba Cloud Native
Jun 15, 2023 · Cloud Native

Why Event‑Driven Architecture Is the Future and How RocketMQ EventBridge Makes It Work

This article explains the fundamentals of event‑driven architecture, contrasts events with commands, outlines its four key characteristics, compares integration patterns, and details the capabilities and technical design of RocketMQ EventBridge, including standards, event hubs, schemas, and serverless integration.

CloudEventsEventBridgearchitecture
0 likes · 18 min read
Why Event‑Driven Architecture Is the Future and How RocketMQ EventBridge Makes It Work
Architects Research Society
Architects Research Society
Jun 5, 2023 · Backend Development

Panel Discussion on Large‑Scale Event‑Driven Architectures and Practical Lessons

A multi‑expert panel shares experiences, challenges, and best practices for building, operating, and evolving large‑scale event‑driven systems using technologies like Kafka, covering architecture decisions, domain modeling, observability, handling unordered events, and advice for day‑two operations.

Kafkaarchitectureevent-driven
0 likes · 29 min read
Panel Discussion on Large‑Scale Event‑Driven Architectures and Practical Lessons
MaGe Linux Operations
MaGe Linux Operations
May 28, 2023 · Backend Development

When to Use RPC vs Event‑Driven Architecture in Microservices?

This article examines microservice communication, comparing RPC and event‑driven approaches, explains different types of coupling, explores event notification and event sourcing, discusses API gateways and internal microservice design, and offers guidance on choosing the right integration method and managing service count.

Event SourcingRPCevent-driven
0 likes · 21 min read
When to Use RPC vs Event‑Driven Architecture in Microservices?
Inke Technology
Inke Technology
May 25, 2023 · Backend Development

How to Build a Scalable Task System with Kafka and Pub/Sub

This article explains how to design and implement a basic task system—covering task configuration, display, progress tracking, and reward collection—while using Kafka for decoupling services and a publish/subscribe event layer to keep task logic independent of event sources.

KafkaPublish‑SubscribeTask System
0 likes · 8 min read
How to Build a Scalable Task System with Kafka and Pub/Sub
JD Retail Technology
JD Retail Technology
Apr 28, 2023 · Backend Development

Node.js: Advantages, Disadvantages, Architecture, and Future Trends

This article examines Node.js’s strengths and weaknesses, its event‑driven architecture, practical code examples, middleware usage, impact on front‑end development, and forecasts its role in future trends such as cloud‑native, serverless, IoT, and AI applications.

Full-StackNode.jsPerformance
0 likes · 15 min read
Node.js: Advantages, Disadvantages, Architecture, and Future Trends
MaGe Linux Operations
MaGe Linux Operations
Apr 11, 2023 · Backend Development

Why Nginx Outperforms Apache in High‑Concurrency Scenarios

This article compares Nginx and Apache, showing how Nginx’s event‑driven, single‑threaded architecture and efficient memory usage enable it to handle tens of thousands of concurrent connections with far less resources, and explains the underlying Apache work modes and I/O models.

ApacheHigh ConcurrencyPerformance
0 likes · 11 min read
Why Nginx Outperforms Apache in High‑Concurrency Scenarios
Cloud Native Technology Community
Cloud Native Technology Community
Feb 14, 2023 · Backend Development

Service Coupling, RPC vs Event‑Driven Communication, and Microservice Design Strategies

The article examines how microservices interact, compares RPC and event‑driven approaches, analyzes different types of coupling, discusses event notification, event sourcing, API gateways, versioning, and offers practical guidance on reducing tight coupling and deciding the appropriate microservice architecture.

Event SourcingRPCbackend architecture
0 likes · 19 min read
Service Coupling, RPC vs Event‑Driven Communication, and Microservice Design Strategies
dbaplus Community
dbaplus Community
Jan 28, 2023 · Backend Development

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

This article examines the trade‑offs between RPC and event‑driven communication in microservice architectures, detailing different types of coupling, the benefits and drawbacks of event notification and event sourcing, practical examples, and strategies such as API gateways and internal microservice design to reduce tight coupling.

API GatewayCouplingEvent Sourcing
0 likes · 22 min read
When Should You Choose Event‑Driven Over RPC in Microservices?
Ubiquitous Tech
Ubiquitous Tech
Jan 28, 2023 · Backend Development

Decoupling Java Business Logic with Spring Event: A Hands‑On Example

Learn how to use Spring's Application Event mechanism to separate main and sub‑processes in Java applications, covering custom event and listener creation, publishing events, abstract base event design, singleton manager, and a real‑world order‑cancellation SMS notification case.

BackendDesign PatternJava
0 likes · 10 min read
Decoupling Java Business Logic with Spring Event: A Hands‑On Example
Tencent Cloud Developer
Tencent Cloud Developer
Dec 7, 2022 · Cloud Native

Kubernetes Architecture Analysis: Design Patterns, Principles and Implementation

The article examines Kubernetes architecture from a software‑design viewpoint, showing how its declarative API and extensible ecosystem outpace Swarm and Mesos, and detailing core concepts, control‑plane components, identified design patterns such as microkernel, event‑driven and CQRS, key architectural decisions, and the resulting strengths and trade‑offs.

K8s ArchitectureKubernetescontainer orchestration
0 likes · 13 min read
Kubernetes Architecture Analysis: Design Patterns, Principles and Implementation
Baidu Geek Talk
Baidu Geek Talk
Nov 9, 2022 · Backend Development

Baidu Contract Advertising Platform: Microservices Architecture Evolution and Best Practices

The article examines Baidu's Contract Advertising Platform, detailing its shift from a monolithic, siloed design to a DDD‑driven microservices architecture using COLA, CQRS, and layered governance, and shares best practices for handling complex B2B advertising scenarios, service iteration, and evolving business needs.

B-end SystemsBaiduCQRS Pattern
0 likes · 27 min read
Baidu Contract Advertising Platform: Microservices Architecture Evolution and Best Practices
Java Architect Essentials
Java Architect Essentials
Oct 28, 2022 · Backend Development

Understanding Service Coupling: RPC vs. Event‑Driven Approaches in Microservice Architecture

The article explains the different kinds of coupling in microservice communication, compares RPC and event‑driven (event notification and event sourcing) approaches, discusses API gateways, service versioning, and offers practical guidance on when to use each method while highlighting the challenges of tight coupling and internal microservice design.

API GatewayEvent SourcingRPC
0 likes · 20 min read
Understanding Service Coupling: RPC vs. Event‑Driven Approaches in Microservice Architecture
Architecture Digest
Architecture Digest
Oct 7, 2022 · Backend Development

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

The article explains the different types of service coupling in microservice architectures, compares RPC and event‑driven approaches—including event notification and event sourcing—provides practical examples, discusses API gateways and strategies to reduce tight coupling, and concludes with guidance on internal microservice design and when to adopt microservices.

Event SourcingRPCbackend architecture
0 likes · 19 min read
Understanding Service Coupling, RPC vs Event‑Driven Communication, and Event Sourcing in Microservices
Top Architect
Top Architect
Sep 23, 2022 · Backend Development

Event‑Driven Architecture and Ensuring Eventual Consistency in Microservices

The article explores event‑driven architecture in microservices, detailing transaction consistency challenges, eventual consistency solutions, domain‑driven design, bounded contexts, and practical patterns such as local transaction tables, event sourcing, and materialized views to achieve reliable distributed systems.

DDDevent-driveneventual consistency
0 likes · 15 min read
Event‑Driven Architecture and Ensuring Eventual Consistency in Microservices
Top Architect
Top Architect
Sep 15, 2022 · Backend Development

Event‑Driven Architecture and Distributed Transaction Consistency in Microservices

The article explains how traditional ACID transaction guarantees break down in microservice environments, discusses the challenges of distributed transactions, and presents event‑driven architectures, eventual consistency, domain services, materialized views, and practical patterns such as local transaction tables and event sourcing to achieve reliable consistency across services.

DDDarchitectureevent-driven
0 likes · 15 min read
Event‑Driven Architecture and Distributed Transaction Consistency in Microservices
Code Ape Tech Column
Code Ape Tech Column
Aug 18, 2022 · Backend Development

Understanding Coupling in Microservices: RPC vs Event‑Driven Approaches

This article explains the different types of coupling in microservice architectures, compares RPC and event‑driven communication, discusses event notification and event sourcing, and offers practical guidance on reducing tight coupling, designing service gateways, and deciding the appropriate number of microservices.

CouplingRPCevent-driven
0 likes · 20 min read
Understanding Coupling in Microservices: RPC vs Event‑Driven Approaches
Architect
Architect
Jul 9, 2022 · Cloud Native

Transitioning from Monolith to Microservices: Service Mesh, Kubernetes, and Architectural Strategies

This article explains how organizations can evolve from monolithic applications to microservices using service mesh patterns, Kubernetes sidecar proxies, event‑driven designs, and practical migration strategies such as incremental extraction, Lego‑style integration, and full rebuilds, while addressing latency, security, and observability concerns.

Kubernetesarchitectureevent-driven
0 likes · 35 min read
Transitioning from Monolith to Microservices: Service Mesh, Kubernetes, and Architectural Strategies
Architect's Guide
Architect's Guide
Jun 21, 2022 · Fundamentals

5 Best Software Architectural Patterns You Must Know About

This article introduces the concept of software architectural patterns, explains why they are essential, and details five popular patterns—layered, microkernel, event‑driven, microservices, and space‑based—along with guidance on when and where to apply each.

Design PatternsMicrokernelSoftware Engineering
0 likes · 17 min read
5 Best Software Architectural Patterns You Must Know About
IT Architects Alliance
IT Architects Alliance
Jun 6, 2022 · Backend Development

From Monolith to Event‑Driven Microservices: A Step‑by‑Step Architecture Blueprint

This comprehensive guide explains how to transform a small e‑commerce monolith into a highly scalable, low‑latency, fault‑tolerant event‑driven microservice system by applying layered architecture, SOA, design patterns, API‑gateway strategies, CQRS, event sourcing, and appropriate cloud‑native technologies.

API GatewayCQRSDesign Patterns
0 likes · 22 min read
From Monolith to Event‑Driven Microservices: A Step‑by‑Step Architecture Blueprint
Alipay Experience Technology
Alipay Experience Technology
May 17, 2022 · Mobile Development

How Ant Group Built an Ultra‑Real‑Time Client Feature Center for Smarter AI

This article examines the challenges of traditional data feature acquisition and presents Ant Group’s ultra‑real‑time client feature center, detailing its architecture, data collection, streaming and script computation, backflow mechanisms, and monitoring to deliver rich, timely, and easy‑to‑use features for AI models.

Python VMReal-time Dataclient-side features
0 likes · 11 min read
How Ant Group Built an Ultra‑Real‑Time Client Feature Center for Smarter AI
Qunar Tech Salon
Qunar Tech Salon
May 5, 2022 · Backend Development

Applying Domain-Driven Design (DDD) to Hotel Transaction Systems: Architecture and Code Implementation

This article explains how Domain-Driven Design is applied to a hotel transaction platform, detailing a four‑layer loose DDD architecture, the responsibilities of each layer, code implementation examples, and strategies for maintaining consistency across aggregates using events and factories.

DDDDomain-Driven DesignHotel Transaction
0 likes · 9 min read
Applying Domain-Driven Design (DDD) to Hotel Transaction Systems: Architecture and Code Implementation
Zhuanzhuan Tech
Zhuanzhuan Tech
Apr 20, 2022 · Backend Development

Transaction Middleware: FSM and Concurrency Model Practices and Exploration

This article examines the challenges faced by a transaction middleware platform, introduces a finite‑state‑machine (FSM) solution for order state flows, and compares traditional serial processing with future‑based staged concurrency and event‑driven concurrency models, highlighting their benefits and trade‑offs.

BackendConcurrencyFinite State Machine
0 likes · 11 min read
Transaction Middleware: FSM and Concurrency Model Practices and Exploration
IT Architects Alliance
IT Architects Alliance
Apr 19, 2022 · Cloud Computing

Avoid Serverless Pitfalls: 5 Anti‑Patterns and 6 Design Patterns for Scalable Architectures

This article examines common Serverless anti‑patterns such as monolithic Lambdas, Lambda orchestration, Lambda‑to‑Lambda calls, and event loops, then presents six proven Serverless design patterns—including Command, Messaging, Priority Queue, Fan‑out, and Pipeline‑Filter—to help architects build cost‑effective, highly available, and maintainable cloud applications.

AWS LambdaAnti-PatternsDesign Patterns
0 likes · 13 min read
Avoid Serverless Pitfalls: 5 Anti‑Patterns and 6 Design Patterns for Scalable Architectures
IT Architects Alliance
IT Architects Alliance
Mar 30, 2022 · Backend Development

Designing a Scalable Event-Driven Microservices Architecture for E‑Commerce

This article guides readers through the evolution from a monolithic e‑commerce application to a highly available, scalable, low‑latency event‑driven microservices architecture, covering design patterns, principles, API gateway, BFF, service aggregation, CQRS, event sourcing, and technology stack choices such as Kafka and Cassandra.

CQRSKafkaarchitecture
0 likes · 21 min read
Designing a Scalable Event-Driven Microservices Architecture for E‑Commerce
Architects Research Society
Architects Research Society
Mar 29, 2022 · Backend Development

Designing Microservice Architecture with Patterns, Principles, and Best Practices

This comprehensive guide teaches how to design scalable, highly available microservice architectures by applying design patterns, principles, and best practices, covering the evolution from monolithic to event‑driven systems, communication strategies, data management techniques, and technology choices such as API gateways, BFF, CQRS, and Kafka.

API GatewayCQRSDesign Patterns
0 likes · 23 min read
Designing Microservice Architecture with Patterns, Principles, and Best Practices
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.

C++EpollIO 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.

I/O multiplexingRedisevent-driven
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.

Asynchronous ProgrammingI/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 Patterndistributed monolithevent-driven
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 PatternsMVCevent-driven
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.

Asynchronous ProgrammingI/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.

Dynamic TemplatesFlutterMVVM
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.

CQRSData Modelingbackend architecture
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.

C++EpollRedis
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-drivenlayered architecture
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.

SOAapplication architecturecloud
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.

EpollHigh ConcurrencyIO Multiplexing
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.

Nginxbackend developmentevent-driven
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.

RPCarchitectureevent-driven
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.

RPCevent-drivenservice coupling
0 likes · 21 min read
Understanding Service Calls in Microservice Architecture: RPC vs Event‑Driven, Coupling Types, and Design Strategies
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.

BackendNginxProcess Model
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.

AIOpsDevOpsStackStorm
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.

BackendNginxProcess Management
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-gatewayDDDRPC
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.

API GatewayEvent SourcingRPC
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 TestingLoad TestingLocust
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.

Flinkdata warehouseevent-driven
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.

IO MultiplexingNginxProcess Model
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.

AirworkflowServerlesscloud-native
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.

Asynchronous Messagingevent-driveneventual 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 PatternsJDKJava
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.

ApacheHigh ConcurrencyNginx
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.

BackendFrameworksJavaScript
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.

KnativeKubernetesServerless
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.

Service GovernanceService Splittingbackend architecture
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 PatternsMVCevent-driven
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.

MVCarchitecturedesign-patterns
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.

High PerformanceIO 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.

CQRSMessage Middlewareasynchronous
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 FlinkReal-time Analyticsevent-driven
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.

BackendEpollHigh Concurrency
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-drivenlayered architecturemicroservices
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 UIFlutter
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.

BASETCCevent-driven
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.

Serverlesscloud-nativeevent-driven
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.

CNCFKEDAKubernetes
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 PatternsMVCevent-driven
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.

AggregatesDomain-Driven DesignJava
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.

MVCarchitecture patternsevent-driven
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.

BackendNginxevent-driven
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 PatternsMVCevent-driven
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 Patternsarchitectureevent-driven
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 ConsistencyTCC
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 PatternsMVCevent-driven
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 ConsistencyTCC
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.

BackendCQRSasynchronous
0 likes · 20 min read
Microservice Decoupling Strategies: From Synchronous Calls to Asynchronous Messaging, Event‑Driven Architecture, and CQRS
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.

CQRSarchitecturedecoupling
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-drivenlayered architecture
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.

CQRSarchitecturedecoupling
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.

CQRSbackend architecturedecoupling
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.

BackendKafkaMosquitto
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.

High PerformanceIO 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.

High PerformanceProcess Modelbackend development
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.

IO MultiplexingNginxPerformance
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.

High PerformanceJavaNetty
0 likes · 4 min read
Why Netty Powers High‑Performance Java Network Applications