Tagged articles
event-driven architecture
82 articles · Page 1 of 1
This article compares DeepSeek's Super-Agent architecture with Octop's team mode, revealing how both independently adopted a two-layer dispatcher-worker design, event-driven asynchronous execution, context isolation, and local execution with cloud coordination to enable parallel multi-agent task processing while preserving security and continuity.
Context ManagementOctopSuper-Agent
0 likes · 44 min read

The author shares six critical Spring Event best practices derived from production incidents, covering graceful shutdown requirements, startup event loss prevention, suitability for eventual consistency over strong consistency, reliability through retry mechanisms, and mandatory idempotency for subscribers.
IdempotencyKafkaSpring Event
0 likes · 11 min read

This article analyzes DeepSeek's SuperAgent architecture, detailing its dual-layer Router/Worker design, event-driven triggers, context management with Inline/Spill and chain-of-recall, full-duplex async execution, and compute-state-environment separation. It compares with Cursor, LangChain, Anthropic, and Cognition approaches, examines the open-source prototype's code-level decisions (model proposes/code decides, outbox pattern, security layers), and shares the author's Flock system implementation for multi-human multi-agent collaboration.
AI agent architectureContext ManagementDeepSeek
0 likes · 56 min read

Qwen Code 1.0 merges Qoder's Harness capabilities into an open-source release, introducing a unified event mechanism that routes external inputs through adapters into standard events, enabling scalable agent orchestration with hand-brain separation and distributed evolution from in-memory bus to multi-node clusters.
AI AgentHarnessQoder
0 likes · 5 min read

openJiuwen's HyperAgent architecture defines eight key traits—proactivity, persistence, growth, collaboration, determinism, extensibility, openness, and economy—supported by a layered AgentOS with event-driven runtime, persistent agents, CoRSI recursive improvement, and swarm-based heterogeneous collaboration for real-world deployment.
AI agentsAgentOSHyperAgent
0 likes · 36 min read

Dr. Ouyang Ye argues that billing systems must evolve from static connectivity ledgers into real-time value exchange hubs to support the Internet of Agents, using dynamic intelligence pricing, multi-party revenue sharing via smart contracts, and event-driven architectures with AI-powered pricing engines.
Billing SystemsCSP TransformationDynamic Pricing
0 likes · 13 min read

Forrester's 2026 survey reveals 53% of employees check six-plus channels for a single critical notice; this article dissects the technical root causes — siloed architectures, disjointed push mechanisms, and missing unified identity — quantifies productivity losses from context switching and duplicate work, and evaluates three mature 2026 solution architectures: a unified notification hub, AI-driven aggregation assistants, and protocol-level standardization via Matrix, illustrated by a real-world case cutting daily search time from 62 to 11 minutes.
AI assistantInformation ArchitectureMatrix protocol
0 likes · 14 min read

DeepSeek's Super Agent architecture uses a dual-layer Router/Worker design, event-driven triggers with two-level filtering, asynchronous multi-channel interaction, compute-state-environment separation, and an external watchdog to enable persistent, proactive multi-task AI agents that maintain context across sessions and reduce human monitoring overhead.
Agent ArchitectureAsynchronous ProcessingCompute-State Separation
0 likes · 22 min read

This article explores Spring Boot's ApplicationEvent mechanism for decoupling business side effects, detailing synchronous default behavior, transaction-boundary listeners, async patterns with dedicated thread pools, exception handling strategies, event chaining, and practical refactoring of an order service, while contrasting in-process events with message queues.
ApplicationEventDecoupling PatternsMessage Queue Integration
0 likes · 24 min read

The article traces 10 evolutionary stages of AI agent construction from prompt workflows to first-principles-driven agents, then details DeepSeek's super agent architecture: an event-driven, dual-layer Router-Worker system with persistent SQLite state machine, engineering capabilities for concurrency, fault tolerance, and delivery reliability, and a memory design that stores facts externally via SQL substring matching rather than vector search.
AI agentsAgent EvolutionDeepSeek
0 likes · 11 min read

