BestHub
Sign in
Tagged articles
356 articles
Page 1 of 4
ZhiKe AI
ZhiKe AI
Jun 1, 2026 · Backend Development

Balancing Software Architecture Choices in Real Projects

The article explains that software architecture is fundamentally about trade‑offs, categorises major architecture families such as DDD, Clean/Hexagonal/Onion, Microservices vs SOA, CQRS/Event Sourcing, MVC, PACELC, BASE, FLP, Repository and 12‑Factor principles, and shows how each addresses specific constraints to help engineers pick the most suitable design for their context.

CAPClean ArchitectureDesign Patterns
0 likes · 12 min read
Balancing Software Architecture Choices in Real Projects
ZhiKe AI
ZhiKe AI
May 14, 2026 · Fundamentals

Why DDD Is a Cognitive Alignment Tool, Not Just an Architecture

The article explains how Domain‑Driven Design addresses the pitfalls of bloated services, unclear boundaries, and inconsistent terminology by introducing bounded contexts, aggregates, and domain events, and outlines a step‑by‑step adoption process while debunking common misconceptions.

AggregatesBounded ContextDomain Events
0 likes · 9 min read
Why DDD Is a Cognitive Alignment Tool, Not Just an Architecture
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Apr 9, 2026 · Fundamentals

Mastering Domain-Driven Design: Core Concepts and Practical Guide

Domain-Driven Design (DDD) centers software architecture on business domains, breaking complex problems into clear subdomains, defining bounded contexts, ubiquitous language, and key building blocks such as entities, value objects, and aggregates, while guiding layered architecture and microservice decomposition for maintainable, collaborative systems.

DDDDomain‑Driven Designmodeling
0 likes · 7 min read
Mastering Domain-Driven Design: Core Concepts and Practical Guide
IT Architects Alliance
IT Architects Alliance
Mar 30, 2026 · Industry Insights

How Domain‑Driven Design Turns Complex Business Logic into Clear Code

This article explains why domain models are needed, walks through DDD's strategic and tactical design concepts, demonstrates a full knowledge‑payment platform case with bounded contexts, aggregates, and ubiquitous language, and outlines practical guidelines and limitations for applying DDD in real projects.

AggregateDomain‑Driven DesignStrategic Design
0 likes · 10 min read
How Domain‑Driven Design Turns Complex Business Logic into Clear Code
Java Tech Enthusiast
Java Tech Enthusiast
Feb 13, 2026 · Backend Development

How DDD + CQRS Can Turn Chaotic Java Code into Clean, Scalable Architecture

This guide shows how to break down tangled Java services using Domain‑Driven Design and Command‑Query Responsibility Segregation, providing concrete terminology, layered diagrams, code examples, and step‑by‑step migration strategies to improve maintainability, performance, and team communication.

CQRSDDDDomain‑Driven Design
0 likes · 14 min read
How DDD + CQRS Can Turn Chaotic Java Code into Clean, Scalable Architecture
java1234
java1234
Feb 7, 2026 · Backend Development

Why Service Layer Should Not Return a Result Object in Java

The article explains why returning a generic Result wrapper from a Java service layer breaks responsibility separation, harms reusability, complicates exception handling and testing, and obscures transaction boundaries, advocating for returning pure domain objects instead.

Design PrinciplesDomain‑Driven DesignException Handling
0 likes · 13 min read
Why Service Layer Should Not Return a Result Object in Java
Java Companion
Java Companion
Feb 7, 2026 · Backend Development

Why Should the Service Layer in Java Not Return a Result Object Directly?

The article explains that returning a Result wrapper from the Service layer mixes business logic with presentation concerns, leading to tighter coupling, reduced reusability, cumbersome error handling, harder testing, poorer DDD alignment, limited interface flexibility, and ambiguous transaction boundaries.

Domain‑Driven DesignException HandlingResult Wrapper
0 likes · 11 min read
Why Should the Service Layer in Java Not Return a Result Object Directly?
FunTester
FunTester
Jan 17, 2026 · Backend Development

How AI‑Assisted Refactoring Turned a Legacy Java Module into a Clean, Maintainable Service

A three‑year‑old Java module riddled with technical debt was systematically refactored using AI tools, following a four‑stage plan of analysis, problem identification, solution design, and incremental implementation, while establishing rigorous verification to ensure safety and quality.

AI-assisted refactoringDomain‑Driven DesignTechnical debt
0 likes · 15 min read
How AI‑Assisted Refactoring Turned a Legacy Java Module into a Clean, Maintainable Service
dbaplus Community
dbaplus Community
Jan 13, 2026 · Backend Development

How AI‑Driven DDD Refactoring Cut Service Package Development from Days to Hours

This article presents a detailed case study of using AI to assist domain‑driven design (DDD) for refactoring Taobao's monolithic flash‑sale service‑package system, showing how automated context extraction, code skeleton generation, and AI‑augmented implementation reduced development effort from 5‑8 person‑days to a configurable solution while improving architecture decoupling, code quality, and extensibility.

AIDomain‑Driven DesignMicroservices
0 likes · 15 min read
How AI‑Driven DDD Refactoring Cut Service Package Development from Days to Hours
Code Wrench
Code Wrench
Jan 8, 2026 · Backend Development

From Hexagonal Architecture to DDD: A Practical Evolution Path for Your System

This article explains how hexagonal architecture serves as a solid foundation for gradually introducing domain‑driven design, outlines the stages of evolution, highlights common pitfalls, and provides concrete code examples to help teams decide when to move beyond hexagonal alone.

Clean ArchitectureDDDDomain‑Driven Design
0 likes · 8 min read
From Hexagonal Architecture to DDD: A Practical Evolution Path for Your System
Architect
Architect
Jan 2, 2026 · Backend Development

How DDD Transforms Spring Cloud Alibaba Microservices: A Practical Guide

This article explains the fundamentals of Domain‑Driven Design, its core principles and two design phases, then shows how to apply DDD within a Spring Cloud Alibaba e‑commerce microservice system, providing a detailed layered architecture, file‑structure example, and recommendations for implementation.

DDDDomain‑Driven DesignMicroservices
0 likes · 11 min read
How DDD Transforms Spring Cloud Alibaba Microservices: A Practical Guide
DaTaobao Tech
DaTaobao Tech
Dec 31, 2025 · Backend Development

How AI Transformed a Taobao Service‑Package System with Domain‑Driven Design

