BestHub
Sign in
Tagged articles
356 articles
Page 4 of 4
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 26, 2020 · Fundamentals

Why Development Teams Need DDD: Insights, Challenges, and Solutions

In this interview, senior ZTE architect Zhang Xiaolong explains why development teams should adopt Domain‑Driven Design, outlines key practices such as a unified language, layered architecture, and domain events, and discusses common obstacles—including limited case studies and tooling gaps—and offers practical solutions to successfully implement DDD in complex, high‑performance telecom software.

Domain EventsDomain‑Driven Design
0 likes · 6 min read
Why Development Teams Need DDD: Insights, Challenges, and Solutions
Youzan Coder
Youzan Coder
Sep 25, 2020 · Backend Development

Designing a Marketing Reverse Domain for Refund Asset Management

This article explains the business challenges of handling marketing assets during refunds, defines asset types and trigger conditions, and details a domain‑driven backend architecture—including entities, value objects, aggregates, services, and model‑mapping configurations—to implement a configurable reverse‑operation system.

Backend ArchitectureDomain‑Driven DesignMarketing
0 likes · 11 min read
Designing a Marketing Reverse Domain for Refund Asset Management
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
政采云技术
政采云技术
Aug 30, 2020 · Frontend Development

High-Quality Maintainable Code: Data Modeling for Frontend Development

This article explains the fundamentals of data modeling for front‑end development, covering its three core elements, integrity constraints, domain‑driven design, layered architecture, and practical guidelines for building clean, maintainable front‑end data models.

Domain‑Driven DesignFrontendSoftware Architecture
0 likes · 14 min read
High-Quality Maintainable Code: Data Modeling for Frontend Development
NetEase Smart Enterprise Tech+
NetEase Smart Enterprise Tech+
Aug 13, 2020 · Backend Development

How to Master Business Architecture with Layered and Domain‑Driven Design

This article explains how business architecture controls system complexity through layered structures and domain‑driven design, compares traditional three‑tier and microservice architectures, highlights common pitfalls, and offers a lightweight domain‑centric approach for scalable, maintainable backend systems.

Domain‑Driven DesignLayered Architecturebusiness architecture
0 likes · 8 min read
How to Master Business Architecture with Layered and Domain‑Driven Design
DevOps
DevOps
Jul 29, 2020 · Product Management

Integrating Technology and Business: Achieving Product‑Market Fit through Domain‑Driven Design

The article explains how deep integration of technology and business drives enterprise innovation by mastering product‑market fit, outlines a five‑step PMF process, and details how Domain‑Driven Design can be used for systematic domain modeling to build sustainable competitive advantage.

Domain‑Driven Designbusiness innovationproduct-market fit
0 likes · 9 min read
Integrating Technology and Business: Achieving Product‑Market Fit through Domain‑Driven Design
Alibaba Cloud Developer
Alibaba Cloud Developer
Jul 27, 2020 · Fundamentals

How Alibaba Entertainment Uses Domain‑Driven Design to Tackle Complex Systems

This article explains the concepts of Domain‑Driven Design, why it has gained traction in China’s internet industry, and how Alibaba Entertainment applies strategic and tactical DDD practices—such as model annotation, health‑check, and hexagonal architecture—to improve scalability, readability, and maintainability of its micro‑service systems.

Backend DevelopmentDomain‑Driven DesignHexagonal Architecture
0 likes · 13 min read
How Alibaba Entertainment Uses Domain‑Driven Design to Tackle Complex Systems
Qborfy AI
Qborfy AI
Jul 7, 2020 · Frontend Development

Unlock JavaScript Sandboxes, Code Scanning & Front‑End Innovations

This weekly tech roundup explains how JavaScript sandboxes isolate code, details a low‑cost AST‑based code‑scanning approach, compares Vue, React and Angular, and shows how domain‑driven design and CSS variables can streamline modern front‑end development.