This article analyzes the Agentic framework's architecture, showing how its event-driven design, Ray-based runtime, and typed event streams solve production challenges like hallucination, debugging, and human-in-the-loop that first-generation agent frameworks ignore.
AI agentsAgenticObservability
0 likes · 14 min read

LobeHub's open-source multi-agent system implements DeepSeek's Super-agent principles in production, using Manager/Worker division, task-based workflows, event-driven filtering, three-layer compute/state/environment separation, and an acceptance system with data flywheel for model fine-tuning — all while dogfooding the platform to develop itself.
AI agent orchestrationAcceptance TestingDeepSeek
0 likes · 17 min read

The article analyzes DeepSeek's Super-agent architecture, showing how it maps operating system concepts—process scheduling, page caching, compute-storage separation, and watchdog mechanisms—to build a dual-layer Router-Worker agent system that enables continuous, efficient, proactive, and persistent autonomous agents, with source code insights from the open-source prototype.
Agent ArchitectureBYOMDeepSeek Super-agent
0 likes · 42 min read

This article analyzes DeepSeek Harness's Super-agent architecture, dissecting its dual-layer Router-Worker design, event-driven routing, context caching, speculative execution, and compute-storage separation, while highlighting trade-offs like cross-layer communication overhead, async complexity, and security risks in BYOM deployments.
Agent ArchitectureContext ManagementDeepSeek Harness
0 likes · 22 min read

DeepSeek releases dsh-superagent-prototype, a next-gen agent architecture using a dual-layer Router/Worker design, event-driven triggers with two-level filtering and subscription pass-through, context management via inline/spill and chained recall, async ReAct loops, compute-storage separation, and a Watchdog for self-healing; experiments show 12.4 min p50 task completion but 3.8x token overhead versus single-session baselines.
AI agentsAgent ArchitectureContext Management
0 likes · 13 min read

This article explains how to make multi-agent collaboration traceable by treating the coordination process as an explicit event stream, covering team structure as configuration, delegation and handoff events with reasons, speaker change signals, and session rollover, enabling auditability and debugging of agent interactions.
Agent orchestrationcollaboration traceabilityevent-driven architecture
0 likes · 30 min read

The article explains CQRS as domain model separation rather than database read/write splitting, detailing command/query model boundaries, event-driven synchronization challenges, consistency trade-offs, engineering pitfalls like event reliability and view explosion, when to avoid CQRS, and a reference e-commerce order implementation with consistency-based query routing.
Architecture Patternsconsistency modelscqrs
0 likes · 15 min read

A real e-commerce stress test reveals a distributed monolith where services are physically separated but logically coupled via shared databases, synchronous write chains, and shared domain models. The article dissects three coupling layers, control-plane risks, and an incremental decoupling strategy with an architectural review checklist.
Bounded Contextarchitectural reviewcoupling analysis
0 likes · 24 min read

This article introduces AI-Native SDLC, explaining why code generation is no longer the bottleneck in software development and how the bottleneck has shifted to requirements specification, context management, verification, governance, and production feedback loops, outlining a 7-layer architecture, artifact-driven workflow, and a 9-part series roadmap.
AI-Native SDLCAgentic WorkflowR&D Process
0 likes · 14 min read

This article introduces Apache Kafka as a distributed streaming platform, detailing its core advantages—high throughput via sequential writes and zero-copy, horizontal scalability through partitions, durability with 7-day retention and replication—and key use cases including log aggregation, event-driven architectures, real-time analytics, and big data integration with tools like Flink and Spark Streaming.
KafkaKafka Streamsbig-data-integration
0 likes · 5 min read

This article analyzes Microsoft's AutoGen framework, contrasting its conversation-driven 'meeting room' architecture with LangGraph's flowchart approach, detailing v0.4's event-driven Actor model, Java integration options, ideal use cases like contract review, and trade-offs including token costs and maintenance mode status.
AI agentsAutoGenJava integration
0 likes · 17 min read

China Postal Savings Bank details its architectural innovation for a highly configurable payment platform serving diverse long-tail public welfare scenarios, covering schema-driven dynamic forms, immersive interaction design, parameterized routing, and a full-lifecycle security compliance system that cut onboarding time from days to hours.
agile developmentconfigurable payment architectureevent-driven architecture
0 likes · 17 min read

