BestHub
Sign in
Tagged articles

Software Architecture

1241 articles · Page 7 of 13
NetEase Yanxuan Technology Product Team
NetEase Yanxuan Technology Product Team
May 18, 2022 · R&D Management

How We Resolved Complex Supplier System Boundaries: A 1.5‑Year R&D Governance Journey

This article details a year‑and‑a‑half of boundary‑governance work on a supplier platform, explaining why fragmented responsibilities hurt efficiency, how the team expressed, identified, and solved boundary issues through clear domain definitions, unified language, and staged migration, and the measurable improvements achieved.

Product ManagementR&D efficiencySoftware Architecture
0 likes · 15 min read
How We Resolved Complex Supplier System Boundaries: A 1.5‑Year R&D Governance Journey
Top Architect
Top Architect
May 14, 2022 · Backend Development

Strategic and Tactical Design Principles for Technical Architecture

This article explains how to design robust technical architectures by addressing strategic principles such as suitability, simplicity, and evolution, and tactical guidelines covering high concurrency, high availability, and business design, while illustrating logical and physical architecture diagrams for real‑world systems.

High AvailabilityHigh concurrencySoftware Architecture
0 likes · 14 min read
Strategic and Tactical Design Principles for Technical Architecture
Programmer DD
Programmer DD
May 4, 2022 · R&D Management

What Really Defines a Software Architect? 3 Perspectives from 12 Years Experience

The article reflects on a dozen years of software development experience to propose three evolving definitions of a software architect, classify various architect roles, and compare centralized versus collaborative work styles, highlighting why the term is often misused in the industry.

R&D ManagementSoftware Architecturearchitect role
0 likes · 12 min read
What Really Defines a Software Architect? 3 Perspectives from 12 Years Experience
Programmer DD
Programmer DD
Apr 29, 2022 · Fundamentals

Master 23 Classic Design Patterns with Real-World Analogies

This article humorously illustrates 23 classic software design patterns—such as Factory Method, Builder, Abstract Factory, Prototype, Singleton, Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy, Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, and Visitor—using everyday relationship scenarios to make each pattern’s intent and structure easy to grasp.

Design PatternsSoftware Architectureobject-oriented
0 likes · 19 min read
Master 23 Classic Design Patterns with Real-World Analogies
JD Tech
JD Tech
Apr 29, 2022 · Frontend Development

Cross‑Platform Frontend Evolution and Low‑Code Flutter Implementation

This article examines the evolution of cross‑platform frontend technologies, outlines key criteria for selecting a solution, compares major approaches such as WebView, native rendering, and self‑rendering, and presents a practical low‑code, Flutter‑based implementation that delivers fast, consistent multi‑device applications.

FlutterFrontendSoftware Architecture
0 likes · 11 min read
Cross‑Platform Frontend Evolution and Low‑Code Flutter Implementation
IT Architects Alliance
IT Architects Alliance
Apr 29, 2022 · R&D Management

30 Essential Architecture Principles Every Software Architect Should Follow

This article presents thirty practical software‑architecture principles—from keeping designs simple and avoiding unnecessary features to mastering concurrency, distributed systems, and user experience—providing a comprehensive guide that helps architects make informed, ROI‑driven decisions while fostering scalable, maintainable solutions.

MVPR&D ManagementSoftware Architecture
0 likes · 11 min read
30 Essential Architecture Principles Every Software Architect Should Follow
Wukong Talks Architecture
Wukong Talks Architecture
Apr 26, 2022 · R&D Management

Understanding the Software Architect Role: Three Definitions, Classifications, and Work Styles

The article reflects on a dozen years of software development experience to propose three evolving definitions of a software architect, examines why the term is often misused, categorises different architect types, and compares centralized versus connective work styles for effective R&D management.

R&D ManagementSoftware ArchitectureTeam Structure
0 likes · 10 min read
Understanding the Software Architect Role: Three Definitions, Classifications, and Work Styles
Code Ape Tech Column
Code Ape Tech Column
Apr 22, 2022 · Backend Development

Application Layering Best Practices and Alibaba Specification

This article explains common misconceptions about application layering, outlines essential principles for maintainable layers, details Alibaba's multi‑layer architecture, proposes optimized layering with service and manager responsibilities, discusses domain model conversions, and concludes with practical guidance for clear, reusable backend design.

Alibaba guidelinesSoftware Architectureapplication layering
0 likes · 8 min read
Application Layering Best Practices and Alibaba Specification
Qunar Tech Salon
Qunar Tech Salon
Apr 20, 2022 · R&D Management

Designing Business Architecture for Activity Capability Layer: A Qunar Case Study

This article examines the concept of business architecture, its origins in TOGAF, and presents a detailed case study of Qunar’s activity capability layer design, highlighting pain points, architectural solutions, and a step-by-step methodology for building robust, reusable activity systems.

Business ArchitectureEnterprise ArchitectureQunar
0 likes · 15 min read
Designing Business Architecture for Activity Capability Layer: A Qunar Case Study
21CTO
21CTO
Apr 18, 2022 · Cloud Native

Designing Complex Business Architecture with DDD in the Cloud‑Native Era

During the Chinese New Year, the author reflects on the declining state of Chinese football and draws parallels to large‑scale digital transformation projects, exploring how component‑based, cloud‑native architecture and domain‑driven design can address the complexities of enterprise business systems, improve modularity, and enable rapid, resilient evolution.

MicroservicesSoftware Architecturedomain-driven design
0 likes · 24 min read
Designing Complex Business Architecture with DDD in the Cloud‑Native Era
Liangxu Linux
Liangxu Linux
Apr 11, 2022 · Cloud Native

Why Microservices Matter: From Simple Services to Kubernetes‑Powered Architecture

This article explains what microservices are, how they differ from traditional monolithic apps, illustrates their benefits and drawbacks with an Amazon product‑page example, describes containers and Docker, and shows why Kubernetes is a natural platform for managing microservice‑based systems.

KubernetesMicroservicesSoftware Architecture
0 likes · 14 min read
Why Microservices Matter: From Simple Services to Kubernetes‑Powered Architecture
IT Architects Alliance
IT Architects Alliance
Apr 7, 2022 · Fundamentals

30 Architectural Principles for Software Engineers

This article presents thirty concise architectural principles covering simplicity, YAGNI, iterative development, testing, ROI, user focus, modular design, configuration, server concurrency, distributed system challenges, and user experience, offering practical guidance for engineers to build scalable, maintainable software systems.