This article examines how a rapidly growing Taobao flash‑sale service‑package system suffered from high development costs, duplicated code, and tight coupling, and shows how AI‑assisted domain‑driven design was applied to refactor the architecture, automate code generation, and dramatically improve efficiency, maintainability, and extensibility.

AIBackend RefactoringDomain‑Driven Design
0 likes · 13 min read
How AI Transformed a Taobao Service‑Package System with Domain‑Driven Design
ITPUB
ITPUB
Dec 28, 2025 · Backend Development

AI-Driven DDD Refactoring: From Monolithic Service Packages to Modular Architecture

Using AI to assist domain-driven design, this case study details how a monolithic Taobao service-package system was analyzed, restructured, and refactored, reducing development effort from 5-8 person-days per package to configuration-based implementation while eliminating duplicated code and improving modularity, testability, and scalability.

AIDomain‑Driven DesignSoftware Architecture
0 likes · 16 min read
AI-Driven DDD Refactoring: From Monolithic Service Packages to Modular Architecture
Architect's Journey
Architect's Journey
Dec 8, 2025 · Backend Development

COLA‑DDD Layered Architecture: A Powerful Tool for Decoupling and Refactoring

The article explains how the COLA‑DDD layered architecture merges Clean Object‑Oriented and Layered Architecture with Domain‑Driven Design to eliminate large‑muddy code, improve iteration speed, enhance scalability, and provide clear layer boundaries, CQRS, event‑driven processing, and low‑risk technical evolution.

COLADDDDecoupling
0 likes · 11 min read
COLA‑DDD Layered Architecture: A Powerful Tool for Decoupling and Refactoring
Architect's Journey
Architect's Journey
Dec 5, 2025 · Backend Development

Capacity‑Driven Microservice Architecture: Solving High‑Concurrency Challenges

The article explains how a capacity‑driven microservice architecture uses performance metrics like QPS, TPS, and latency as the primary split criterion, detailing design principles, module responsibilities, and practical benefits that enable systems to handle traffic spikes without service collapse.

Domain‑Driven DesignMicroservicescapacity‑driven architecture
0 likes · 10 min read
Capacity‑Driven Microservice Architecture: Solving High‑Concurrency Challenges
php Courses
php Courses
Dec 4, 2025 · Backend Development

From Procedural PHP to Modern Practices: Transform Your Development Mindset

This article examines how early PHP developers often wrote tangled, procedural code that mixes business logic with presentation, and outlines concrete steps—adopting OOP, design patterns, domain‑driven design, test‑driven development, and modern tooling—to shift toward a cleaner, more maintainable backend development approach.

Backend DevelopmentDesign PatternsDomain‑Driven Design
0 likes · 7 min read
From Procedural PHP to Modern Practices: Transform Your Development Mindset
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 9, 2025 · Backend Development

Why I Stopped Using DDD: Real‑World Pain Points and Lessons Learned

The article shares the author's practical frustrations with Domain‑Driven Design—covering confusing CQRS classifications, ambiguous aggregate‑root boundaries, performance conflicts, and the high time cost—while offering concrete examples, code snippets, and a candid conclusion that DDD should be applied judiciously rather than dogmatically.

CQRSDDDDomain‑Driven Design
0 likes · 25 min read
Why I Stopped Using DDD: Real‑World Pain Points and Lessons Learned
Su San Talks Tech
Su San Talks Tech
Nov 2, 2025 · Fundamentals

Unraveling Complex Systems: Key Architecture Principles and Design Strategies

This article explains what constitutes a complex system, defines software architecture, explores various architecture types, outlines key design factors, presents analysis methods like DDD, and reviews typical solutions such as microservices, cloud‑native, DevOps, and big‑data architectures for building robust, scalable systems.

Complex SystemsDesign PrinciplesDomain‑Driven Design
0 likes · 16 min read
Unraveling Complex Systems: Key Architecture Principles and Design Strategies
Architect
Architect
Nov 1, 2025 · Fundamentals

What Makes a Complex System? Unveiling the Core Principles of Software Architecture

Complex systems are composed of many interacting components, and understanding their architecture—from business and application layers to technical, data, microservice, cloud‑native, and DevOps designs—requires grasping core principles, requirements, and design patterns that ensure reliability, scalability, and long‑term value.

Complex SystemsDesign PrinciplesDomain‑Driven Design
0 likes · 17 min read
What Makes a Complex System? Unveiling the Core Principles of Software Architecture
Architect
Architect
Sep 18, 2025 · Fundamentals

Why Modeling Is the Hardest Puzzle in Software Architecture – A Deep Dive

This article explores the essential role of modeling in software engineering, outlines the three main types of modeling, examines why modeling remains a persistent challenge due to language ambiguity and real‑world complexity, and provides practical guidance on business and domain modeling for architects.

Business AnalysisDomain‑Driven DesignSoftware Modeling
0 likes · 16 min read
Why Modeling Is the Hardest Puzzle in Software Architecture – A Deep Dive
DaTaobao Tech
DaTaobao Tech
Sep 5, 2025 · Fundamentals

What the ‘Big Mud Ball’ Teaches About Modern Software Architecture

The article explores core software architecture challenges through eight resonant concepts—big mud ball, independent value, domain division, concept design, classification perspective, domain thickness, global versus local, and scaffolding—offering practical strategies to avoid code chaos, clarify responsibilities, and foster engineering excellence.

Domain‑Driven DesignSoftware ArchitectureTechnical debt
0 likes · 14 min read
What the ‘Big Mud Ball’ Teaches About Modern Software Architecture
IT Architects Alliance
IT Architects Alliance
Aug 31, 2025 · Backend Development

7 Common Architecture Mistakes Chinese Developers Make and How to Fix Them

After analyzing thousands of Chinese projects, the article reveals seven pervasive architecture design pitfalls—overreliance on frameworks, chasing trends, neglecting domain modeling, ignoring evolution, overlooking non‑functional requirements, lacking team standards, and weak testing—offering practical guidance to adopt business‑driven, scalable, maintainable designs.

Domain‑Driven DesignMicroservicesSoftware Architecture
0 likes · 9 min read
7 Common Architecture Mistakes Chinese Developers Make and How to Fix Them
Zhuanzhuan Tech
Zhuanzhuan Tech
Aug 1, 2025 · Fundamentals

Unlock Faster, Clearer Software Design with Event Storming: A Practical Guide

This article explains how Event Storming—a collaborative, sticky‑note‑driven workshop—helps teams break down complex business processes into events, commands, aggregates and policies, dramatically speeding up requirements analysis, improving model quality, and turning the resulting model directly into code and living documentation.

