BestHub
Sign in
Tagged articles
129 articles
Page 2 of 2
Programmer DD
Programmer DD
Nov 17, 2020 · Fundamentals

Why Good Software Architecture Matters: From Basics to the COLA Framework

This article explains the concept of software architecture, why it is essential, the responsibilities of architects, various architecture classifications, and introduces practical application architectures such as layered, CQRS, hexagonal, onion, and the open‑source COLA framework, highlighting how separating business logic from technical details improves maintainability and scalability.

COLA frameworkCQRSExtension Points
0 likes · 16 min read
Why Good Software Architecture Matters: From Basics to the COLA Framework
IT Architects Alliance
IT Architects Alliance
Nov 12, 2020 · Backend Development

Mastering CQRS: Choose the Right Architecture – Single, Dual, or Event‑Sourced

This article explains the Command‑Query Separation principle, introduces the CQRS architectural pattern, and compares three implementations—single‑database, dual‑database, and event‑sourced—detailing their workflows, benefits, and trade‑offs for optimizing read and write operations in backend systems.

Backend ArchitectureCQRSCQS
0 likes · 6 min read
Mastering CQRS: Choose the Right Architecture – Single, Dual, or Event‑Sourced
IT Architects Alliance
IT Architects Alliance
Nov 2, 2020 · Backend Development

How DDD Can Tame Complex Business Logic in Modern Backend Systems

This article explores how Domain‑Driven Design helps the Tongtian Tower platform manage rapidly growing business complexity by separating business and technical concerns, introducing strategic and tactical design, bounded contexts, layered and hexagonal architectures, and complementary patterns such as CQRS and domain primitives.

Backend ArchitectureCQRSDomain Modeling
0 likes · 40 min read
How DDD Can Tame Complex Business Logic in Modern Backend Systems
IT Architects Alliance
IT Architects Alliance
Oct 28, 2020 · Fundamentals

Why Architecture Matters: From Basics to the COLA Open‑Source Framework

This article explains what software architecture is, why it is essential, the responsibilities of architects, various classification types, common patterns such as layered, CQRS, hexagonal and onion architectures, and introduces the open‑source COLA framework with its layered design, extension mechanisms, and specification rules.

COLACQRSDesign Patterns
0 likes · 14 min read
Why Architecture Matters: From Basics to the COLA Open‑Source Framework
Architects' Tech Alliance
Architects' Tech Alliance
Oct 25, 2020 · Fundamentals

Understanding Software Architecture and the COLA Application Architecture

This article explains the concept of software architecture, why it is needed, the responsibilities of architects, various architectural classifications and patterns such as layered, CQRS, hexagonal and onion architectures, and introduces the COLA framework with its layered design, extension mechanisms, and specification guidelines.

COLACQRSHexagonal Architecture
0 likes · 12 min read
Understanding Software Architecture and the COLA Application Architecture
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Oct 23, 2020 · Fundamentals

Why Architecture Matters: From Basics to the COLA Framework

This article explains what software architecture is, why it is essential, the responsibilities of architects, various classification types, typical architectural patterns such as layered, CQRS, hexagonal and onion architectures, and introduces Alibaba's open‑source COLA framework with its layered design, extension and specification concepts.

COLA frameworkCQRSHexagonal Architecture
0 likes · 14 min read
Why Architecture Matters: From Basics to the COLA Framework
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
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
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
iQIYI Technical Product Team
iQIYI Technical Product Team
Sep 4, 2020 · Backend Development

Applying Axon Framework and Spring StateMachine in iQIYI Contract Platform: Architecture, Practices, and Lessons

iQIYI’s contract platform replaced a cumbersome Activiti workflow with a lightweight combination of Axon Framework and Spring StateMachine, leveraging DDD, CQRS, and event sourcing to achieve clear layered architecture, traceable events, and flexible state transitions, while confronting distributed‑transaction sagas, batch limits, and integration complexities, and planning future Axon Server adoption.

Axon FrameworkBackend ArchitectureCQRS
0 likes · 11 min read
Applying Axon Framework and Spring StateMachine in iQIYI Contract Platform: Architecture, Practices, and Lessons
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
High Availability Architecture
High Availability Architecture
May 11, 2020 · Backend Development

Understanding CQRS Complexity: Goals, Common Pitfalls, and Practical Solutions

This article examines the CQRS (Command Query Responsibility Segregation) pattern, outlining its objectives, three major complexity traps—over‑isolated commands, event sourcing coupling, and excessive tooling—and offers practical mitigation strategies, including relaxed isolation, alternative projection techniques, and careful service decomposition.