Software Architecturedesign principlesdistributed systems
0 likes · 12 min read
30 Architectural Principles for Software Engineers
政采云技术
政采云技术
Apr 7, 2022 · Fundamentals

Applying Architectural Patterns to Monolith Splitting and System Scalability: Lessons from "Software Architecture with Patterns"

This article reviews key concepts from the book "Software Architecture with Patterns" and discusses how architectural patterns such as layered architecture, microkernel, and GoF design patterns can guide the decomposition of monolithic applications and improve the extensibility of complex systems.

DDDDesign PatternsSoftware Architecture
0 likes · 15 min read
Applying Architectural Patterns to Monolith Splitting and System Scalability: Lessons from "Software Architecture with Patterns"
Programmer DD
Programmer DD
Apr 6, 2022 · R&D Management

Why Traditional Software Architects Fail and How Everyone Can Be an Architect

The article critiques traditional software architects as bottlenecks, shares personal experiences at eBay and Alibaba, argues that dedicated architecture departments often cause more harm than good, and advocates that every engineer develop architectural thinking, offering guidance for engineers, team leads, and CTOs.

Engineering CultureSoftware Architecturearchitectural thinking
0 likes · 9 min read
Why Traditional Software Architects Fail and How Everyone Can Be an Architect
Top Architect
Top Architect
Apr 2, 2022 · Backend Development

Applying Domain-Driven Design to Payment Systems: A Comprehensive Guide

This article explains how Airwallex uses Domain-Driven Design (DDD) to model a complex payment system, detailing strategic and tactical patterns, bounded contexts, domain events, and the translation of domain models into microservice architectures, while highlighting the benefits of clear communication and modular design.

Backend DevelopmentDDDDomain-Driven Design
0 likes · 9 min read
Applying Domain-Driven Design to Payment Systems: A Comprehensive Guide
Architecture Digest
Architecture Digest
Apr 2, 2022 · Backend Development

Applying Domain-Driven Design to Model a Payment System at Airwallex

This article explains how Airwallex uses Domain-Driven Design (DDD) to model a complex payment system, covering problem and solution spaces, bounded contexts, domain models, services, events, infrastructure, and the transition from domain concepts to microservices.

Domain EventsSoftware Architecturebounded context
0 likes · 10 min read
Applying Domain-Driven Design to Model a Payment System at Airwallex
Top Architect
Top Architect
Mar 26, 2022 · Fundamentals

A Top Architect’s Humorous Guide to 23 Classic Design Patterns

This article presents a light‑hearted yet comprehensive overview of 23 classic software design patterns—such as Factory Method, Builder, Abstract Factory, Prototype, Singleton, Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy, Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, and Visitor—explaining each pattern’s intent, structure, advantages, and drawbacks through everyday analogies.

Design PatternsProgramming FundamentalsSoftware Architecture
0 likes · 19 min read
A Top Architect’s Humorous Guide to 23 Classic Design Patterns
Architecture Digest
Architecture Digest
Mar 25, 2022 · Fundamentals

Understanding Domain-Driven Design: Core Concepts, Building Blocks, and Modeling Practices

Domain-Driven Design (DDD) is a model‑driven approach that places the business domain at the core, using ubiquitous language, bounded contexts, and building blocks such as entities, value objects, and services to create a cohesive domain model that aligns code with complex business requirements.

Domain ModelingSoftware ArchitectureUbiquitous Language
0 likes · 9 min read
Understanding Domain-Driven Design: Core Concepts, Building Blocks, and Modeling Practices
Open Source Linux
Open Source Linux
Mar 22, 2022 · Fundamentals

30 Essential Architecture Principles Every Engineer Should Follow

This article presents thirty practical architecture principles—from keeping designs simple and avoiding unnecessary features to embracing distributed, stateless systems and thoughtful configuration—offering a comprehensive guide for architects to lead, mentor, and build resilient, user‑focused software.

Design PatternsSoftware Architecturedistributed systems
0 likes · 11 min read
30 Essential Architecture Principles Every Engineer Should Follow
ITPUB
ITPUB
Mar 21, 2022 · Fundamentals

How to Tame Software Complexity: Entropy, Constructal Law, and Design Strategies

This article explores why software systems inevitably become more entropic and complex, draws parallels with physical entropy and the Constructal Law, identifies sources of uncertainty, scale, and cognitive cost, and presents practical approaches such as isolating core kernels, adopting Domain‑Driven Design, and applying Clean Code principles to keep systems maintainable.

Software Architectureanemic modelclean code
0 likes · 18 min read
How to Tame Software Complexity: Entropy, Constructal Law, and Design Strategies
IT Architects Alliance
IT Architects Alliance
Mar 20, 2022 · Fundamentals

Overview of Architectural Thinking and Layered Architecture Models

This article explains architectural thinking as a synthesis of system, structured, and programming mindsets, emphasizing the core principles of decomposition and integration, and describes various layered models such as cloud three‑layer, SOA, and classic three‑tier architectures for both technical and application design.

Cloud ComputingLayered DesignSOA
0 likes · 15 min read
Overview of Architectural Thinking and Layered Architecture Models
IT Architects Alliance
IT Architects Alliance
Mar 17, 2022 · Backend Development

Introduction to Microservice Architecture: Concepts, Evolution, Comparison with Monolithic, Design Patterns, Advantages and Disadvantages

This article provides a comprehensive overview of microservice architecture, covering its definition, history, differences from monolithic development, key characteristics, comparison with SOA, practical implementation steps, common design patterns, and the pros and cons of adopting microservices in modern software systems.

Design PatternsMicroservicesSoftware Architecture
0 likes · 23 min read
Introduction to Microservice Architecture: Concepts, Evolution, Comparison with Monolithic, Design Patterns, Advantages and Disadvantages
IT Architects Alliance
IT Architects Alliance
Mar 16, 2022 · R&D Management

What Is Software Architecture? A Deep Dive into Layers, Types, and Evolution

This comprehensive guide explains the definition of software architecture, its essential concepts, layered classifications, various architecture levels, evolution from monolith to microservices, common pitfalls, and metrics for evaluating architectural soundness, providing practical insights for architects and developers alike.