Agile CollaborationDomain‑Driven DesignEvent Storming
0 likes · 14 min read
Unlock Faster, Clearer Software Design with Event Storming: A Practical Guide
Tencent Cloud Developer
Tencent Cloud Developer
Jul 22, 2025 · Fundamentals

Why Good Software Architecture Is the Key to Solving Complex Business Problems

This article explores the essence of software architecture, tracing its definition, its role in solving division‑of‑labor challenges, and how a pragmatic, balanced design that treats architecture as software design itself can deliver sustainable value while navigating business complexity, team coordination, and evolving requirements.

Design PrinciplesDomain‑Driven DesignSoftware Architecture
0 likes · 47 min read
Why Good Software Architecture Is the Key to Solving Complex Business Problems
Code Ape Tech Column
Code Ape Tech Column
Jul 14, 2025 · Backend Development

Mastering Hexagonal Architecture in Spring Boot: 3 Implementation Strategies

This article explains the fundamentals of hexagonal (ports‑and‑adapters) architecture, presents three ways to implement it in Spring Boot—including a classic version, a DDD‑enhanced version, and a simplified variant—while analyzing their advantages, disadvantages, and suitable scenarios.

Domain‑Driven DesignHexagonal ArchitectureSoftware Architecture
0 likes · 35 min read
Mastering Hexagonal Architecture in Spring Boot: 3 Implementation Strategies
Code Ape Tech Column
Code Ape Tech Column
Jul 10, 2025 · Backend Development

Why DDD Is the Missing Piece in Your Microservices Architecture

This article explains how Domain‑Driven Design (DDD) complements microservice architecture by addressing functional partitioning gaps, guiding system decomposition, and improving scalability, while also highlighting common microservice pitfalls and practical steps for clear bounded‑context modeling.

Backend DevelopmentDomain‑Driven DesignMicroservices
0 likes · 9 min read
Why DDD Is the Missing Piece in Your Microservices Architecture
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Jul 8, 2025 · Backend Development

Master DDD: Practical Guide to Domain‑Driven Design Architecture with Code

This article introduces the fundamentals of Domain‑Driven Design (DDD), explains key concepts such as rich domain models, entities, value objects, aggregates, repositories, adapters, and application orchestration, and demonstrates their implementation through comprehensive Java code examples and a complete project structure diagram.

DDDDomain‑Driven DesignRepository
0 likes · 15 min read
Master DDD: Practical Guide to Domain‑Driven Design Architecture with Code
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jun 6, 2025 · Backend Development

How to Split Services Effectively: Principles, Real Cases, and Domain Modeling

This article explains why overly fine‑grained service splitting hurts performance and debugging, shows best‑practice granularity aligned with team size, introduces evolutionary splitting based on model responsibilities, and walks through real‑world case studies, domain‑driven design concepts, architectural patterns such as hexagonal, CQRS, and event‑driven designs, and practical steps for building a robust service‑oriented system.

CQRSDomain‑Driven DesignEvent-driven
0 likes · 6 min read
How to Split Services Effectively: Principles, Real Cases, and Domain Modeling
Baidu Geek Talk
Baidu Geek Talk
May 21, 2025 · Backend Development

Applying Domain‑Driven Design to Build Maintainable and Scalable Backend Architecture

This article explains how the increasing complexity of business logic in modern backend systems leads to tangled code, and demonstrates how strategic and tactical Domain‑Driven Design (DDD) concepts—such as bounded contexts, aggregates, entities, value objects, repositories, and application services—can decouple business and technology, improve maintainability, extensibility, and stability, and guide practical layered architecture implementation.

Backend ArchitectureDDDDomain‑Driven Design
0 likes · 30 min read
Applying Domain‑Driven Design to Build Maintainable and Scalable Backend Architecture
DaTaobao Tech
DaTaobao Tech
May 14, 2025 · Backend Development

How a 2‑Year Journey Unified Java Backend Code Structure for Better Readability and Maintenance

This article shares a two‑and‑a‑half year effort to standardize code style and architecture across a large Java backend, detailing the origins, evolving patterns, a unified layered model, concrete implementation examples, measurable benefits, and future directions for continuous improvement.

Backend ArchitectureDomain‑Driven DesignService Layer
0 likes · 16 min read
How a 2‑Year Journey Unified Java Backend Code Structure for Better Readability and Maintenance
Java Tech Enthusiast
Java Tech Enthusiast
Apr 20, 2025 · Backend Development

Understanding Domain-Driven Design (DDD) with Practical Examples

Domain‑Driven Design (DDD) aligns software structure with business concepts by embedding rules in rich domain models, using aggregates, domain services, and events, contrasting with traditional anemic layers, and is ideal for complex, evolving domains such as e‑commerce, finance, or ERP systems.

Backend DevelopmentDDDDesign Patterns
0 likes · 9 min read
Understanding Domain-Driven Design (DDD) with Practical Examples
dbaplus Community
dbaplus Community
Apr 9, 2025 · Backend Development

How DDD and Hexagonal Architecture Revamp Huolala’s CRM System

This article explores how Domain‑Driven Design and hexagonal (clean) architecture were applied to Huolala’s user CRM, detailing the tactical design patterns, module breakdown, code examples, and the step‑by‑step migration that improved scalability, maintainability, and development efficiency.

DDDDomain‑Driven DesignHexagonal Architecture
0 likes · 43 min read
How DDD and Hexagonal Architecture Revamp Huolala’s CRM System
Architecture Breakthrough
Architecture Breakthrough
Mar 31, 2025 · Fundamentals

Why Mastering Abstraction Is the Real Skill Behind Great Software Design

The article explains that while encapsulation, inheritance, and polymorphism are often highlighted, true software craftsmanship hinges on the ability to abstract—identifying essential features, discarding irrelevant details, and modeling problem domains through steps like analysis, concept extraction, and system design, supported by principles such as low coupling, high cohesion, sufficiency, and completeness.

CohesionCouplingDesign Principles
0 likes · 10 min read
Why Mastering Abstraction Is the Real Skill Behind Great Software Design
Architecture Breakthrough
Architecture Breakthrough
Mar 4, 2025 · Product Management

How Business Knowledge Can Future‑Proof Your Development Career in the AI Age

The article explains why developers must combine deep business understanding with AI tools, outlines a three‑layer domain model (core, generic, supporting), debunks common misconceptions, and provides a step‑by‑step methodology for mastering banking business concepts to boost ROI and career resilience.