BackendCQRSDesign Patterns
0 likes · 10 min read
Understanding CQRS Complexity: Goals, Common Pitfalls, and Practical Solutions
vivo Internet Technology
vivo Internet Technology
Apr 8, 2020 · Backend Development

Applying Domain Events, Saga, and CQRS in Domain-Driven Design

The article, the second in a DDD practice series, shows how immutable domain events can capture business milestones and be stored and published, introduces Saga—both choreography and orchestration—to manage distributed transactions with compensations, and explains how CQRS separates read and write models, illustrating each concept with Java code while highlighting the resulting decoupling, scalability, and modeling clarity alongside added complexity and storage challenges.

CQRSDomain EventsDomain-Driven Design
0 likes · 21 min read
Applying Domain Events, Saga, and CQRS in Domain-Driven Design
Alibaba Cloud Developer
Alibaba Cloud Developer
Aug 29, 2019 · Fundamentals

Why Architecture Matters: Unpacking Application Design Principles and the COLA Framework

This article explains what software architecture is, why it is essential for any system, the responsibilities of architects, various architecture classifications, and introduces the COLA open‑source framework that combines layered, hexagonal, and onion architectures with CQRS and extensibility to separate business logic from technical details.

COLA frameworkCQRSHexagonal Architecture
0 likes · 14 min read
Why Architecture Matters: Unpacking Application Design Principles and the COLA Framework
Java Backend Technology
Java Backend Technology
Jul 20, 2019 · Backend Development

Mastering CQRS: How to Split Commands and Queries for Scalable Java Backends

This article explains the CQRS pattern, contrasts it with traditional CRUD, outlines its architectural benefits, presents two implementation approaches—including shared and separate databases—and provides a step‑by‑step Java example with command interfaces, a CommandBus, and controller integration, helping developers adopt CQRS in real projects.

CQRSCommand Busjava
0 likes · 8 min read
Mastering CQRS: How to Split Commands and Queries for Scalable Java Backends
Java Captain
Java Captain
Jun 19, 2019 · Backend Development

Understanding Domain-Driven Design (DDD) and Its Role in Solving CRUD Problems

This article introduces Domain‑Driven Design, explains why traditional MVC‑based CRUD approaches lead to heavy, hard‑to‑maintain services, and shows how DDD concepts such as aggregates, bounded contexts, event sourcing and CQRS can clarify business logic, improve micro‑service boundaries, and reduce system complexity.

CQRSCRUDDDD
0 likes · 29 min read
Understanding Domain-Driven Design (DDD) and Its Role in Solving CRUD Problems
JD Tech
JD Tech
Apr 17, 2018 · Operations

Overwatch: A Distributed Real‑Time RPC Monitoring Platform for System Observability

The article describes Overwatch, a distributed monitoring system developed by Dada‑JD Daojia that collects, aggregates, and visualizes RPC traffic in real time using consumer‑side agents, Kafka, Storm, and a Node.js CQRS architecture, enabling engineers to quickly locate and resolve service failures.

CQRSDistributed MonitoringRPC
0 likes · 8 min read
Overwatch: A Distributed Real‑Time RPC Monitoring Platform for System Observability
Alibaba Cloud Developer
Alibaba Cloud Developer
Dec 27, 2017 · Artificial Intelligence

How Alibaba’s AI‑Powered UED Platform Transforms Design Outsourcing

Alibaba’s UED outsourcing platform integrates AI-driven image verification, DDD‑based architecture, CQRS, and API interfaces to streamline design task distribution, real‑time budgeting, automated settlement, and quality assessment, enabling efficient, controllable, and intelligent management of over 700 external designers across the group.

AI verificationAlibabaCQRS
0 likes · 9 min read
How Alibaba’s AI‑Powered UED Platform Transforms Design Outsourcing
Alibaba Cloud Developer
Alibaba Cloud Developer
Dec 15, 2017 · Backend Development

Taming Enterprise Application Complexity: Extension Points, CQRS & DDD

Frank, a senior technical expert at Alibaba International, shares how his team tackled the growing complexity of their legacy CRM system by redesigning the architecture with extensible extension points, metadata, CQRS, DDD, SOLID principles, and disciplined layering to achieve better scalability, maintainability, and code readability.

BackendCQRSDDD
0 likes · 17 min read
Taming Enterprise Application Complexity: Extension Points, CQRS & DDD
Node Underground
Node Underground
Dec 12, 2017 · Backend Development

Mastering CQRS and Event Sourcing: Clean, Scalable Backend Design