CSS VariablesCode ScanningDomain‑Driven Design
0 likes · 7 min read
Unlock JavaScript Sandboxes, Code Scanning & Front‑End Innovations
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 9, 2020 · R&D Management

Unlock Seamless Business‑Dev Collaboration with Event Storming

This article explores the communication gaps that hinder software projects, introduces Event Storming as a visual, collaborative workshop technique, walks through its syntax and practical coupon‑distribution example, connects the outcomes to Domain‑Driven Design, and shows how the method improves alignment between product, business, and engineering teams.

CollaborationDomain‑Driven DesignEvent Storming
0 likes · 14 min read
Unlock Seamless Business‑Dev Collaboration with Event Storming
360 Zhihui Cloud Developer
360 Zhihui Cloud Developer
May 27, 2020 · Backend Development

Mastering Domain-Driven Design in Go: Build a Food Recommendation API

This article walks through a complete Go implementation of a food recommendation API using Domain-Driven Design, covering project setup, layer separation, entity and repository definitions, infrastructure configuration, application services, HTTP interfaces, authentication, and how to run the application.

APIBackend DevelopmentDomain‑Driven Design
0 likes · 19 min read
Mastering Domain-Driven Design in Go: Build a Food Recommendation API
vivo Internet Technology
vivo Internet Technology
May 6, 2020 · Backend Development

Understanding Aggregates, Entities, and Value Objects in Domain-Driven Design

The article explains DDD’s core building blocks—entities identified by persistent IDs, immutable value objects, and aggregates that group related objects under a single root—using a car‑model case study to show how roots enforce invariants, how factories, repositories and lazy‑loaded references fit within a hexagonal architecture, and why these practices improve modular, maintainable software.

AggregatesDomain‑Driven DesignEntities
0 likes · 31 min read
Understanding Aggregates, Entities, and Value Objects in Domain-Driven Design
Beike Product & Technology
Beike Product & Technology
Apr 10, 2020 · R&D Management

Case Study: Evolution of Beike’s Real‑Estate Mid‑Platform Architecture and Service‑Oriented Transformation

Beike’s real‑estate platform transitioned from a monolithic application to a service‑oriented, domain‑driven mid‑platform, detailing the architectural analysis, phased evolution, componentization, data services, and operational insights that enabled scalable, reusable business capabilities across multiple city‑level services.

Domain‑Driven DesignR&D Managementarchitecture
0 likes · 15 min read
Case Study: Evolution of Beike’s Real‑Estate Mid‑Platform Architecture and Service‑Oriented Transformation
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
Meituan Technology Team
Meituan Technology Team
Mar 19, 2020 · Backend Development

Applying Design Patterns and Domain‑Driven Design in Meituan Takeaway Marketing System

The Meituan Takeaway Marketing team shows how combining domain‑driven design with classic patterns such as Factory Method, Strategy, State and Responsibility Chain creates an extensible, maintainable reward system that adapts to rapidly changing business rules while keeping the domain model clean and SOLID‑compliant.

Design PatternsDomain‑Driven DesignFactory Method
0 likes · 25 min read
Applying Design Patterns and Domain‑Driven Design in Meituan Takeaway Marketing System
JD Retail Technology
JD Retail Technology
Feb 24, 2020 · Fundamentals

Understanding Domain-Driven Design: Value, Process, and Architectural Practices

This article explores how Domain-Driven Design (DDD) can address the growing complexity of business and technical requirements in large-scale systems, detailing its strategic and tactical processes, layered and hexagonal architectures, and integration with microservices to achieve flexible, maintainable, and scalable software solutions.

Domain‑Driven DesignHexagonal ArchitectureStrategic Design
0 likes · 42 min read
Understanding Domain-Driven Design: Value, Process, and Architectural Practices
vivo Internet Technology
vivo Internet Technology
Feb 12, 2020 · Backend Development