AI integrationDomain‑Driven DesignProcess Improvement
0 likes · 21 min read
How Business Knowledge Can Future‑Proof Your Development Career in the AI Age
37 Interactive Technology Team
37 Interactive Technology Team
Feb 19, 2025 · Fundamentals

Domain-Driven Design (DDD) and Microservice Architecture: Concepts, Patterns, and Refactoring Strategies

The article explains how Domain‑Driven Design combined with microservice architecture can restructure a monolithic transaction system by defining bounded contexts, applying patterns such as layered architecture, CQRS and event‑driven communication, and refactoring domains to improve maintainability, scalability, and business clarity.

Bounded ContextCQRSDomain‑Driven Design
0 likes · 9 min read
Domain-Driven Design (DDD) and Microservice Architecture: Concepts, Patterns, and Refactoring Strategies
Architect's Journey
Architect's Journey
Jan 22, 2025 · Backend Development

Deep Dive into DDD Rich Model: Best Practices

The article explains the DDD rich (or active) model, its core characteristics, compares it with the anemic model, and shows how to apply it in a shared‑rental billing domain using Java, DDD layers, domain events, and a lightweight framework.

Backend ArchitectureDDDDomain Events
0 likes · 10 min read
Deep Dive into DDD Rich Model: Best Practices
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Jan 15, 2025 · Backend Development

Principles and Guidelines for Splitting Microservices

This article discusses why and how to split monolithic applications into microservices, outlining common pitfalls of over‑splitting and presenting practical principles such as team and domain isolation, the three‑person rule, read/write separation, dependency management, and service count guidelines.

Backend ArchitectureDomain‑Driven DesignMicroservices
0 likes · 15 min read
Principles and Guidelines for Splitting Microservices
Eric Tech Circle
Eric Tech Circle
Jan 14, 2025 · Backend Development

DDD vs MVC: Practical Trade‑offs, Pitfalls, and When to Keep It Simple

This article compares Domain‑Driven Design and MVC, outlines the architectural changes such as dependency inversion and layer separation, examines common drawbacks in real projects, and offers concrete guidance on when to adopt DDD, blend it with MVC, or stick to a lightweight CRUD‑centric approach.

Backend ArchitectureBest PracticesDDD
0 likes · 9 min read
DDD vs MVC: Practical Trade‑offs, Pitfalls, and When to Keep It Simple
Huolala Tech
Huolala Tech
Jan 10, 2025 · Backend Development

How DDD and Hexagonal Architecture Transform a CRM System – A Practical Walkthrough

This article explores the practical application of Domain‑Driven Design and hexagonal architecture in a real‑world CRM system, detailing strategic and tactical design, module division, code examples, and a step‑by‑step migration from a traditional layered architecture to a more flexible, maintainable backend solution.

Backend DevelopmentDDDDomain‑Driven Design
0 likes · 49 min read
How DDD and Hexagonal Architecture Transform a CRM System – A Practical Walkthrough
DaTaobao Tech
DaTaobao Tech
Jan 8, 2025 · Fundamentals

Domain‑Driven and Process‑Driven Code Design Patterns

The article proposes a domain‑model‑driven code paradigm—defining clear business models, core domain objects, and infrastructure abstractions like repositories, facades, and factories—while contrasting it with process‑driven designs using ability nodes and chains, arguing that these patterns cut repetitive effort and boost maintainability.

Ability PatternDomain‑Driven DesignProcess-Driven
0 likes · 16 min read
Domain‑Driven and Process‑Driven Code Design Patterns
Alibaba Cloud Developer
Alibaba Cloud Developer
Jan 3, 2025 · Fundamentals

Master System Design: From Mindset to Architecture – A Complete Knowledge Framework

This comprehensive guide walks readers through the entire system design process, covering problem definition, key concepts, system analysis, modeling techniques, architectural thinking, design tools, requirements gathering, domain‑driven and use‑case modeling, design principles, patterns, and practical architecture delivery.

Domain‑Driven DesignSystem Designmodeling
0 likes · 43 min read
Master System Design: From Mindset to Architecture – A Complete Knowledge Framework
Java Tech Enthusiast
Java Tech Enthusiast
Dec 31, 2024 · Backend Development

Discussion on Adopting Domain-Driven Design (DDD) in a Growing Business

The team concluded that adopting Domain‑Driven Design can be valuable, but only when a company can afford the upfront investment, has a shared language and cross‑department collaboration, possesses strong OOP expertise, and maintains a culture supportive of the required organizational change.

Backend DevelopmentDDDDomain‑Driven Design
0 likes · 4 min read
Discussion on Adopting Domain-Driven Design (DDD) in a Growing Business
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Dec 30, 2024 · Backend Development

Comprehensive Introduction to Domain-Driven Design (DDD)

This article provides a comprehensive overview of Domain-Driven Design (DDD), explaining its core principles, layered architecture, domain model components such as entities, value objects, aggregates, and bounded contexts, and includes Java code examples to illustrate implementation.

Backend DevelopmentDDDDesign Patterns
0 likes · 6 min read
Comprehensive Introduction to Domain-Driven Design (DDD)
DataFunSummit
DataFunSummit
Dec 29, 2024 · Big Data

Ant Group Data Architecture Practice and Upgrade Strategy

This article shares Ant Group's practical experience and evolution of data architecture, covering theoretical foundations, analysis of current challenges, proposed upgrade solutions based on domain‑driven design, and future outlook through complex network theory to improve scalability, governance, and resilience of large‑scale data systems.

Ant GroupData ArchitectureDomain‑Driven Design
0 likes · 19 min read
Ant Group Data Architecture Practice and Upgrade Strategy
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Dec 23, 2024 · Fundamentals

Mastering Domain-Driven Design: A Complete Guide to DDD Principles

This article provides a comprehensive introduction to Domain‑Driven Design (DDD), covering its origins, core principles, layered architecture, key concepts such as entities, value objects, aggregates, bounded contexts, and how DDD improves communication and maintainability in complex software systems.

Bounded ContextDomain‑Driven DesignEntity
0 likes · 6 min read
Mastering Domain-Driven Design: A Complete Guide to DDD Principles
SQB Blog
SQB Blog
Nov 29, 2024 · Backend Development

How We Unified Retail and Catering Product Platforms with DDD‑Driven Architecture

This article details the step‑by‑step architectural evolution that merged retail and catering product systems into a shared, extensible platform using domain‑driven design, service standardization, and incremental vertical and horizontal upgrades to reduce technical debt and improve scalability.

CateringDomain‑Driven DesignMicroservices
0 likes · 13 min read
How We Unified Retail and Catering Product Platforms with DDD‑Driven Architecture
Architect
Architect
Nov 23, 2024 · Backend Development