MicroservicesSoftware ArchitectureSystem Design
0 likes · 24 min read
What Is Software Architecture? A Deep Dive into Layers, Types, and Evolution
Architects' Tech Alliance
Architects' Tech Alliance
Mar 16, 2022 · Fundamentals

Comprehensive Overview of Software Architecture: Concepts, Layers, Levels, Evolution, and Best Practices

This article provides an extensive introduction to software architecture, covering its definition, essential concepts such as systems, subsystems, modules, components, and frameworks, various architectural layers and classifications, architectural levels, strategic versus tactical design, evolution from monoliths to micro‑services, common pitfalls, measurement criteria, and recommended learning resources.

MicroservicesSoftware ArchitectureSystem Design
0 likes · 21 min read
Comprehensive Overview of Software Architecture: Concepts, Layers, Levels, Evolution, and Best Practices
Ctrip Technology
Ctrip Technology
Mar 10, 2022 · Fundamentals

Improving Code Quality with Domain‑Driven Design and Algebraic Data Types

This article explains why code quality often degrades despite clear requirements, introduces Domain‑Driven Design (DDD) and Algebraic Data Types (ADT) as a unified modeling approach, shows how Curry‑Howard isomorphism connects domain knowledge to type systems, and demonstrates practical TypeScript examples that reduce illegal states, defensive code and improve maintainability.

Domain-Driven DesignSoftware ArchitectureType Theory
0 likes · 29 min read
Improving Code Quality with Domain‑Driven Design and Algebraic Data Types
IT Services Circle
IT Services Circle
Mar 9, 2022 · Fundamentals

Understanding the 4+1 View Model of Software Architecture

This article introduces the 4+1 view model of software architecture, explaining its four main views—Logical, Process, Physical, Development—and the additional Scenario view, illustrating each with examples and diagrams to guide architects in comprehensive system design.

4+1 view modelScenario ViewSoftware Architecture
0 likes · 6 min read
Understanding the 4+1 View Model of Software Architecture
Architecture Digest
Architecture Digest
Mar 9, 2022 · Fundamentals

Domain-Driven Design: Concepts, Bounded Contexts, and Architectural Patterns

This article introduces Domain-Driven Design (DDD), explains key terminology, describes the evolution of architecture from SaaS to IaaS, details bounded context concepts and division rules, and reviews major architectural styles such as clean layered, hexagonal, and onion architectures for building robust software systems.

Clean ArchitectureDDDDomain-Driven Design
0 likes · 9 min read
Domain-Driven Design: Concepts, Bounded Contexts, and Architectural Patterns
IT Architects Alliance
IT Architects Alliance
Mar 8, 2022 · Backend Development

How to Build a New Project with Domain‑Driven Design: From Concepts to Architecture

This guide walks through applying Domain‑Driven Design to a brand‑new project, covering essential terminology, the evolution from SaaS to IaaS, defining bounded contexts, the four DDD boundaries, and various architectural styles such as clean layered, hexagonal, and onion architectures, with practical insights for implementation.

Clean ArchitectureDomain-Driven DesignMicroservices
0 likes · 10 min read
How to Build a New Project with Domain‑Driven Design: From Concepts to Architecture
Architects' Tech Alliance
Architects' Tech Alliance
Mar 8, 2022 · Backend Development

30 Architectural Principles for Software Engineers

The article presents thirty practical architectural principles—ranging from simplicity, YAGNI, iterative development, automated testing, and ROI to server concurrency, distributed system design, user experience, and configuration management—aimed at guiding engineers and teams toward robust, scalable, and maintainable software solutions.

Backend DevelopmentSoftware Architectureconcurrency
0 likes · 10 min read
30 Architectural Principles for Software Engineers
Tencent Cloud Developer
Tencent Cloud Developer
Mar 8, 2022 · Backend Development

Go Microservices Architecture Best Practices Based on Clean Architecture and trpc-Go

The article presents clean‑architecture best practices for Go microservices built with trpc‑Go, recommending a four‑layer pyramid (gateway, logic, repo, entity), strict dependency inversion, interface‑based injection, gomock testing, centralized JSON configuration, and a three‑phase rollout to replace tangled packages and global imports while avoiding DDD complexity.

Clean ArchitectureDependency InjectionGo backend
0 likes · 14 min read
Go Microservices Architecture Best Practices Based on Clean Architecture and trpc-Go
DevOps
DevOps
Mar 8, 2022 · Fundamentals

Understanding Technical Debt: Classification, Impact, and Mitigation Strategies

The article explains the origins and four quadrants of technical debt, outlines its detrimental effects on software quality and maintainability, and offers practical approaches—including daily debt management, clear technical standards, continuous technology monitoring, visualization, and sustained investment—to identify, prioritize, and reduce technical debt in development teams.

Software ArchitectureSoftware Maintenancecode quality
0 likes · 10 min read
Understanding Technical Debt: Classification, Impact, and Mitigation Strategies
IT Architects Alliance
IT Architects Alliance
Mar 7, 2022 · Backend Development

Differences Between Microservices and Monolithic Architecture

The article explains how microservices differ from monolithic applications by emphasizing team‑based, autonomous service design, data‑sharing challenges, dependency management, API communication patterns, and the use of shared caches to improve performance and reliability.

CachingMicroservicesService Dependency
0 likes · 7 min read
Differences Between Microservices and Monolithic Architecture
IT Architects Alliance
IT Architects Alliance
Mar 6, 2022 · R&D Management

30 Software Architecture Principles for Effective System Design

This article presents thirty practical software architecture principles—ranging from simplicity and YAGNI to distributed system design, user experience, and configuration management—offered by architect Srinath to guide teams in making better technical decisions and fostering collaborative, high‑quality product development.

Software ArchitectureSystem Designdesign principles
0 likes · 12 min read
30 Software Architecture Principles for Effective System Design
21CTO
21CTO
Mar 5, 2022 · Fundamentals

30 Essential Architecture Principles Every Engineer Should Follow

This article presents thirty practical software architecture principles—from simplicity and YAGNI to distributed system design and user experience—offering actionable guidance for engineers to shape robust, maintainable, and user‑centric systems.

Engineering best practicesSoftware ArchitectureSystem Design
0 likes · 11 min read
30 Essential Architecture Principles Every Engineer Should Follow
Architect
Architect
Mar 5, 2022 · Fundamentals

30 Architectural Principles for Software Architects