Understanding Domain-Driven Design: Misconceptions, Principles, and Practical Implementation

Domain‑Driven Design, a mindset rather than a rigid methodology, clarifies business complexity through a central domain model, layered and hexagonal architectures, bounded contexts, and repository patterns—dispelling myths that it suits only large projects or adds excessive boiler‑plate, and showing practical Java implementation.

Clean ArchitectureDomain‑Driven DesignHexagonal Architecture
0 likes · 20 min read
Understanding Domain-Driven Design: Misconceptions, Principles, and Practical Implementation
Alibaba Cloud Developer
Alibaba Cloud Developer
Jan 21, 2020 · Backend Development

COLA 2.0: Redefining Java Backend Architecture with Layered Design & Extensible Components

This article explains how the COLA 2.0 framework restructures Java backend applications by introducing a cleaner layered architecture, redefining components and modules, adding flexible extension points, and providing practical guidance for generating and using COLA‑based services.

COLA frameworkDomain‑Driven DesignExtension Points
0 likes · 18 min read
COLA 2.0: Redefining Java Backend Architecture with Layered Design & Extensible Components
Java High-Performance Architecture
Java High-Performance Architecture
Jan 13, 2020 · Backend Development

10 Proven Practices to Master Microservices Architecture

This article outlines ten essential microservices best practices—from domain‑driven design and independent databases to async communication, observability, and organizational alignment—providing a comprehensive guide for building scalable, maintainable service‑oriented systems.

Domain‑Driven DesignObservabilityarchitecture
0 likes · 7 min read
10 Proven Practices to Master Microservices Architecture
Youzan Coder
Youzan Coder
Jan 8, 2020 · Cloud Native

Youzan Retail Finance Middle Platform Architecture Design and Practice

The article outlines Youzan's retail finance middle platform design, detailing the business background of complex SaaS retail, a structured analysis using layered business, application, data, and technology architectures, and a step‑by‑step implementation that emphasizes reusable domain capabilities and long‑term, standardized middle‑platform development.

Data ArchitectureDomain‑Driven DesignEnterprise Architecture
0 likes · 20 min read
Youzan Retail Finance Middle Platform Architecture Design and Practice
21CTO
21CTO
Nov 16, 2019 · Fundamentals

Why Strategic Design, Not Just Tactical, Is the True Heart of DDD

In this article, Meituan‑Dianping expert Mu Zongyan’s GIAC conference talk highlights that while Domain‑Driven Design has become popular with microservices, its true power lies in strategic design rather than rigid tactical patterns, urging architects to focus on broader business contexts.

DDDDomain‑Driven DesignSoftware Architecture
0 likes · 4 min read
Why Strategic Design, Not Just Tactical, Is the True Heart of DDD
Architects Research Society
Architects Research Society
Nov 16, 2019 · Backend Development

Practical Guide to Domain‑Driven Design: Modeling, Architecture, and Implementation

This article presents a comprehensive, practice‑oriented overview of Domain‑Driven Design, covering its conceptual foundations, project‑level management, architectural layering, design patterns, implementation techniques with Java/Spring, testing, continuous integration, and deployment strategies for enterprise applications.

Domain‑Driven DesignJavacontinuous integration
0 likes · 39 min read
Practical Guide to Domain‑Driven Design: Modeling, Architecture, and Implementation
Architecture Digest
Architecture Digest
Nov 4, 2019 · Fundamentals

From Chaotic Code to Structured Architecture: Reflections on Software Planning and Domain‑Driven Design

The article reflects on the parallels between urban planning and software design, critiques the pitfalls of unplanned legacy systems, outlines a typical three‑layer development workflow, and introduces domain‑driven design concepts as a disciplined approach to building maintainable backend architectures.

Domain‑Driven DesignSoftware Architecturedatabase modeling
0 likes · 12 min read
From Chaotic Code to Structured Architecture: Reflections on Software Planning and Domain‑Driven Design
Architecture Digest
Architecture Digest
Nov 1, 2019 · Fundamentals