Applying Domain‑Driven Design to the Evolution of Meituan Dianping Transaction System

This article explains how Meituan Dianping’s transaction platform evolved through three architectural stages—simple monolith, micro‑service, and platform—by adopting Domain‑Driven Design concepts such as ubiquitous language, bounded contexts, and iterative modeling to manage growing business complexity and improve system maintainability.

Domain‑Driven DesignMeituanMicroservices
0 likes · 20 min read
Applying Domain‑Driven Design to the Evolution of Meituan Dianping Transaction System
JD Tech
JD Tech
Nov 18, 2024 · Backend Development

From Campus to Backend Engineer: Growth, System Refactoring, and AI Assistant at JD

This article shares a recent graduate's journey into backend development at JD, offering practical advice for newcomers, detailing a large‑scale system refactor using domain‑driven design, discussing the creation of an AI‑powered merchant assistant, and emphasizing continuous learning and professional growth.

AIDomain‑Driven DesignSystem Design
0 likes · 13 min read
From Campus to Backend Engineer: Growth, System Refactoring, and AI Assistant at JD
Architect
Architect
Nov 17, 2024 · Backend Development

How to Refactor a Multi‑Tenant Service to Reduce Coupling and Code Bloat

The article presents a real‑world case of a multi‑tenant system whose business logic was tightly coupled across tenants, leading to a massive service class, and demonstrates how applying Domain‑Driven Design, the Dependency Inversion Principle, and the Factory pattern can restructure the code into isolated tenant‑specific actions, improving maintainability and testability.

Backend ArchitectureCode RefactoringDependency Inversion
0 likes · 6 min read
How to Refactor a Multi‑Tenant Service to Reduce Coupling and Code Bloat
Architect
Architect
Nov 16, 2024 · Industry Insights

Ctrip’s Journey: Transforming the Account System from Monolith to Multi‑Region Platform

This article examines Ctrip’s evolution of its account system—from a monolithic service to a domain‑driven, middle‑platform architecture with multi‑region deployment—detailing the motivations, domain restructuring, read/write comparison process, configuration‑driven capabilities, and routing strategies that enable scalable, reliable user management.

Backend ArchitectureDomain‑Driven DesignMicroservices
0 likes · 15 min read
Ctrip’s Journey: Transforming the Account System from Monolith to Multi‑Region Platform
Java Tech Enthusiast
Java Tech Enthusiast
Oct 7, 2024 · Backend Development

Domain-Driven Design (DDD) Architecture: Concepts, Layers, and Practices

Domain‑Driven Design (DDD) structures software around a rich domain model—entities, value objects, aggregates, and services—organized into UI, application, domain, and infrastructure layers, employing patterns such as aggregate roots, domain events, and event‑driven microservices to improve maintainability, scalability, and collaboration between developers and domain experts.

DDDDomain‑Driven Designjava
0 likes · 41 min read
Domain-Driven Design (DDD) Architecture: Concepts, Layers, and Practices
JD Tech
JD Tech
Sep 23, 2024 · Backend Development

Evolution of JD Advertising System Architecture: From Monolithic Code to Domain‑Driven Design

This article outlines the step‑by‑step architectural evolution of JD's advertising platform, describing how the system progressed from a simple, tightly coupled codebase through context‑based designs to a domain‑driven, capability‑oriented architecture that improves extensibility, reuse, stability, and knowledge transfer.

Code ReuseDomain‑Driven DesignSystem Design
0 likes · 24 min read
Evolution of JD Advertising System Architecture: From Monolithic Code to Domain‑Driven Design
JD Retail Technology
JD Retail Technology
Sep 23, 2024 · Backend Development

Evolution of JD Advertising System Architecture: From Simple Code to Domain‑Driven Design

This article chronicles the multi‑generation architectural evolution of JD's advertising platform, explaining why a good code architecture must be extensible, reusable, maintainable and stable, and describing how domain‑driven design, aggregates, and ability orchestration were introduced to solve the challenges of complex, multi‑scenario business requirements.

AggregatesDomain‑Driven Designarchitecture
0 likes · 22 min read
Evolution of JD Advertising System Architecture: From Simple Code to Domain‑Driven Design
JD Cloud Developers
JD Cloud Developers
Sep 6, 2024 · Fundamentals

How to Tame Business System Complexity: Strategies and Best Practices

This article explains what software complexity means, how it is measured and classified, outlines the negative impacts of high business complexity, and presents concrete architectural, coding, and configuration techniques to reduce complexity and improve maintainability.

Code RefactoringDomain‑Driven DesignSystem Architecture
0 likes · 13 min read
How to Tame Business System Complexity: Strategies and Best Practices
JD Tech Talk
JD Tech Talk
Sep 6, 2024 · Fundamentals

Overview of Software Complexity and Strategies for Reducing Business System Complexity

The article explains the concept and measurement of software complexity, its impact on development cost and stability, common causes in business systems, and presents a set of architectural, coding, and configuration practices—including domain splitting, layered design, clear commenting, and configurable rules—to effectively reduce and manage complexity.

Best PracticesCode RefactoringDomain‑Driven Design
0 likes · 12 min read
Overview of Software Complexity and Strategies for Reducing Business System Complexity
DevOps
DevOps
Sep 4, 2024 · Fundamentals

Concept‑Driven Software Design: From Daniel Jackson’s “Concept” to Business‑Service‑Driven Development with AI Assistance

The article analyses Daniel Jackson’s concept‑driven software design presented at the 2024 Global Software R&D Conference, relates it to domain‑driven design and business services, and demonstrates how AI‑augmented prompts can generate Java domain models and a Spring‑Boot RESTful API for order submission.

AI-assisted developmentDomain‑Driven Designbusiness services
0 likes · 17 min read
Concept‑Driven Software Design: From Daniel Jackson’s “Concept” to Business‑Service‑Driven Development with AI Assistance
JD Retail Technology
JD Retail Technology
Aug 19, 2024 · Interview Experience

From Campus to Backend Engineer: 3 Years of Growth at JD

This article shares a recent graduate's three‑year journey at JD, offering practical advice for newcomers, detailing a large‑scale system redesign for a merchant conference, outlining promotion‑season preparation, and describing the development of an AI assistant while emphasizing continuous learning and professional mindset.

AI assistantBackend DevelopmentDomain‑Driven Design
0 likes · 12 min read
From Campus to Backend Engineer: 3 Years of Growth at JD
Eric Tech Circle
Eric Tech Circle
Aug 11, 2024 · Backend Development