This article explains the CQRS (Command Query Responsibility Segregation) and Event Sourcing patterns, outlines their benefits such as clearer logic, stability, and scalability, and discusses practical goals like separating core business logic, using pure functions, and achieving easier testing and horizontal expansion, while warning of added complexity.

CQRSEvent SourcingScalability
0 likes · 3 min read
Mastering CQRS and Event Sourcing: Clean, Scalable Backend Design
Qunar Tech Salon
Qunar Tech Salon
Nov 28, 2017 · Backend Development

Optimizing the TTS Pricing Engine: From Monolithic V1 to Scalable V2 Architecture

This article details the evolution of Qunar's TTS pricing engine from a monolithic V1 implementation with dual-level caching and blocking HTTP interfaces to a scalable V2 architecture featuring service separation, asynchronous processing, CQRS-based rule storage, canal synchronization, Solr and Redis indexing, and Kafka-driven data pipelines.

CQRSSolrcaching
0 likes · 10 min read
Optimizing the TTS Pricing Engine: From Monolithic V1 to Scalable V2 Architecture
Meituan Technology Team
Meituan Technology Team
Oct 26, 2017 · Backend Development

Domain-Driven Design Q&A: Event Handling, Service Design, and Domain Boundaries

The article records a Meituan‑Dianping Q&A on Domain‑Driven Design, where engineers discuss using domain events with transactions, designing RPC interfaces, separating domain and application layers, handling cross‑aggregate operations, and defining bounded contexts, illustrating how DDD guides microservice architecture and business modeling.

CQRSDDDDomain-Driven Design
0 likes · 6 min read
Domain-Driven Design Q&A: Event Handling, Service Design, and Domain Boundaries
Dada Group Technology
Dada Group Technology
Sep 29, 2017 · Operations

Overwatch: A Distributed System Monitoring Platform for Real‑Time RPC Visibility

Overwatch is an open‑source distributed monitoring platform built by Dada‑Jingdong Home that collects, aggregates, and visualizes RPC traffic across thousands of micro‑services in real time, enabling engineers to quickly pinpoint the root cause of system failures using directed‑graph visualizations and CQRS‑based data queries.

CQRSKafkaRPC
0 likes · 10 min read
Overwatch: A Distributed System Monitoring Platform for Real‑Time RPC Visibility
Architecture Digest
Architecture Digest
Apr 4, 2016 · Backend Development

Handling Distributed Transactions in Large‑Scale Microservice Systems

The article examines the challenges of distributed transactions in large‑scale microservice architectures and compares three main approaches—traditional two‑phase commit, stateless queue‑based eventual consistency with event sourcing and CQRS, and transaction compensation techniques such as TCC—highlighting their trade‑offs and real‑world examples like Flipkart.

CQRSDistributed TransactionsEvent Sourcing
0 likes · 8 min read
Handling Distributed Transactions in Large‑Scale Microservice Systems
ITPUB
ITPUB
Feb 19, 2016 · Backend Development

Rethinking 12306 Ticketing: A Domain‑Driven Design Model for High‑Concurrency Reservations

This article analyzes the unique complexities of China's 12306 train ticketing system, proposes a domain‑driven aggregate model centered on train trips, explains seat‑allocation rules and overlapping interval handling, and outlines a CQRS and event‑sourcing architecture to achieve strong consistency and high concurrency.

CQRSDomain-Driven DesignEvent Sourcing
0 likes · 25 min read
Rethinking 12306 Ticketing: A Domain‑Driven Design Model for High‑Concurrency Reservations
21CTO
21CTO
Feb 16, 2016 · Backend Development

Rethinking 12306 Ticketing: A Domain‑Driven Design Model for Complex Train Reservations

This article analyses the unique business complexity of China's 12306 railway ticketing system, proposes a domain‑driven aggregate design centered on the train route, explains how to model seat availability and ticket issuance, and outlines a CQRS/event‑sourcing architecture to achieve strong consistency and high concurrency.

Backend ArchitectureCQRSDDD
0 likes · 25 min read
Rethinking 12306 Ticketing: A Domain‑Driven Design Model for Complex Train Reservations
Qunar Tech Salon
Qunar Tech Salon
May 17, 2015 · Fundamentals

Why CQRS Is Becoming a Practical Architecture for Complex Business Applications

The article explains how the lack of Command‑Query Responsibility Segregation (CQRS) leads to unnecessary complexity, outlines the benefits of read‑write separation, presents a simple e‑commerce example, and summarizes Vladimir Khorikov’s three CQRS types and when to apply them.

CQRSRead-Write SeparationSoftware Architecture
0 likes · 5 min read
Why CQRS Is Becoming a Practical Architecture for Complex Business Applications