Reflections on Transaction System Design: Principles, Patterns, and Evolution

This article reflects on the redesign of a large‑scale transaction system, describing a decision‑making routine that starts from purpose and goals, discusses programming paradigms, SOLID principles, domain‑driven design, bounded contexts, component splitting, layering, and the trade‑offs of patterns such as State and CQRS to achieve a flexible, maintainable backend architecture.

Design PatternsDomain‑Driven DesignSOLID
0 likes · 21 min read
Reflections on Transaction System Design: Principles, Patterns, and Evolution
Architects Research Society
Architects Research Society
Oct 10, 2019 · Fundamentals

An Introduction to Domain-Driven Design Patterns and Practices

This article explains the core concepts of Domain‑Driven Design, including model‑driven design, ubiquitous language, bounded contexts, layered and hexagonal architectures, and key building blocks such as entities, value objects, aggregates, repositories, factories, and services, to help developers build business‑centric enterprise applications.

DDDDomain‑Driven DesignHexagonal Architecture
0 likes · 22 min read
An Introduction to Domain-Driven Design Patterns and Practices
Architecture Digest
Architecture Digest
Sep 12, 2019 · Backend Development

Methodology for Writing Complex Business Code: Process Decomposition and Domain Modeling

This article presents a practical methodology for handling complex business logic by combining top‑down process decomposition with bottom‑up domain modeling, illustrating the approach with a detailed product‑on‑sale use case, code examples, and guidance on avoiding over‑reliance on tooling.

Domain‑Driven DesignSoftware Architecturecode organization
0 likes · 12 min read
Methodology for Writing Complex Business Code: Process Decomposition and Domain Modeling
Youzan Coder
Youzan Coder
Aug 30, 2019 · Backend Development

Domain-Driven Design Practice in Lead Management System: From Theory to Implementation

The article shows how to apply Domain‑Driven Design to construct an education‑sector lead management system, detailing the four‑layer architecture, a four‑color prototype analysis for requirements, core DDD concepts such as entities, value objects, aggregates and repositories, and a concrete implementation of domain models and services.

Aggregate DesignDDD ArchitectureDomain‑Driven Design
0 likes · 18 min read
Domain-Driven Design Practice in Lead Management System: From Theory to Implementation
Alibaba Cloud Developer
Alibaba Cloud Developer
Aug 14, 2019 · Backend Development

Mastering Complex Business Code: Structured Decomposition & Domain Modeling

This article presents a practical methodology for handling complex business scenarios by combining top‑down process decomposition with bottom‑up domain modeling, illustrated through Alibaba's retail‑to‑store product onboarding case, complete with code examples and architectural guidance.

Domain‑Driven DesignSoftware Architecturecode decomposition
0 likes · 14 min read
Mastering Complex Business Code: Structured Decomposition & Domain Modeling
21CTO
21CTO
Aug 9, 2019 · Fundamentals

How Clean Architecture Can Simplify Your Codebase: A Deep Dive into Layered Design

This article explores the principles of Clean Architecture, explains layered thinking and dependency rules, discusses how to apply them in real projects, and reflects on the broader meaning of software architecture, including domain‑driven design and practical advice for developers seeking to improve their design skills.

Clean ArchitectureDependency RuleDomain‑Driven Design
0 likes · 15 min read
How Clean Architecture Can Simplify Your Codebase: A Deep Dive into Layered Design
Mafengwo Technology
Mafengwo Technology
Jul 11, 2019 · Backend Development

How DDD Transformed Our E‑Commerce Discount Center: A Practical Refactor

This article details how applying Domain‑Driven Design to a complex e‑commerce discount system clarified business logic, improved flexibility, and guided a step‑by‑step architectural overhaul from a monolithic model to a layered, domain‑centric solution with tactical and strategic design considerations.