Reshaping a Microservice with DDD: A Practical Layered Architecture Guide

This article shares the author's experience of redesigning a microservice using Domain‑Driven Design, detailing a standardized layered architecture, directory structure, model conversions, common pitfalls, and practical recommendations to improve code clarity and testing efficiency.

Backend DevelopmentDDDDomain‑Driven Design
0 likes · 13 min read
Reshaping a Microservice with DDD: A Practical Layered Architecture Guide
Top Architect
Top Architect
Aug 6, 2024 · Backend Development

Why and How to Adopt Microservices: Principles, Design Strategies, and Comparison with Other Architectures

The article explains why microservices have become a mainstream architectural style, outlines the problems of monolithic systems, presents core microservice characteristics, offers practical decomposition principles and patterns, compares microservices with monolith, distributed, serverless, SOA and service‑mesh architectures, and lists common technology stacks for implementation.

Backend ArchitectureDomain‑Driven Designcloud-native
0 likes · 26 min read
Why and How to Adopt Microservices: Principles, Design Strategies, and Comparison with Other Architectures
Architecture and Beyond
Architecture and Beyond
Aug 3, 2024 · Fundamentals

Domain-Driven Design: Core Principles, Practices, and Lessons for Technical Team Management

This article explains Domain-Driven Design (DDD), its key concepts such as bounded contexts, ubiquitous language, domain models and layered architecture, traces its evolution, highlights recent trends like Event Storming and CQRS, and draws parallels to technical team management practices for handling complexity, communication, iteration, and strategic focus.

Domain‑Driven DesignMicroservicesagile
0 likes · 15 min read
Domain-Driven Design: Core Principles, Practices, and Lessons for Technical Team Management
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jul 24, 2024 · Backend Development

Mastering Domain-Driven Design: Core Concepts, Layers, and Practical C# Examples

Domain-Driven Design (DDD) is a software development methodology that bridges business and technology by defining clear domain models, improving communication, code quality, and handling complexity through layered architecture, with concrete C# examples of entities, value objects, aggregates, and domain services.

Backend DevelopmentCDDD
0 likes · 7 min read
Mastering Domain-Driven Design: Core Concepts, Layers, and Practical C# Examples
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jul 22, 2024 · Backend Development

Understanding Domain-Driven Design (DDD) Architecture

This article introduces Domain-Driven Design (DDD), explains its core concepts, benefits, and the four-layered DDD architecture—including UI, Application, Domain, and Infrastructure layers—while also offering resources for deeper study and interview preparation.

Backend DevelopmentDDDDesign Patterns
0 likes · 6 min read
Understanding Domain-Driven Design (DDD) Architecture
Top Architecture Tech Stack
Top Architecture Tech Stack
Jul 22, 2024 · Backend Development

Designing Microservices with Domain‑Driven Design, Context Mapping, and Event Storming

This article explains how to design microservice architectures by applying domain‑driven design concepts such as bounded contexts and aggregates, using context mapping and event‑storming techniques to define clear service boundaries, handle communication, and balance consistency with availability.

Bounded ContextDomain‑Driven DesignEvent Storming
0 likes · 21 min read
Designing Microservices with Domain‑Driven Design, Context Mapping, and Event Storming
High Availability Architecture
High Availability Architecture
Jul 9, 2024 · Backend Development

Applying Domain-Driven Design to a B2B Marketing System: Strategic, Tactical, and Code Architecture Practices

This article explains how Domain-Driven Design (DDD) can be used to tackle the complexity of a B2B marketing system by detailing strategic design, tactical design, and code architecture practices, illustrating concept modeling, bounded contexts, aggregation roots, and layered architectures with real‑world examples and diagrams.

Domain‑Driven DesignStrategic DesignTactical Design
0 likes · 18 min read
Applying Domain-Driven Design to a B2B Marketing System: Strategic, Tactical, and Code Architecture Practices
Tencent Cloud Developer
Tencent Cloud Developer
Jul 9, 2024 · R&D Management

Reading Notes on 'Software Method': Business Modeling, Requirements, Analysis, and Design

The article distills the book “Software Method,” outlining a disciplined approach that starts with industry‑specific business modeling—defining vision, use‑case and sequence diagrams, and improvement patterns—then moves to precise requirements gathering, detailed analysis class diagrams, and finally design, emphasizing that true software value comes from meeting real demand.

Domain‑Driven DesignR&D ManagementSystem Design
0 likes · 25 min read
Reading Notes on 'Software Method': Business Modeling, Requirements, Analysis, and Design
Alibaba Cloud Developer
Alibaba Cloud Developer
Jul 5, 2024 · Fundamentals

Why Every Developer Should Think Like an Architect: A Practical Guide

This article explores what software architecture means, distinguishes vertical and horizontal architects, outlines the essential skills and methodology for architects, and provides a step‑by‑step framework—from understanding requirements and quality attributes to modeling business and system domains—so anyone can develop an architect’s mindset.

Domain‑Driven DesignSoftware Architecturearchitectural thinking
0 likes · 30 min read
Why Every Developer Should Think Like an Architect: A Practical Guide
Architect
Architect
Jul 4, 2024 · Industry Insights

How DDD Transforms Complex Marketing Systems: Strategic and Tactical Design Insights

This article explains how Meituan applied Domain‑Driven Design to build a scalable B‑side marketing platform, covering background challenges, core DDD concepts, strategic use‑case modeling, tactical code mapping, aggregation design, and practical architectural patterns for large‑scale systems.

DDDDomain‑Driven DesignMarketing System
0 likes · 20 min read
How DDD Transforms Complex Marketing Systems: Strategic and Tactical Design Insights
DaTaobao Tech
DaTaobao Tech
Jul 3, 2024 · Fundamentals

Architecture Thinking and Practice

The article explains software architecture concepts, the architect’s duties of extracting requirements, designing and implementing solutions, and presents methodologies such as the C4 model, 4+1 view and domain‑driven design, while outlining how to develop architectural thinking through study, practice, reflection and ongoing learning.

C4 ModelDomain‑Driven Designagile
0 likes · 27 min read
Architecture Thinking and Practice
JD Cloud Developers
JD Cloud Developers
Jun 12, 2024 · Backend Development

How to Turn a Restaurant Scenario into Concrete DDD Architecture

This article walks through a complete Domain‑Driven Design case study using a restaurant example, covering domain analysis, unified language, domain division, service design, modeling, upstream/downstream relationships, layered architecture, microservice boundaries, and functional implementation to illustrate how business concepts map to software structures.