The article presents thirty concise architectural principles—ranging from simplicity, YAGNI, iterative development, automated testing, ROI, user‑centric design, modularity, to distributed system concerns like statelessness, idempotency, CAP theory, and configuration best practices—offered as a practical guide for architects and development teams.

Software ArchitectureSystem Designdesign principles
0 likes · 12 min read
30 Architectural Principles for Software Architects
IT Architects Alliance
IT Architects Alliance
Mar 1, 2022 · Fundamentals

What Truly Defines Software Architecture? A Deep Dive into Concepts, Layers, and Evolution

This article explains the fundamental definition of software architecture, distinguishes systems, subsystems, modules, components, frameworks, and various architecture layers, and examines how architectures evolve from monoliths to distributed services and micro‑services while highlighting common pitfalls and evaluation criteria.

MicroservicesSoftware ArchitectureSystem Design
0 likes · 23 min read
What Truly Defines Software Architecture? A Deep Dive into Concepts, Layers, and Evolution
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Feb 27, 2022 · Fundamentals

Comprehensive Overview of 23 Java Design Patterns

This article provides a detailed English summary of 23 Java design patterns—including their purposes, core principles, classification into creational, structural, and behavioral groups, definitions, typical use‑cases, and visual diagrams—helping developers understand how to write reusable, readable, extensible, and reliable code.

BehavioralCreationalDesign Patterns
0 likes · 17 min read
Comprehensive Overview of 23 Java Design Patterns
IT Architects Alliance
IT Architects Alliance
Feb 26, 2022 · Fundamentals

Why Clean Architecture, DDD, and CQRS Together Create Scalable, Testable Systems

This article explains Clean Architecture, shows how Domain‑Driven Design fits into its concentric‑layer model, and demonstrates how adding Command‑Query Responsibility Segregation (CQRS) enhances scalability, testability, and maintainability while outlining practical implementation steps, benefits, and trade‑offs.

CQRSClean ArchitectureDesign Patterns
0 likes · 22 min read
Why Clean Architecture, DDD, and CQRS Together Create Scalable, Testable Systems
Java Interview Crash Guide
Java Interview Crash Guide
Feb 22, 2022 · Backend Development

Ensuring API Idempotency: Prevent Duplicate Requests in Scalable Systems

Idempotency ensures that repeated API calls produce the same result, preventing duplicate processing in high‑traffic systems; this article explains why it matters, typical duplicate request scenarios, and a practical implementation using client‑generated identifiers to cache and filter repeated submissions.

API designMicroservicesSoftware Architecture
0 likes · 4 min read
Ensuring API Idempotency: Prevent Duplicate Requests in Scalable Systems
Programmer DD
Programmer DD
Feb 16, 2022 · Fundamentals

What Is Software Architecture? Core Concepts, Layers, and Design Principles

This article explains the essence of software architecture, covering definitions, system vs. subsystem, module vs. component, framework vs. architecture, various architectural layers, classifications, evolution from monolith to microservices, and how to evaluate a design’s suitability for business and non‑functional requirements.

MicroservicesSoftware ArchitectureSystem Design
0 likes · 26 min read
What Is Software Architecture? Core Concepts, Layers, and Design Principles
IT Architects Alliance
IT Architects Alliance
Feb 16, 2022 · Fundamentals

How to Create Effective Architecture Diagrams: Concepts, Types, and the C4 Modeling Approach

This article explains the importance of clear architecture diagrams, defines architecture and its visual representations, outlines common diagram types and pitfalls, and introduces the C4 modeling approach with practical guidance for creating self‑describing, audience‑focused system diagrams.

C4 modelSoftware ArchitectureSystem Design
0 likes · 10 min read
How to Create Effective Architecture Diagrams: Concepts, Types, and the C4 Modeling Approach
IT Architects Alliance
IT Architects Alliance
Feb 16, 2022 · Cloud Native

Understanding Microservices: Concepts, Benefits, Drawbacks, and Their Relationship with Containers and Kubernetes

This article explains what microservices are, how they differ from traditional monolithic applications, provides an Amazon product‑listing example, discusses containers, compares the two, outlines when to adopt microservices, lists their pros and cons, and describes how Kubernetes supports cloud‑native microservice architectures.

ContainersKubernetesMicroservices
0 likes · 12 min read
Understanding Microservices: Concepts, Benefits, Drawbacks, and Their Relationship with Containers and Kubernetes
Architecture Digest
Architecture Digest
Feb 11, 2022 · Fundamentals

An Introduction to Domain-Driven Design: Concepts, Benefits, and Practical Steps

This article summarizes Evans' concise DDD booklet, explains why domain‑driven design is needed, outlines the problems it addresses, describes strategic and tactical design practices—including bounded contexts, ubiquitous language, aggregates, and event storming—and highlights common pitfalls and supporting tools.

Domain-Driven DesignEvent StormingSoftware Architecture
0 likes · 15 min read
An Introduction to Domain-Driven Design: Concepts, Benefits, and Practical Steps
IT Architects Alliance
IT Architects Alliance
Feb 10, 2022 · Fundamentals

An Introduction to Domain-Driven Design (DDD): Concepts, Benefits, and Practical Practices

This article explains Domain-Driven Design (DDD), outlining why it is needed, how it solves common software development problems, and detailing strategic and tactical design steps, event‑storming techniques, and common misconceptions to help teams align business and technical perspectives.

Domain-Driven DesignEvent StormingSoftware Architecture
0 likes · 14 min read
An Introduction to Domain-Driven Design (DDD): Concepts, Benefits, and Practical Practices
Programmer DD
Programmer DD
Feb 10, 2022 · Fundamentals

Mastering Software Architecture Diagrams: A Practical C4 Methodology

Learn how to create clear, audience‑focused software architecture diagrams using the C4 model, covering essential concepts, diagram types, common pitfalls, and practical tips to ensure your diagrams communicate effectively without unnecessary complexity.

C4 modelSoftware ArchitectureSystem Design
0 likes · 11 min read
Mastering Software Architecture Diagrams: A Practical C4 Methodology
NiuNiu MaTe
NiuNiu MaTe
Feb 10, 2022 · Fundamentals

Master the Proxy Pattern with a Fun Story and Go Example

This article explains the proxy design pattern through an engaging cartoon story, analyzes the roles of client, target, and proxy, discusses its benefits and variations, and shows practical usage examples such as ES6 Proxy, virtual image lazy‑loading, and a Golang implementation.