The article explains how to handle duplicate payment callbacks in Spring Boot using database unique constraints, conditional state updates, an outbox pattern for reliable event publishing, and downstream idempotency, ensuring orders are processed exactly once even if the payment platform sends repeated notifications.
IdempotencyOutbox Patterndatabase constraints
0 likes · 17 min read

The article analyzes the engineering challenges of large‑scale multi‑agent AI systems—such as connection loss, synchronous blocking, and traffic spikes—and explains how Huawei Cloud AI Queue, built on RocketMQ with Lite Topic, Session Log, and priority topics, provides an event‑driven, elastic, and observable communication backbone for stable, scalable agent collaboration.
AI QueueAgent CommunicationAsynchronous Messaging
0 likes · 16 min read

This article dissects common MQ mis‑selections, categorises four message types, explains the five architectural roles of a message broker, compares Kafka, RabbitMQ and Pulsar on capabilities and trade‑offs, and provides a step‑by‑step selection guide with real‑world code snippets and best‑practice patterns.
KafkaMessage QueueOutbox Pattern
0 likes · 26 min read

This article details a production-ready event-driven architecture for DDD microservices, covering the complete domain event flow, local event table for message loss prevention, three idempotency patterns for duplicate consumption, ordering solutions, five common pitfalls, and a five-layer eventual consistency architecture.
IdempotencyLocal Event TableMessage Queue
0 likes · 12 min read

The article explains why cross‑aggregate business logic belongs in domain services, how domain events capture immutable business facts, and demonstrates practical Spring Boot implementations—including in‑process publishing, message‑queue integration, and the Outbox pattern—while highlighting pitfalls and verification techniques.
Domain EventDomain ServiceOutbox Pattern
0 likes · 10 min read

The article analyzes the pitfalls of synchronous calls in a payroll microservice, defines domain events and their naming conventions, compares them with message‑queue messages, and presents two concrete implementations—Spring ApplicationEvent for intra‑process decoupling and RocketMQ with a transactional outbox for cross‑process communication—while also clarifying when event sourcing is appropriate.
DDDRocketMQSpring ApplicationEvent
0 likes · 15 min read


webdreamJun 24, 2026 · Backend Development
The article analyzes whether endorsement (policy changes) and policy management should reside in a single microservice or be split into two, weighing data consistency, cohesion, operational simplicity, scaling, deployment independence, fault isolation, team size, and compliance, and provides a concrete decision framework and split strategy.
cqrsdomain-driven designevent-driven architecture
0 likes · 11 min read

The article explains how traditional synchronous microservice calls create tight coupling, cascading failures, scaling bottlenecks, and high latency, and demonstrates that adopting an event‑driven architecture with producers, consumers, and a message broker such as Kafka can fully decouple services, improve scalability, and enable patterns like event sourcing and CQRS.
KafkaMessage Brokercqrs
0 likes · 14 min read

This article explains that architecture and design form a continuous spectrum distinguished by three dimensions—significance of trade-offs, investment level, and strategic vs tactical scope—helping engineers clarify decision impact and make wiser technical choices.
Martin Fowlerevent-driven architecturemicroservices
0 likes · 6 min read

Spring Boot can adopt the CloudEvents specification to unify event payloads across microservices, eliminating format inconsistencies; the article explains the spec, shows structured and binary HTTP modes, provides Maven dependencies, configuration, and code examples for producers, consumers, and reactive handling with Spring Cloud Function.
CloudEventsHTTPJava
0 likes · 12 min read

This article presents a senior architect’s end‑to‑end design of a smart parking guidance system, detailing how high‑frequency sensor streams are ingested via Spring Boot gateways, processed with Kafka and Flink for stateful de‑duplication, debouncing, and aggregation, and finally served through Redis, PostgreSQL and Spring Boot APIs for real‑time vehicle routing.
FlinkKafkaSmart Parking
0 likes · 35 min read