DDDDomain ModelingDomain‑Driven Design
0 likes · 23 min read
How to Turn a Restaurant Scenario into Concrete DDD Architecture
Eric Tech Circle
Eric Tech Circle
Jun 7, 2024 · Industry Insights

Mastering the 4A Enterprise Architecture: From TOGAF to DDD Integration

This article explains the 4A enterprise architecture model, compares it with TOGAF and Huawei’s “One Body Four Faces” framework, outlines the four architectural layers, and shows how Domain‑Driven Design can be mapped onto each layer with concrete examples and diagrams.

4A ModelDomain‑Driven DesignEnterprise Architecture
0 likes · 9 min read
Mastering the 4A Enterprise Architecture: From TOGAF to DDD Integration
Architect
Architect
May 23, 2024 · Fundamentals

Unlocking Software Architecture: How Domain‑Driven Design Elevates Teams and Careers

This article explains Domain‑Driven Design (DDD) from its origins to practical modeling, compares it with MVC, outlines business and personal benefits, discusses drawbacks, details strategic and tactical concepts, and walks through a real‑world VOC product example using event‑storming and four‑color modeling.

DDDDomain‑Driven DesignSoftware Architecture
0 likes · 34 min read
Unlocking Software Architecture: How Domain‑Driven Design Elevates Teams and Careers
Meituan Technology Team
Meituan Technology Team
May 23, 2024 · Backend Development

Applying Domain-Driven Design to Marketing System Architecture: Strategic, Tactical, and Code Practices

This article walks through the application of Domain-Driven Design (DDD) in a B‑side marketing platform, detailing how strategic design defines use cases and unified language, tactical design maps concepts to object models, and code architecture organizes implementations, illustrated with concrete examples, diagrams, and practical guidelines.

B2B MarketingDomain‑Driven DesignStrategic Design
0 likes · 20 min read
Applying Domain-Driven Design to Marketing System Architecture: Strategic, Tactical, and Code Practices
Ctrip Technology
Ctrip Technology
May 23, 2024 · Backend Development

Evolution of Ctrip Account System: Domain‑Driven, Middle‑Platform, and Multi‑Region Architecture

This article details Ctrip's account system evolution, covering its transition from monolithic to domain‑driven microservices, middle‑platform consolidation, and multi‑region deployment, including design goals, read/write comparison processes, configuration‑driven capabilities, and routing strategies to improve scalability, reliability, and operational efficiency.

Domain‑Driven DesignReliabilityaccount system
0 likes · 13 min read
Evolution of Ctrip Account System: Domain‑Driven, Middle‑Platform, and Multi‑Region Architecture
DeWu Technology
DeWu Technology
May 20, 2024 · Fundamentals

Domain-Driven Design (DDD): Concepts, Value, and Modeling Techniques

Domain‑Driven Design aligns software architecture with business needs by establishing a shared language, clear bounded contexts, and strategic‑tactical patterns—entities, value objects, aggregates, services, and events—while using techniques such as Event Storming and Four‑Color Modeling to visualize domains, guide micro‑service boundaries, and produce maintainable, adaptable systems.

Domain‑Driven DesignSoftware ArchitectureStrategic Design
0 likes · 28 min read
Domain-Driven Design (DDD): Concepts, Value, and Modeling Techniques
Architect's Journey
Architect's Journey
May 15, 2024 · Artificial Intelligence

How DDD Enables an AI‑Driven Skin Analysis System for Customer Success

The article details a SaaS company's two‑month development of an AI‑powered skin‑analysis solution, illustrating how DDD’s four‑color modeling split health services into aggregates, integrated Face++ APIs, and delivered a 30‑second, 30‑dimension skin report that attracted over 80 000 users and 9 000 orders.

Artificial IntelligenceDomain‑Driven DesignFace++
0 likes · 7 min read
How DDD Enables an AI‑Driven Skin Analysis System for Customer Success
Meituan Technology Team
Meituan Technology Team
May 9, 2024 · Backend Development

Evolution and Practice of Domain-Driven Design (DDD) in Meituan Dianping Transaction System

The article recounts Meituan Dianping’s transaction system evolution—from a simple MVC design to microservices and a plug‑in platform—illustrating how domain‑driven design’s ubiquitous language, bounded contexts, and strategic modeling guided the separation of core, supporting, and generic domains and enabled scalable, maintainable architecture.

Backend DevelopmentDomain‑Driven DesignMicroservices
0 likes · 20 min read
Evolution and Practice of Domain-Driven Design (DDD) in Meituan Dianping Transaction System
MoonWebTeam
MoonWebTeam
May 8, 2024 · Frontend Development

Unlocking Domain Primitives: A Front‑End Guide to Cleaner Code

This article explains Domain‑Driven Design's Domain Primitive concept from a front‑end perspective, compares it with VO/DTO/PO, outlines its principles, provides concrete TypeScript examples, and shows how applying DP can improve validation, encapsulation, and testability in real‑world projects.

Domain PrimitiveDomain‑Driven DesignFrontend
0 likes · 20 min read
Unlocking Domain Primitives: A Front‑End Guide to Cleaner Code
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
May 4, 2024 · Backend Development

Refactoring Cloud Disk Upload Logic with Domain-Driven Design: Models, Factories, and Repositories

The article examines the difficulties of applying Domain-Driven Design to a cloud‑disk file‑upload scenario, demonstrates how to simplify the code by extracting business models, introducing factories and repositories, and explains how these patterns clarify the separation between business and technical concerns.

Domain‑Driven DesignFactory PatternRepository Pattern
0 likes · 20 min read
Refactoring Cloud Disk Upload Logic with Domain-Driven Design: Models, Factories, and Repositories
dbaplus Community
dbaplus Community
Mar 25, 2024 · Backend Development

Why CQRS Matters: Reducing System Complexity Through Command‑Query Separation

This article explains how applying CQRS and layered splitting—separating commands and queries across service, model, repository, and data layers—can dramatically lower system complexity, improve performance, and resolve common conflicts in high‑traffic backend applications.

CQRSCommand Query SeparationDomain‑Driven Design
0 likes · 12 min read
Why CQRS Matters: Reducing System Complexity Through Command‑Query Separation
dbaplus Community
dbaplus Community
Mar 20, 2024 · Backend Development

How DDD Transforms Complex Software: Practical Insights and Real‑World Refactoring

This article explores the fundamentals of Domain‑Driven Design, its challenges, practical steps for applying DDD concepts such as value objects, repository patterns, hexagonal architecture, and domain layer design, and shares concrete refactoring experiences to build more maintainable, extensible, and testable systems.