Design PatternsGolangProxy Pattern
0 likes · 4 min read
Master the Proxy Pattern with a Fun Story and Go Example
DevOps
DevOps
Feb 7, 2022 · R&D Management

Growth of a Technical Leader: Lessons from My Years as an Architect at Dangdang

The article shares the author’s four‑year journey as a software architect at Dangdang, detailing practical experiences in platform reconstruction, order system planning, technology‑stack selection, open‑source framework development, and the four essential growth elements—learning, adapting, collaborating, and driving—offering actionable insights for technical leaders.

Software Architecturetechnical leadership
0 likes · 17 min read
Growth of a Technical Leader: Lessons from My Years as an Architect at Dangdang
Open Source Linux
Open Source Linux
Jan 25, 2022 · Cloud Native

Microservices Explained: When to Use Them, Containers, and Kubernetes

This article explains what microservices are, how they differ from traditional monolithic apps, illustrates their use with an Amazon product page example, and explores the relationship with containers and Kubernetes, while outlining benefits, drawbacks, and design considerations for adopting a microservice architecture.

ContainersMicroservicesSoftware Architecture
0 likes · 12 min read
Microservices Explained: When to Use Them, Containers, and Kubernetes
Architect
Architect
Jan 23, 2022 · Backend Development

Designing Consistent API Return Codes: Lessons from HTTP Status Codes

The article explains why a well‑designed API return‑code system—modeled after HTTP status codes, with clear numeric ranges, descriptive messages, and personalized user messages—reduces communication overhead, simplifies maintenance, and enables effective monitoring and alerting for backend services.

API designBackend DevelopmentError Codes
0 likes · 6 min read
Designing Consistent API Return Codes: Lessons from HTTP Status Codes
Top Architect
Top Architect
Jan 15, 2022 · Backend Development

Technical Architecture Design Principles: Strategy and Tactics for Backend Systems

This article explains how to design robust backend technical architectures by addressing strategic principles such as suitability, simplicity, and evolution, and tactical guidelines covering high concurrency, high availability, and business design, while illustrating logical and physical architecture diagrams and practical implementation tips.

High AvailabilityHigh concurrencySoftware Architecture
0 likes · 14 min read
Technical Architecture Design Principles: Strategy and Tactics for Backend Systems
Top Architect
Top Architect
Dec 31, 2021 · Fundamentals

Understanding Software Architecture: Concepts, Layers, and the COLA Framework

This article explains the fundamentals of software architecture, why it is needed, the responsibilities of architects, various architectural classifications, and introduces classic and modern application architectures such as layered, CQRS, hexagonal, onion, and the open‑source COLA framework with its design and extension principles.

COLACQRSDesign Patterns
0 likes · 14 min read
Understanding Software Architecture: Concepts, Layers, and the COLA Framework
IT Architects Alliance
IT Architects Alliance
Dec 31, 2021 · Industry Insights

A Complete 19‑Part Knowledge Map for Software Architects

The article presents a detailed 19‑section knowledge map for software architects, covering everything from core responsibilities and fundamentals to distributed caching, messaging, load balancing, performance testing, OS, algorithms, networking, databases, JVM, micro‑services, DDD, security, high availability, big data, and blockchain, with visual mind‑maps for each topic.

Big DataMicroservicesSoftware Architecture
0 likes · 4 min read
A Complete 19‑Part Knowledge Map for Software Architects
Open Source Linux
Open Source Linux
Dec 31, 2021 · Fundamentals

Which Programming Languages Power Today's Operating Systems and Software?

This article surveys the programming languages and technology stacks behind a wide range of operating systems, user interfaces, desktop search tools, office suites, databases, browsers, servers, and other software, highlighting the prevalence of C, C++, Java, and other languages across the industry.

Operating SystemsSoftware Architecturedevelopment tools
0 likes · 10 min read
Which Programming Languages Power Today's Operating Systems and Software?
Architect
Architect
Dec 30, 2021 · Backend Development

Avoiding the Distributed Monolith Trap: Combining Command and Event Patterns in Microservice Architecture

The article explains how the misconception of treating distribution as the whole of microservices leads to a distributed‑monolith trap, and shows how mixing command‑driven and event‑driven communication can decouple services, improve reliability, and guide a smooth migration from monolith to microservices.

Command PatternMicroservicesSoftware Architecture
0 likes · 11 min read
Avoiding the Distributed Monolith Trap: Combining Command and Event Patterns in Microservice Architecture
21CTO
21CTO
Dec 25, 2021 · Cloud Native

When Should You Split a Monolith? Strategies and Principles for Microservice Migration

This article explains why and when to break a monolithic application into microservices, outlines the business and technical signals that trigger splitting, presents guiding principles, functional and non‑functional strategies, and risk‑mitigation practices to ensure a smooth, sustainable migration.

Domain-Driven DesignMicroservicesService Splitting
0 likes · 21 min read
When Should You Split a Monolith? Strategies and Principles for Microservice Migration
IT Architects Alliance
IT Architects Alliance
Dec 22, 2021 · Industry Insights

Mastering Technical Architecture: Strategic & Tactical Design Principles for Scalable Systems

This article explains how to transform product requirements into robust technical architectures by addressing uncertainty through strategic principles—suitability, simplicity, evolution—and tactical guidelines covering high concurrency, high availability, and business design, illustrated with logical and physical diagrams.

High AvailabilityHigh concurrencySoftware Architecture
0 likes · 14 min read
Mastering Technical Architecture: Strategic & Tactical Design Principles for Scalable Systems
21CTO
21CTO
Dec 20, 2021 · Fundamentals

Mastering Software Architecture: Strategic & Tactical Design Principles

This article explores how to transform product requirements into robust technical architectures by addressing uncertainty, outlining strategic principles—appropriateness, simplicity, evolution—and tactical guidelines for high concurrency, high availability, and business design, while illustrating logical and physical architecture diagrams.

High AvailabilityHigh concurrencySoftware Architecture
0 likes · 14 min read
Mastering Software Architecture: Strategic & Tactical Design Principles
IT Architects Alliance
IT Architects Alliance
Dec 16, 2021 · Fundamentals

What Really Defines Software Architecture? Core Concepts and Layers Explained