Backend RefactoringDDDDomain‑Driven Design
0 likes · 17 min read
How DDD Transformed Our E‑Commerce Discount Center: A Practical Refactor
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
Architects Research Society
Architects Research Society
Mar 11, 2019 · Fundamentals

An Overview of Domain‑Driven Design Patterns and Practices

Domain-Driven Design (DDD) focuses on modeling core business complexity by building a ubiquitous language, bounded contexts, and layered architectures, and the article explains key DDD patterns such as model‑driven design, aggregates, repositories, factories, services, and hexagonal architecture, illustrated with diagrams and Java code examples.

AggregatesDomain‑Driven DesignHexagonal Architecture
0 likes · 35 min read
An Overview of Domain‑Driven Design Patterns and Practices
Xianyu Technology
Xianyu Technology
Jan 31, 2019 · Backend Development

Business Isolation and Domain Modeling for Xianyu Detail Page Architecture

The article shows how to refactor a tangled Xianyu detail‑page built on legacy MVC by isolating each vertical business with the Strategy pattern, extracting shared services, packaging them as libraries or JARs, and then applying domain‑driven design to create a clean, layered, maintainable architecture.

Business IsolationDomain‑Driven Designarchitecture
0 likes · 11 min read
Business Isolation and Domain Modeling for Xianyu Detail Page Architecture
Continuous Delivery 2.0
Continuous Delivery 2.0
Jan 15, 2019 · Fundamentals

Software Complexity and Domain‑Driven Design: Isolating Business and Technical Concerns

This article explains how software complexity arises from both business requirements and quality attributes, discusses the challenges of technical and business complexity, and demonstrates how Domain‑Driven Design—through layered and hexagonal architectures, bounded contexts, and micro‑service decomposition—helps isolate concerns and manage complexity in large systems.

Domain‑Driven DesignLayered ArchitectureSoftware Architecture
0 likes · 24 min read
Software Complexity and Domain‑Driven Design: Isolating Business and Technical Concerns
Meituan Technology Team
Meituan Technology Team
Dec 20, 2018 · Artificial Intelligence

Demystifying Learning to Rank: From Core Algorithms to Scalable Online Sorting Architecture

This article provides a comprehensive, system‑engineer‑focused guide to Learning to Rank, covering fundamental machine‑learning concepts, evaluation metrics such as Precision, nDCG and ERR, training‑testing‑inference stages, pointwise/pairwise/listwise methods, and a detailed multi‑layer online ranking architecture with feature, model and recall governance.

A/B testingDomain‑Driven DesignLearning-to-Rank
0 likes · 29 min read
Demystifying Learning to Rank: From Core Algorithms to Scalable Online Sorting Architecture
DevOps
DevOps
Nov 9, 2018 · Fundamentals

Applying Domain‑Driven Design: Achieving Consensus and Effective Team Collaboration

The article explains how domain‑driven design helps software teams reach a shared understanding of the problem domain by cultivating requirements through visual collaboration, structured inception and iteration activities, and continuous feedback loops, ultimately improving architecture, reducing miscommunication, and delivering higher‑quality software.

Domain‑Driven DesignSoftware ArchitectureTeam Collaboration
0 likes · 15 min read
Applying Domain‑Driven Design: Achieving Consensus and Effective Team Collaboration
Alibaba Cloud Developer
Alibaba Cloud Developer
Aug 21, 2018 · Backend Development

Mastering Domain‑Driven Design: From Data Models to Rich Domain Objects

This article explores practical Domain‑Driven Design in a B‑to‑B setting, comparing data‑centric and object‑centric modeling, illustrating blood‑loss, anemia, and rich models, and showing how dependency injection, testing strategies, repository abstractions, and deployment architectures can improve software quality and maintainability.

Backend ArchitectureDomain‑Driven DesignRepository Pattern
0 likes · 15 min read
Mastering Domain‑Driven Design: From Data Models to Rich Domain Objects
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 18, 2018 · Backend Development