DDDDomain‑Driven DesignHexagonal Architecture
0 likes · 20 min read
How DDD Transforms Complex Software: Practical Insights and Real‑World Refactoring
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Mar 12, 2024 · Fundamentals

Understanding Domain-Driven Design (DDD) Architecture: Concepts, Layers, and Core Principles

Domain-Driven Design (DDD) is a software design methodology that simplifies complex business domains by defining clear boundaries, layers, and core concepts such as aggregates, entities, value objects, and bounded contexts, helping teams achieve better business understanding, modularity, maintainability, and efficient architecture.

DDDDesign PatternsDomain‑Driven Design
0 likes · 10 min read
Understanding Domain-Driven Design (DDD) Architecture: Concepts, Layers, and Core Principles
Architect
Architect
Feb 2, 2024 · Backend Development

How DDD Transforms a Complex Pricing System: A Step‑by‑Step Architectural Guide

This article walks through the practical application of Domain‑Driven Design to a large‑scale pricing system, detailing business understanding, strategic and tactical design, context integration, layered architecture, and concrete Java implementations that illustrate how DDD improves modularity, testability, and maintainability.

Clean ArchitectureDDDDomain‑Driven Design
0 likes · 14 min read
How DDD Transforms a Complex Pricing System: A Step‑by‑Step Architectural Guide
JavaEdge
JavaEdge
Jan 28, 2024 · Backend Development

Designing a Marketing Reverse Domain for Refunds with DDD

This article explains how to model and implement a marketing reverse domain that handles coupon and asset recovery during refunds, using domain‑driven design, rule engines, and service layers, complete with state‑machine diagrams, code snippets, and practical mapping configurations.

Domain‑Driven DesignMarketingRefund
0 likes · 11 min read
Designing a Marketing Reverse Domain for Refunds with DDD
dbaplus Community
dbaplus Community
Jan 24, 2024 · Backend Development

How DDD Reshapes Video Platform Architecture: A Quantitative Refactoring Study

This article explains how Domain‑Driven Design was applied to the Tencent Video “Together Watch” system, presenting a step‑by‑step domain modeling process, mapping to a layered micro‑service architecture, and a quantitative evaluation of the refactoring’s impact on modularity, performance, code size, and operational costs.

Architecture RefactoringDomain‑Driven Designquantitative evaluation
0 likes · 17 min read
How DDD Reshapes Video Platform Architecture: A Quantitative Refactoring Study
政采云技术
政采云技术
Jan 16, 2024 · Fundamentals

Understanding Finite State Machines: Definitions, Usage, Advantages, and Their Relation to Domain‑Driven Design

This article explains what a finite state machine (FSM) is, illustrates it with a car transmission example, outlines its components and diagramming, discusses its technical pros and cons, explores business benefits, and examines how state machines relate to domain‑driven design.

Domain‑Driven DesignFinite State MachineSoftware Architecture
0 likes · 13 min read
Understanding Finite State Machines: Definitions, Usage, Advantages, and Their Relation to Domain‑Driven Design
DaTaobao Tech
DaTaobao Tech
Jan 8, 2024 · Fundamentals

Understanding Application Architecture: From Chaos to Order

Understanding an application's architecture—defining clear module and package hierarchies, adopting layered patterns like Hexagonal or Clean Architecture, and applying principles such as Dependency Inversion and CQRS—transforms chaotic codebases into maintainable, testable systems that reduce onboarding time and simplify future development.

CQRSDependency InversionDomain‑Driven Design
0 likes · 22 min read
Understanding Application Architecture: From Chaos to Order
macrozheng
macrozheng
Jan 4, 2024 · Backend Development

How DDD and Spring Data JPA Simplify Order Management in Java

This article explains how Domain‑Driven Design (DDD) combined with Spring Data JPA enables clean, object‑oriented modeling of order workflows, introduces the Repository pattern for persistence, and demonstrates the full lifecycle—from creation to address modification and payment—through concise Java code and SQL examples.

DDDDomain‑Driven DesignRepository Pattern
0 likes · 21 min read
How DDD and Spring Data JPA Simplify Order Management in Java
JD Cloud Developers
JD Cloud Developers
Dec 26, 2023 · Fundamentals

Unlock DDD: Practical Hexagonal Architecture and Repository Patterns

This article explores Domain‑Driven Design fundamentals, illustrating how to expose hidden concepts, adopt hexagonal architecture, and implement repository patterns to achieve high scalability, maintainability, and testability in complex software systems, while addressing common pitfalls like the anemic model.

DDDDomain‑Driven DesignHexagonal Architecture
0 likes · 23 min read
Unlock DDD: Practical Hexagonal Architecture and Repository Patterns
Bilibili Tech
Bilibili Tech
Dec 26, 2023 · Backend Development

Rearchitecting Bilibili Live Broadcast Platform: From Legacy PHP to Go with Domain‑Driven Design and Hexagonal Architecture

The article details Bilibili’s migration of its legacy PHP live‑broadcast service to Go microservices using Domain‑Driven Design and Hexagonal architecture, describing event‑storming, six‑layer tactical design, TDD, traffic‑mirroring migration, and resulting higher reliability, lower latency, and improved maintainability.

Domain‑Driven DesignHexagonal ArchitectureMicroservices
0 likes · 43 min read
Rearchitecting Bilibili Live Broadcast Platform: From Legacy PHP to Go with Domain‑Driven Design and Hexagonal Architecture
php Courses
php Courses
Dec 14, 2023 · Fundamentals

Understanding Different Types of Value Objects and Their Implementation in PHP

This article explores simple, complex, and composite value objects in PHP, providing guidelines for their design, validation, immutability, string representation, equality checks, while also discussing alternative error handling approaches such as Either types and union types.

Domain‑Driven DesignError HandlingFactory Method
0 likes · 16 min read
Understanding Different Types of Value Objects and Their Implementation in PHP
dbaplus Community
dbaplus Community
Dec 13, 2023 · Fundamentals

How to Design Scalable, Maintainable Software Architecture: From Principles to Practice

This article explores how to build a robust engineering architecture by prioritizing product value, defining clear layered and DDD structures, selecting appropriate technologies, and establishing standards for exception, logging, monitoring, and team collaboration to achieve scalability, maintainability, reliability, security, and high performance.

Domain‑Driven DesignException HandlingLayered Architecture
0 likes · 27 min read
How to Design Scalable, Maintainable Software Architecture: From Principles to Practice