This article clarifies the essence of software architecture by defining key concepts such as system, subsystem, module, component, framework versus architecture, and then details the multiple architectural layers—including business, application, data, code, technical, and deployment—while highlighting their purposes, relationships, and design considerations.

Software ArchitectureSystem Designapplication architecture
0 likes · 11 min read
What Really Defines Software Architecture? Core Concepts and Layers Explained
Architecture Digest
Architecture Digest
Dec 15, 2021 · Fundamentals

Object‑Oriented Modeling: Concepts, Attributes, Composition, and Code Examples

This article explains the philosophical basis of object‑oriented thinking, distinguishes attributes and operations, compares data‑model and object‑model designs with Java and SQL examples, discusses composition versus aggregation through a digestion model, and illustrates application‑service patterns in account credit scenarios.

Domain-Driven DesignJavaSoftware Architecture
0 likes · 13 min read
Object‑Oriented Modeling: Concepts, Attributes, Composition, and Code Examples
Architects Research Society
Architects Research Society
Dec 14, 2021 · Fundamentals

Context Mapping Patterns in Domain-Driven Design

The article explains various context‑mapping techniques from Domain‑Driven Design—such as Partnership, Shared Kernel, Customer/Supplier, Conformist, Anti‑Corruption Layer, Open Host Service, and Published Language—and advises when to apply each based on code, team, and business considerations.

Domain-Driven DesignIntegration PatternsSoftware Architecture
0 likes · 7 min read
Context Mapping Patterns in Domain-Driven Design
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Dec 14, 2021 · Fundamentals

What Really Defines Software Architecture? Core Concepts and Layers Explained

This article clarifies the fundamental concept of software architecture, distinguishes related terms such as system, subsystem, module, component, framework, and architecture, and outlines the five major architectural layers—business, application, data, code, technical, and deployment—providing a comprehensive guide for architects and developers.

Software ArchitectureSystem Designapplication architecture
0 likes · 12 min read
What Really Defines Software Architecture? Core Concepts and Layers Explained
Java Captain
Java Captain
Dec 12, 2021 · Backend Development

Why a Good Code Structure Matters and How to Design It: Models, Utils, Services, DAO, and Controllers

The article explains why a solid code structure is essential, outlines the principles of single responsibility, reusability and clear definitions, and details the roles of Model, Util, Service, DAO and Controller, while discussing their relevance to Web, Android and iOS development.

Model-View-ControllerSoftware Architecturecode-structure
0 likes · 9 min read
Why a Good Code Structure Matters and How to Design It: Models, Utils, Services, DAO, and Controllers
YunZhu Net Technology Team
YunZhu Net Technology Team
Dec 10, 2021 · Backend Development

Understanding Rule Engines: Concepts, Patterns, and Practical Applications

This article explains what a rule engine is, why it is useful, common products, core concepts such as rule files, LHS/RHS, facts, and various modeling patterns, as well as management, execution modes, real‑world use cases and best‑practice recommendations for building scalable backend rule‑processing systems.

Business RulesDecision TableSoftware Architecture
0 likes · 17 min read
Understanding Rule Engines: Concepts, Patterns, and Practical Applications
Java High-Performance Architecture
Java High-Performance Architecture
Dec 9, 2021 · Fundamentals

Bridging the Language Gap: How a Ubiquitous Domain Model Enhances DDD Collaboration

This article explains how mismatched vocabularies between domain experts and developers hinder project progress, and how establishing a shared, model‑driven language can reduce misunderstandings, streamline communication, and improve the reliability of software built with Domain‑Driven Design.

CollaborationDomain-Driven DesignSoftware Architecture
0 likes · 8 min read
Bridging the Language Gap: How a Ubiquitous Domain Model Enhances DDD Collaboration
Alibaba Cloud Developer
Alibaba Cloud Developer
Dec 7, 2021 · Backend Development

How to Standardize Business Architecture: A Layered Design Blueprint

This article presents a comprehensive, layer‑by‑layer framework for unifying business architecture design, detailing product contracts, business models, services, flows, components, infrastructure, and model adapters, and shows how low‑code and hard‑coded approaches can be combined to accelerate development while maintaining consistency.

Backend DevelopmentDesign PatternsSoftware Architecture
0 likes · 25 min read
How to Standardize Business Architecture: A Layered Design Blueprint
Architecture Digest
Architecture Digest
Dec 7, 2021 · Fundamentals

Bridging the Language Gap in Domain‑Driven Design

The article explains how mismatched vocabularies between domain experts and developers hinder project progress, and argues that establishing a shared, model‑driven language—central to Domain‑Driven Design—can improve communication, reduce misunderstandings, and create more reliable software.

CollaborationDomain-Driven DesignSoftware Architecture
0 likes · 8 min read
Bridging the Language Gap in Domain‑Driven Design
Qingyun Technology Community
Qingyun Technology Community
Nov 30, 2021 · Fundamentals

How Low‑Code Platforms Design Flexible Workflows: From Train Tracks to Nodes

This article explains workflow fundamentals using a train‑transport analogy, describes key design elements such as forms, task nodes, and routing, compares open‑source engines, and details a low‑code platform architecture that separates business logic, process control, and event handling for flexible, distributed execution.

NodeSoftware Architecturelow-code
0 likes · 11 min read
How Low‑Code Platforms Design Flexible Workflows: From Train Tracks to Nodes
HelloTech
HelloTech
Nov 30, 2021 · Backend Development

Applying Domain-Driven Design and Microservice Architecture in E-commerce Business

The talk demonstrates how to apply Domain‑Driven Design and microservice architecture to an e‑commerce voucher platform by defining problem spaces and bounded contexts, prioritizing boundaries over aggregates, using layered‑on‑demand infrastructure, and following SOLID principles to achieve clear, maintainable services.

DDDDomain-Driven DesignE‑Commerce
0 likes · 12 min read
Applying Domain-Driven Design and Microservice Architecture in E-commerce Business
Architects' Tech Alliance
Architects' Tech Alliance
Nov 29, 2021 · Fundamentals

Common Software Architecture Patterns and Their Characteristics

This article introduces seven widely used software architecture patterns—layered, multi‑layer, pipe‑filter, client‑server, MVC, event‑driven, and microservices—explaining their contexts, problems they solve, typical structures, advantages, drawbacks, and suitable application scenarios.

Design PatternsMVCMicroservices
0 likes · 10 min read
Common Software Architecture Patterns and Their Characteristics
Top Architect
Top Architect
Nov 27, 2021 · Fundamentals