Amap TechFeb 3, 2026 · Artificial Intelligence
After LLMs entered the deep‑water stage, developers realized that agents must go beyond passive Q&A to support asynchronous, long‑running, and subscribable tasks; this article details the design, architecture, and engineering challenges of the “Xiao Gao Teacher AI Agent” smart‑task system, from event‑driven logic to fault‑tolerant deployment.
AI AgentLLMScalable Backend
0 likes · 19 min read

This article explains how a Go‑based smart factory evolves from a prototype to a production‑grade system by externalizing configuration with Viper, injecting Trace IDs for end‑to‑end observability, and adopting an event‑driven architecture to achieve flexible, maintainable, and scalable industrial automation.
Configuration ManagementDistributed TracingGo
0 likes · 13 min read

Custom events let developers decouple UI components by broadcasting semantic actions, offering a flexible alternative to direct calls or global state, and improving maintainability, testability, and performance, with best‑practice naming, payload design, bubbling, and cancelable options explained alongside practical JavaScript examples.
Decouplingcustom eventsevent-driven architecture
0 likes · 10 min read

Using a coffee‑shop metaphor, this article explains how Spring’s event‑driven model—event definitions, publishing, and listeners—enables scalable, decoupled backend systems, compares listeners with MQ, shares performance benchmarks, and provides best‑practice guidelines for reliable, high‑throughput applications.
Springbackend developmentevent-driven architecture
0 likes · 9 min read

This article examines how traditional high‑performance message queues and event‑driven architectures can be revitalized for AI agents, tracing the evolution of messaging middleware, highlighting key integration points, and showcasing Apache Pulsar's cloud‑native features that enable reliable, scalable, and intelligent multi‑agent systems.
AI AgentApache PulsarMessage Queue
0 likes · 16 min read

This article explains how Redis achieves high concurrency through non‑blocking I/O, an event‑driven reactor model, efficient I/O multiplexing, in‑memory data structures, and cluster sharding to support millions of simultaneous connections.
database scalingevent-driven architecturenon-blocking I/O
0 likes · 4 min read

This article explains Nginx’s origins, its event‑driven, non‑blocking multi‑process architecture, modular design, and detailed request‑handling workflow, providing a comprehensive overview of how the high‑performance web server operates in modern backend systems.
NGINXbackend developmentevent-driven architecture
0 likes · 5 min read

The article explains how Event‑Driven Architecture (EDA) transforms traditional request‑response systems into decoupled, asynchronous pipelines that boost system resilience, scalability, observability, and agility, and it demonstrates a practical AWS EventBridge image‑processing workflow.
AWS EventBridgeEDAOperations
0 likes · 10 min read

This article explains Redis' deployment models, core components, and the event‑driven engine that powers command processing, detailing the flow from client connection through the reactor loop, command parsing, execution, and response delivery with code examples and diagrams.
ClusterCommand ExecutionReplication
0 likes · 15 min read

This article explains the challenges of maintaining data consistency in distributed, event‑driven microservice architectures and introduces three practical patterns—Outbox, Original Event Handling, and Self‑Read—to guarantee reliable state synchronization across services, even when failures occur.
CDCOutbox Patterndistributed transactions
0 likes · 6 min read

This article explains critical pitfalls and best‑practice guidelines for employing Spring Event in Java backend applications, covering graceful shutdown requirements, event loss during startup, suitable business scenarios, reliability enhancements, retry mechanisms, idempotency, and the relationship between Spring Event and message queues.
BackendJavaRetry
0 likes · 12 min read

Redis achieves millisecond‑level latency by storing all data in memory, using specially optimized data structures such as SDS, incremental‑rehash hash tables, and ziplists, employing a single‑threaded event‑driven model with epoll‑based I/O multiplexing, and streamlining network communication through the compact RESP protocol, compression, and batching, while also offering flexible eviction and persistence strategies.
Cache EvictionI/O multiplexingdata structures
0 likes · 11 min read


JavaEdgeAug 24, 2024 · Backend Development
This article examines the trade‑offs between simple and detailed events in event‑driven architectures, illustrating their impact on scalability, coupling, and system design through concrete examples, design guidelines, and considerations from domain‑driven design to practical implementation.
backend designdetailed eventsevent-driven architecture
0 likes · 12 min read