Design Scalable Java Microservices: Domain Modeling, REST APIs & Versioning

This article explains how to identify, design, and implement Java microservices—from domain‑driven modeling and service boundaries to RESTful API creation, documentation, proper HTTP verbs, and versioning strategies—using examples like an online retail store and the Game On! text adventure.

API VersioningDomain‑Driven DesignREST API
0 likes · 31 min read
Design Scalable Java Microservices: Domain Modeling, REST APIs & Versioning
ITPUB
ITPUB
Jun 27, 2018 · Backend Development

From Monolith to Microservices: Lessons from Three Generations of Payment Architecture

The article shares a senior engineer’s perspective on evolving payment system architectures—from a simple monolithic WAR package, through a duplicated “chimney” style, to a fully modular micro‑service platform—highlighting why each generation fits different business stages and how domain‑driven design supports rapid market growth.

Domain‑Driven DesignSystem architecturebackend design
0 likes · 12 min read
From Monolith to Microservices: Lessons from Three Generations of Payment Architecture
JD Tech
JD Tech
Apr 23, 2018 · Backend Development

Rapid Construction of the 7Fresh Retail System Using Domain‑Driven Design

The article details how JD.com’s 7Fresh retail platform was built in just two and a half months by applying strategic DDD, virtual organization structures, extensive component reuse, and cross‑team collaboration to integrate over 60 systems and dozens of devices for both online and offline operations.

DDDDomain‑Driven DesignSystem architecture
0 likes · 8 min read
Rapid Construction of the 7Fresh Retail System Using Domain‑Driven Design
Alibaba Cloud Developer
Alibaba Cloud Developer
Mar 27, 2018 · Fundamentals

Why Domain Modeling Is Essential for Clean, Scalable Business Logic

This article explains why domain modeling is crucial for managing complex business logic, compares transaction scripts with domain models using a bank transfer example, outlines the benefits of object‑oriented design, and provides practical steps and best practices for building, evolving, and visualizing domain models.

DDDDomain ModelingDomain‑Driven Design
0 likes · 16 min read
Why Domain Modeling Is Essential for Clean, Scalable Business Logic
Meituan Technology Team
Meituan Technology Team
Dec 21, 2017 · Backend Development

Implementing Domain-Driven Design in Microservices Architecture

The article demonstrates how applying Domain‑Driven Design to a lottery platform’s microservices—by defining bounded contexts such as lottery and risk control, modeling aggregates like DrawLottery and AwardPool, using domain services and anti‑corruption layers, and enforcing high cohesion and low coupling—solves over‑coupling and anemic domain model challenges while tightly aligning the system with business logic.

AggregatesBounded ContextDDD
0 likes · 28 min read
Implementing Domain-Driven Design in Microservices Architecture
Java Backend Technology
Java Backend Technology
Dec 9, 2017 · Backend Development

Boost Java Development: Master Lombok for Elegant Get/Set and Code Generation

This article introduces Lombok as a Java code‑simplification tool, explains how to install the IDEA plugin and add the Maven dependency, demonstrates basic and advanced annotation usage, discusses domain‑driven design models, and shows how Lombok can be combined with FreeMarker and MyBatis for automatic code generation.

Backend DevelopmentDomain‑Driven DesignJava
0 likes · 8 min read
Boost Java Development: Master Lombok for Elegant Get/Set and Code Generation
21CTO
21CTO
Nov 23, 2017 · Backend Development

How to Build a Perfect Target Architecture for Microservice Migration

This article shares a payment company's experience planning and executing a microservice transformation, covering the initial blueprint, implementation roadmap, current architectural challenges, key design debates, and the final target architecture diagram to guide a systematic migration.

Domain‑Driven DesignService MigrationSoftware Architecture
0 likes · 10 min read
How to Build a Perfect Target Architecture for Microservice Migration
Architecture Digest
Architecture Digest
Nov 23, 2017 · Backend Development