Understanding Software Architecture: From Basic Concepts to the COLA Framework

This article explains the fundamentals of software architecture, why architecture is needed, the responsibilities of architects, various architecture categories, common styles such as layered, CQRS, hexagonal and onion architectures, and introduces the open‑source COLA framework with its layered design, extension points and standards.

COLA frameworkCQRSDesign Patterns
0 likes · 12 min read
Understanding Software Architecture: From Basic Concepts to the COLA Framework
Java High-Performance Architecture
Java High-Performance Architecture
Nov 26, 2021 · Fundamentals

Mastering Domain-Driven Design: Key Principles and Practical Insights

This article shares eight months of hands‑on experience with Domain‑Driven Design, explaining why traditional waterfall approaches hinder true business understanding and presenting practical notes, mind‑map visualizations, and step‑by‑step guidance on effective modeling, knowledge digestion, continuous learning, and deep model design.

Domain-Driven DesignSoftware Architectureagile-practices
0 likes · 12 min read
Mastering Domain-Driven Design: Key Principles and Practical Insights
DevOps Cloud Academy
DevOps Cloud Academy
Nov 26, 2021 · Operations

Key Capabilities for Continuous Delivery and DevOps Performance

The article outlines twenty‑four essential capabilities—including version control, automated deployment, continuous integration, trunk‑based development, test automation, lean management, and cultural practices—that together drive high‑performance software delivery and organizational effectiveness.

AutomationCultureLean Management
0 likes · 10 min read
Key Capabilities for Continuous Delivery and DevOps Performance
Sohu Tech Products
Sohu Tech Products
Nov 24, 2021 · Frontend Development

Modularization Practices in Vivo Game Center: Componentization, Configuration, and Experimentation

This article explains how Vivo Game Center adopted a modular architecture—combining componentization, configuration, and experiment-driven deployment—to enable rapid, flexible UI layout adjustments, unified backend processes, and data-driven A/B testing, thereby improving development efficiency and user‑targeted operations.

AB testingMobile AppSoftware Architecture
0 likes · 17 min read
Modularization Practices in Vivo Game Center: Componentization, Configuration, and Experimentation
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 23, 2021 · Fundamentals

Why Object‑Oriented Design Still Matters: From Machine Code to Domain‑Driven Architecture

This article traces the evolution of programming paradigms—from low‑level machine code through procedural and object‑oriented approaches—explains the pitfalls of poor abstraction, introduces domain‑driven design, and reviews key software design principles such as SOLID, OCP, DIP, PLOA and KISS.

Object-Oriented ProgrammingProgramming ParadigmsSOLID
0 likes · 21 min read
Why Object‑Oriented Design Still Matters: From Machine Code to Domain‑Driven Architecture
Architects' Tech Alliance
Architects' Tech Alliance
Nov 22, 2021 · Fundamentals

Understanding Software Architecture and the COLA Application Architecture

This article explains the concept of software architecture, its necessity, the role of architects, various architectural categories, typical patterns such as layered, CQRS, hexagonal and onion architectures, and introduces the COLA open‑source application architecture with its layered design, extension mechanisms, and specification guidelines.

COLACQRSSoftware Architecture
0 likes · 14 min read
Understanding Software Architecture and the COLA Application Architecture
IT Architects Alliance
IT Architects Alliance
Nov 21, 2021 · R&D Management

Mastering Software Architecture: From Basics to Evolution

This comprehensive guide explains the essence of software architecture, its layers and classifications, architectural levels, strategic versus tactical design, evolution from monoliths to micro‑services, common pitfalls, and key metrics for evaluating a sound architecture.

Best PracticesMicroservicesSoftware Architecture
0 likes · 22 min read
Mastering Software Architecture: From Basics to Evolution
Architects' Tech Alliance
Architects' Tech Alliance
Nov 19, 2021 · Fundamentals

Understanding Software Architecture: Concepts, Layers, Levels, Evolution, and Common Pitfalls

This article provides a comprehensive overview of software architecture, covering its definition, essential concepts such as systems, subsystems, modules, and frameworks, various architectural layers and classifications, evolution from monolithic to microservices, design principles, evaluation criteria, and typical misconceptions to avoid.

MicroservicesSoftware ArchitectureSystem Design
0 likes · 21 min read
Understanding Software Architecture: Concepts, Layers, Levels, Evolution, and Common Pitfalls
Architecture Digest
Architecture Digest
Nov 13, 2021 · Fundamentals

Anemic vs. Rich Domain Models: Core Concepts of Domain‑Driven Design

The article explains the differences between the anemic (transaction‑script) and rich (domain‑model) approaches in DDD, discusses their historical origins, advantages, drawbacks, and provides guidance on when and how to apply each model in software design.

Domain-Driven DesignObject-Oriented DesignRich Model
0 likes · 9 min read
Anemic vs. Rich Domain Models: Core Concepts of Domain‑Driven Design
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Nov 5, 2021 · Backend Development

Understanding Domain-Driven Design (DDD): Concepts, Design Process, and Architectural Practices

This article explains the fundamentals of Domain-Driven Design, covering its core concepts, step‑by‑step design methodology, domain modeling techniques, and how to apply DDD in microservice architectures with considerations for technical elements such as distributed transactions and scalability.

Backend DevelopmentDDDDomain-Driven Design
0 likes · 7 min read
Understanding Domain-Driven Design (DDD): Concepts, Design Process, and Architectural Practices
macrozheng
macrozheng
Nov 1, 2021 · Backend Development

Design Patterns in Java: Strategy, Chain, Template, Observer & Singleton

This article explores six classic design patterns—Strategy, Chain of Responsibility, Template Method, Observer, Factory, and Singleton—detailing their real‑world business scenarios, core principles, Java implementations with Spring integration, and how they improve code maintainability, extensibility, and adherence to SOLID principles.

JavaSOLIDSoftware Architecture
0 likes · 27 min read
Design Patterns in Java: Strategy, Chain, Template, Observer & Singleton
Top Architect
Top Architect
Oct 27, 2021 · Backend Development

Technical Architecture Design Principles: Strategy, Tactics, and Practical Guidelines

This article explains how to design robust technical architectures by applying strategic principles of suitability, simplicity, and evolution, and tactical principles covering high concurrency, high availability, and business design, while illustrating logical and physical architecture diagrams and offering practical implementation advice.