This article explains why organizations may replace traditional relational databases with Apache Kafka as a system of record, highlighting Kafka's economic, scalable, immutable log capabilities, event replay, flexibility for diverse use cases, and its suitability for highly regulated, data‑intensive environments.
Data StreamingImmutable LogKafka
0 likes · 10 min read


21CTOMay 6, 2024 · Backend Development
This article narrates how McDonald’s food‑delivery platform uses a hexagonal, event‑driven, micro‑service architecture with serverless functions, message brokers, and schema registries to achieve massive scalability, low latency, and reliable order processing for millions of daily users.
backend developmentevent-driven architecturehexagonal-architecture
0 likes · 8 min read

This article explores the evolution of message middleware, defines event‑driven architecture, explains why it resurfaces in the cloud era, and details RocketMQ 5.0 EventBridge’s design—its CloudEvents‑based abstraction, schema support, rule engine, observability, and real‑world use cases—offering practical guidance for building scalable, decoupled systems.
CloudEventsEventBridgeIoT
0 likes · 15 min read

Explore the essential distinctions between microservices and event‑driven architecture, covering service granularity, data handling, bounded contexts, and practical use‑case scenarios, to help architects and developers choose the right approach for scalable, responsive software systems.
event-driven architecturemicroservicessoftware design
0 likes · 8 min read

This article explains the Observer design pattern, its intent, real‑world analogies, advantages and drawbacks, and provides a complete JavaScript example with prototype‑based code to illustrate how publishers and subscribers interact in an event‑driven system.
Observer PatternPublish‑Subscribedesign patterns
0 likes · 12 min read

The article explains that building evolvable software systems—using strategies like microservices and event‑driven architecture—allows teams to adapt to changing workloads and business growth, illustrated with real‑world examples from Amazon, Prime Video, and S3, while emphasizing that no single architectural pattern fits all scenarios.
cloud computingevent-driven architectureevolvable systems
0 likes · 6 min read

NetEase Cloud Music transitioned from public FaaS to a private Knative‑based serverless platform, delivering elastic audio‑video processing, multi‑language support, event‑driven scaling across hybrid private and public clouds, boosting resource utilization and cutting costs, though cold‑starts and container expertise remain challenges.
KnativeResource Optimizationcloud native
0 likes · 16 min read


phodalOct 24, 2022 · Industry Insights
This article provides a comprehensive overview of low‑latency architecture, covering network hardware, system‑level programming strategies, language choices, memory management techniques, event‑driven designs, high‑performance data structures, and visualization approaches for building ultra‑fast computing systems.
High-Performance ComputingJava performanceevent-driven architecture
0 likes · 10 min read

The article describes how Wix engineers built a robust, Kafka‑based event‑driven messaging infrastructure for over 1,400 microservices, detailing patterns such as consumption and projection, end‑to‑end streaming with websockets, in‑memory KV stores, schedule‑and‑forget jobs, exactly‑once transactions, and event aggregation to achieve scalability, resilience, and low‑latency data access.
Data StreamingKafkadistributed systems
0 likes · 16 min read

This fifth installment explains vivo’s real‑time marketing automation engine, detailing its business need, layered architecture (access, processing, output, management, warehouse), scalable event‑queue design, dynamic configuration, unified dispatch, Flink‑based metric enrichment, and rule‑engine integration to achieve low‑latency, high‑throughput personalized targeting.
FlinkMessage Queueevent-driven architecture
0 likes · 13 min read

This article explains how Wix uses Kafka‑based event‑driven messaging to decouple microservices, improve scalability, and achieve exactly‑once processing through patterns such as consume‑and‑project, end‑to‑end event streams, in‑memory KV stores, scheduled jobs, transactional events, and event aggregation.
Data StreamingKafkadistributed systems
0 likes · 16 min read