Microservice Transformation Experience and Target Architecture Design

This article shares the author's experience and lessons learned from a two‑day intensive discussion on microservice migration, outlining a concrete implementation plan, current architectural challenges, key debates, and the final target architecture blueprint for a third‑party payment company.

Backend ArchitectureDomain‑Driven DesignSystem Migration
0 likes · 12 min read
Microservice Transformation Experience and Target Architecture Design
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
Hujiang Technology
Hujiang Technology
Sep 13, 2017 · Backend Development

Domain-Driven Design of an E‑commerce Transaction System

This article explores how to apply Domain‑Driven Design principles to structure and simplify a complex e‑commerce transaction system, detailing sub‑domain division, model refinement, core order‑service design, and the use of design patterns to achieve a maintainable backend architecture.

Design PatternsDomain‑Driven Designe-commerce
0 likes · 10 min read
Domain-Driven Design of an E‑commerce Transaction System
Programmer DD
Programmer DD
Aug 19, 2017 · Backend Development

Decoupling Business Logic with Domain Events Using Guava EventBus

This article explains how to apply Domain‑Driven Design's domain events to separate reply handling from push notification logic, discusses the shortcomings of embedding side‑effects directly, compares Spring and Guava event mechanisms, and provides a custom Guava‑based publisher implementation with synchronous and asynchronous buses.

Domain EventsDomain‑Driven DesignEventBus
0 likes · 8 min read
Decoupling Business Logic with Domain Events Using Guava EventBus
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 5, 2017 · Backend Development

How SOA and DDD Combine to Build Robust Backend Systems

This article explores the definitions of SOA and DDD, explains DDD's layered architecture, demonstrates how business relationships become domain models, and provides concrete C# examples of repositories, services, and factories to illustrate the integration of service‑oriented architecture with domain‑driven design.

Backend ArchitectureC#DDD
0 likes · 18 min read
How SOA and DDD Combine to Build Robust Backend Systems
Architecture Digest
Architecture Digest
Mar 15, 2017 · Fundamentals

The Importance of a Unified Language and Model‑Driven Design in Large‑Scale Distributed Systems

This article discusses the challenges of building large distributed systems, emphasizing the need for a unified internal language, model‑driven design, layered architecture, and clear interface design principles to improve communication, maintainability, and scalability.

Domain‑Driven DesignLayered ArchitectureSoftware Architecture
0 likes · 14 min read
The Importance of a Unified Language and Model‑Driven Design in Large‑Scale Distributed 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.

CQRSConcurrencyDomain‑Driven Design
0 likes · 25 min read
Rethinking 12306 Ticketing: A Domain‑Driven Design Model for High‑Concurrency Reservations
Architect
Architect
Feb 19, 2016 · Backend Development

Domain Modeling and Architecture Design for High‑Concurrency Train Ticketing System (12306)

The article analyzes the complex business rules of China's 12306 train ticketing platform, proposes a domain‑driven design where the train aggregate root manages seat inventory and interval overlap, and outlines a CQRS/event‑sourcing architecture to achieve strong consistency and high concurrency.

CQRSDomain‑Driven DesignEvent Sourcing
0 likes · 23 min read
Domain Modeling and Architecture Design for High‑Concurrency Train Ticketing System (12306)
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
Dec 6, 2014 · Fundamentals

Why Code Becomes Unreadable Over Time and How to Keep It Simple

The article explains how over‑complex mental models, poor translation of semantic ideas into code, inadequate naming, missing design chunks, unclear usage patterns, and lack of smooth model transitions cause code to decay, and offers practical principles such as DDD, SRP, good naming, testing, and reusing existing algorithms to maintain readability.

Domain‑Driven Designcode readabilitymental models
0 likes · 10 min read
Why Code Becomes Unreadable Over Time and How to Keep It Simple