High AvailabilityHigh concurrencySoftware Architecture
0 likes · 15 min read
Technical Architecture Design Principles: Strategy, Tactics, and Practical Guidelines
Selected Java Interview Questions
Selected Java Interview Questions
Oct 25, 2021 · Fundamentals

Understanding Factory and Strategy Design Patterns in Java

This article explains the differences and similarities between the Factory and Strategy design patterns in Java, provides concrete code examples for each, and discusses how the Strategy pattern can offer more flexible behavior composition compared to the traditional Factory approach.

Design PatternsFactory PatternJava
0 likes · 7 min read
Understanding Factory and Strategy Design Patterns in Java
IT Architects Alliance
IT Architects Alliance
Oct 17, 2021 · Fundamentals

Why Domain-Driven Design (DDD) Became Popular and Its Role in Microservices

The article explains how Domain-Driven Design (DDD) rose to prominence by addressing business‑boundary challenges in microservice architectures, outlines the evolution of software architectures, and details DDD’s strategic and tactical design practices for creating clear, maintainable service boundaries.

DDDDomain-Driven DesignSoftware Architecture
0 likes · 9 min read
Why Domain-Driven Design (DDD) Became Popular and Its Role in Microservices
21CTO
21CTO
Oct 12, 2021 · Fundamentals

Good vs Bad Architecture: Principles, Patterns, and Practices for Scalable Systems

This article explains how good software architecture enables easy evolution, fault tolerance, and low maintenance, while bad architecture leads to complexity and brittleness, and it outlines key principles, design styles, and practical techniques such as domain‑centric, microservices, event‑driven, and CQRS to build robust, adaptable systems.

Design PatternsDomain-Driven DesignMicroservices
0 likes · 14 min read
Good vs Bad Architecture: Principles, Patterns, and Practices for Scalable Systems
Architecture Digest
Architecture Digest
Oct 12, 2021 · Fundamentals

Introduction to Domain-Driven Design (DDD)

This article provides a concise overview of Domain-Driven Design, explaining why it matters, defining key concepts such as domain, model, bounded context, and ubiquitous language, and illustrating how DDD helps teams tackle core software complexity through collaborative modeling and shared terminology.

DDDDomain-Driven DesignSoftware Architecture
0 likes · 11 min read
Introduction to Domain-Driven Design (DDD)
NetEase Cloud Music Tech Team
NetEase Cloud Music Tech Team
Oct 11, 2021 · Frontend Development

DrawIO Secondary Development: A Comprehensive Technical Guide

This guide walks developers through DrawIO secondary development, explaining why integration is needed, how to set up Java/Ant, clone and build the source, configure dev mode, deploy via various platforms, and use core APIs like getCurrentFile and loadFile, with a starter scaffold on GitHub.

Diagram ToolDrawioJavaScript
0 likes · 23 min read
DrawIO Secondary Development: A Comprehensive Technical Guide
Architect
Architect
Oct 11, 2021 · Databases

How to Efficiently Read Redis Source Code: A Step-by-Step Guide

This article presents a practical, seven‑step methodology for efficiently reading Redis source code, covering project mapping, prerequisite knowledge, starting from basic modules, identifying the core execution path, balancing overall structure with detailed logic, handling auxiliary features, and performing targeted gap‑filling to master the codebase.

RedisSoftware Architecturedatabase
0 likes · 14 min read
How to Efficiently Read Redis Source Code: A Step-by-Step Guide
Programmer DD
Programmer DD
Oct 10, 2021 · Backend Development

Why Scaffolding Frameworks Like Spring Boot Are Essential for Modern Backend Development

Microservice architecture introduces complexity, but using scaffolding tools such as Spring Boot and Spring Data lets developers focus on business logic by providing reusable components, reducing duplication, and simplifying data access, while avoiding the pitfalls of building custom persistence layers from scratch.

Backend DevelopmentMicroservicesScaffolding
0 likes · 12 min read
Why Scaffolding Frameworks Like Spring Boot Are Essential for Modern Backend Development
IT Architects Alliance
IT Architects Alliance
Oct 10, 2021 · Industry Insights

10 Essential Software Architecture Patterns Every Engineer Should Know

This article introduces ten fundamental software architecture patterns—including layered, client‑server, master‑slave, pipe‑filter, proxy, P2P, event‑bus, MVC, blackboard, and interpreter—explaining their structures, typical use cases, advantages, and drawbacks to help developers choose the right design for large‑scale systems.

Design PatternsSoftware ArchitectureSystem Design
0 likes · 9 min read
10 Essential Software Architecture Patterns Every Engineer Should Know
Architects' Tech Alliance
Architects' Tech Alliance
Oct 9, 2021 · Fundamentals

Understanding Software Architecture: History, Concepts, and Definitions

This article explores the evolution of software development from machine code to high‑level languages, explains the two software crises, and defines key architectural concepts such as systems, subsystems, modules, components, frameworks, and the role of software architecture in managing complexity.

Software Architecturearchitectural fundamentalshistory of programming
0 likes · 14 min read
Understanding Software Architecture: History, Concepts, and Definitions
Java Architect Essentials
Java Architect Essentials
Oct 7, 2021 · Fundamentals

Understanding Software Architecture: Concepts, Layers, Types, and Evolution

This article explains the essence of software architecture, defining systems, subsystems, modules, components, frameworks, and various architectural layers such as business, application, data, code, technical, and deployment, and discusses architectural evolution from monolithic to distributed and microservice designs, including common pitfalls and recommended reading.

Software ArchitectureSystem Designarchitecture patterns
0 likes · 21 min read
Understanding Software Architecture: Concepts, Layers, Types, and Evolution
Architect
Architect
Oct 5, 2021 · Fundamentals

Understanding Entities and Value Objects in Domain‑Driven Design: Why a Message Should Be an Entity and Contacts Should Be Treated as Entities

The article explains the core characteristics of entities—identity and continuity—using DDD concepts, demonstrates why a Message in a messaging scenario qualifies as an entity, and argues that senders and recipients (contacts) should also be modeled as entities rather than value objects.

DDDDomain-Driven DesignEntity
0 likes · 12 min read
Understanding Entities and Value Objects in Domain‑Driven Design: Why a Message Should Be an Entity and Contacts Should Be Treated as Entities