This guide explains how Alibaba Cloud EventBridge’s open API target enables event‑driven automation for managing cloud resources, covering event bus types, official event sources, required parameters, and step‑by‑step examples such as creating RocketMQ topics and ECS snapshots.
Alibaba CloudCloud AutomationOpenAPI
0 likes · 13 min read


21CTOAug 23, 2022 · Cloud Native
This article traces RocketMQ's transformation from a traditional message queue to a cloud‑native, ultra‑fusion platform that integrates messaging, event‑driven architecture, and streaming, highlighting its historical stages, architectural upgrades, multi‑language SDKs, stateless consumption, and future cloud‑native trends.
Message QueueRocketMQcloud native
0 likes · 22 min read

This article explains how Huawei Cloud EventGrid, powered by Apache EventMesh and gRPC, provides a serverless, high‑availability event bus that unifies HTTP, TCP, and message‑queue protocols, enabling composable applications to integrate seamlessly across cloud services and SaaS partners.
EventGridEventMeshevent-driven architecture
0 likes · 15 min read

This article explains the core concepts of Alibaba Cloud EventBridge for building event‑driven architectures, compares imperative and declarative IaC approaches, and provides detailed Terraform examples—including a DingTalk alert and a custom bus triggering FunctionCompute—complete with code snippets and deployment steps.
Alibaba CloudEventBridgeIaC
0 likes · 14 min read

This article explains the fundamentals of event‑driven architecture, outlines when it should be used, describes common patterns such as event notification, state transfer, event sourcing, and CQRS, and provides a detailed example of applying these concepts in a content‑platform microservice system with code snippets and deployment considerations.
Backendcqrsevent-driven architecture
0 likes · 17 min read

Event‑driven architecture (EDA) coordinates micro‑services through immutable events and a reliable broker, enabling decoupling, asynchronous processing, and state‑change tracking via patterns such as event notification, state transfer, event sourcing, and CQRS, while offering scalability and robustness but demanding careful design to avoid complexity and consistency issues.
Message Queuebackend designcqrs
0 likes · 18 min read

This article explains how Redis, originally a single‑threaded in‑memory cache, introduced Lazy Free and multi‑threaded I/O to eliminate blocking during large key deletions, improve QPS, and lay the groundwork for future multithreading strategies.
Database PerformanceLazy FreeMultithreaded I/O
0 likes · 16 min read

This article explains how Wix engineers built a robust, event‑driven messaging infrastructure on Kafka that serves over 1,400 microservices, detailing six key patterns—including consumption‑projection, end‑to‑end event flows, in‑memory KV stores, scheduling, transactional events, and aggregation—that improve scalability, resilience, and operational simplicity.
KafkaMessage Streamingbackend design
0 likes · 19 min read

This article explains how to design microservice architectures by applying domain‑driven design, defining bounded contexts, using context mapping and event‑storming techniques, and addressing communication, consistency, and integration patterns such as event‑driven messaging and the Backend‑for‑Frontend approach.
Backend For FrontendBounded ContextContext Mapping
0 likes · 19 min read

Tencent Cloud’s serverless platform, now serving over a million developers and billions of daily invocations, accelerates business and education workloads, enables massive elastic scaling, integrates video, GPU, and event‑bus services, and simplifies migration, debugging, and SaaS integration, heralding serverless as the next mainstream cloud paradigm.
Function ComputeTencent Cloudcloud computing
0 likes · 17 min read

This article explains how Nginx achieves high performance through its modular design, event‑driven architecture, multi‑stage asynchronous request handling, master‑worker process model, and efficient memory‑pool implementation, contrasting it with traditional web servers and illustrating each concept with diagrams.
Backend PerformanceNGINXProcess Model
0 likes · 9 min read

The article examines how to reduce tight coupling between microservices by applying module‑division principles, converting synchronous calls to asynchronous messaging, leveraging event‑driven architectures and CQRS, employing local caching and data landing, and refactoring overly coupled services for more resilient backend systems.
Asynchronous Messagingbackend designcqrs
0 likes · 21 min read

This article explains the open‑source Stateful Functions framework, its API and Flink‑based runtime, and how it simplifies building distributed stateful applications by combining serverless concepts with robust state management for event‑driven architectures.
Apache FlinkStateful Functionsbig data
0 likes · 8 min read

Microservice architectures struggle with traditional ACID transactions, so this article reviews local and distributed transaction basics, explains why 2PC/3PC are unsuitable, introduces the BASE model, and details four practical consistency patterns—reliable event, async event, business compensation, and TCC—highlighting their mechanisms, advantages, and drawbacks.
BASE theoryData ConsistencyTCC
0 likes · 17 min read


ITPUBJul 28, 2020 · Databases
This article explains MySQL Binlog’s role in event‑driven order processing, analyzes hidden pitfalls such as premature Binlog reads and two‑phase commit issues, and offers practical solutions like retry strategies and direct Binlog consumption to ensure data consistency.
Database LogsMySQLTwo-Phase Commit
0 likes · 14 min read

This article explains Nginx's high‑performance architecture, covering its modular design, event‑driven processing, multi‑stage asynchronous request handling, master‑worker process model, and memory‑pool mechanism, and compares it with traditional web servers.
NGINXProcess Managementevent-driven architecture
0 likes · 10 min read

This article explains how event‑driven and microkernel architectures provide flexible, decoupled designs for complex backend systems, comparing centralized and decentralized patterns, outlining their structures, advantages, drawbacks, and suitable scenarios, and offering practical guidance for implementation.
BackendMicrokernelevent-driven architecture
0 likes · 12 min read

This article explains how shifting from synchronous command‑driven interactions to asynchronous event‑driven flows reduces coupling, improves scalability, and enables flexible querying in distributed systems, while also discussing hybrid patterns, the single‑writer principle, and practical advantages illustrated with Kafka‑based examples.
EventsKafkaQueries
0 likes · 13 min read

This article provides a comprehensive walkthrough of Nginx’s startup sequence, master‑worker process communication, critical callback configurations, and the detailed flow of HTTP request handling, supplemented with GDB debugging steps and example module development for deeper insight into its modular architecture.
event-driven architecturegdb debugginghttp request processing
0 likes · 14 min read


21CTOMay 25, 2017 · Cloud Computing
This article introduces Serverless computing, explains its core concepts such as BaaS and FaaS, outlines its key characteristics, and showcases real-world use cases ranging from data processing pipelines to web applications, highlighting benefits, challenges, and future trends.
AWS LambdaBaaSFaaS
0 likes · 10 min read

The article explains how NIO replaces the thread‑intensive blocking I/O model with a non‑blocking, event‑driven architecture that lets a single thread handle many connections, covering BIO vs NIO differences, selector mechanics, Reactor/Proactor patterns, buffer strategies, practical use cases, and framework recommendations.
Buffer ManagementI/O multiplexingJava Networking
0 likes · 19 min read

This article explores how an ideal web framework—featuring a unified data model, reusable code, event‑driven logic, and language‑agnostic architecture—can be realized in practice, discussing frontend and backend realities, graph‑based data modeling, and the benefits for maintainability and extensibility.
Data ModelingWeb Frameworkevent-driven architecture
0 likes · 25 min read


21CTOSep 15, 2015 · Fundamentals
This article explores how ideal web frameworks could evolve by separating data description from logic, using event‑driven architectures, graph databases, and cross‑language integration to achieve minimal, maintainable, and extensible code, while contrasting current practices like React, Angular, and Meteor.
BackendData ModelingWeb Framework
0 likes · 26 min read


21CTOSep 14, 2015 · Fundamentals
The article explores how ideal web frameworks could evolve by separating data description from logic, using event‑driven architectures, graph databases, and cross‑language components to achieve minimal, maintainable, and extensible code, while discussing practical implementations, challenges, and philosophical foundations.
Data ModelingFrontend Developmentevent-driven architecture
0 likes · 25 min read

The article explains the fundamentals of stream processing, event sourcing, and complex event processing, comparing raw event storage with aggregated results, illustrating architectures with Kafka, Samza, and other frameworks, and highlighting benefits such as scalability, flexibility, and decoupling for modern data‑driven systems.
Apache KafkaApache Samzabig data
0 likes · 11 min read
