The article illustrates Separation of Concerns beyond AOP by refactoring a reconciliation service that mixes WeChat Pay and Alipay SDK calls with business logic, introducing a wrapper layer with custom types to isolate SDK-specific parsing from core matching rules, enabling independent evolution of each concern.
This article explains why independently deployed services can still have chaotic internal architecture, and demonstrates how to separate business rules, use cases, ports, and adapters to ensure dependencies point inward, enabling testable, evolvable systems without mechanically applying layered templates.
The article explains why solid architecture matters for Java projects, outlines seven mainstream architectural patterns—including layered, DDD, hexagonal, clean, CQRS, event‑driven, and microkernel—and provides a decision guide to help teams choose the most suitable approach based on complexity, experience, performance, and evolution needs.
This article distills the core concepts of Robert C. Martin’s Clean Architecture, covering layered design, SOLID principles, component cohesion and coupling rules, boundary strategies, the onion model, and why databases are merely infrastructure, all illustrated with concrete code examples and diagrams.
This article presents five practical patterns—single‑use‑case classes, a lightweight Facade, self‑validating input records, domain‑event side‑effects, and ports‑and‑adapters—that transform monolithic Spring @Service classes into modular, readable, testable, and transaction‑safe components, improving maintainability and extensibility.
The article examines how software architecture has progressed from the traditional DDD four‑layer structure through Hexagonal, Onion, and Clean architectures, explaining essential versus accidental complexity, layering principles, dependency inversion, and how each pattern refines modularity, testability, and dependency direction.
The article details a large‑scale AI‑driven refactor of Gaode's store front‑end, explaining why AI was needed, the four core technologies (FilePlan, Task Orchestrator, Clean‑Spec, Knowledge‑Loop), concrete metrics such as 624 AI commits, 6000 anti‑patterns cleared, and the resulting architectural, component and quality improvements.
The article explains that Onion Architecture’s essence lies in inward‑facing dependencies rather than the visual onion shape, details its six‑layer structure, clarifies common misconceptions, and compares it with Clean and Hexagonal architectures to show how it improves testability and replaceability.
Hexagonal Architecture’s true essence lies in its ports‑and‑adapters structure and technology‑agnostic core, not the six‑sided diagram, and the article explains this concept, its driving vs. driven sides, its relation to DIP, common misconceptions, and how it aligns with Clean and Onion architectures.
The article explains that Clean Architecture’s true essence lies in the immutable Dependency Rule—dependencies must always point inward—while the four‑layer diagram is merely a flexible skeleton, and it clarifies common misconceptions, ties to SOLID, and shows how to apply the rule across Hexagonal and Onion variants.
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.
A comprehensive practical guide to implementing Domain-Driven Design in complex business systems, covering bounded context division using Event Storming and subdomain analysis, aggregate root and entity design with code examples, domain event patterns for decoupling and eventual consistency, and integrating DDD with Spring Boot's layered architecture using onion/clean architecture principles.
This step‑by‑step guide shows how to use the Go‑Kratos microservice framework to create a clean‑architecture user service, covering environment setup, project scaffolding, Protobuf API definition, code generation, layered implementation (biz, data, service), server registration, and testing with curl.
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.
This article details the integration and optimization of Amap Flutter plugins (amap_flutter_map, amap_flutter_location) in an OpenHarmony project, covering Clean Architecture layering, tile caching, memory management, cross-platform adaptations for Android/iOS, error handling, and a complete HarmonyOS bridge/adapter implementation in ArkTS.
Even a minor UI adjustment, like reshaping a product list or tweaking a cart button, can trigger crashes, state loss, and hard‑to‑track side effects in Android apps; this article explains why solid architecture—separating concerns with Clean Architecture, SOLID principles, and layered design—prevents such disasters and eases future migrations.
This article explains the evolution and benefits of layered software architecture—from early two‑layer designs to MVC, DDD, Clean Architecture, and the Monet framework—highlighting how clear responsibilities, adaptability, and proper dependency direction improve maintainability, scalability, and team collaboration.
This article examines the growing complexity of a points‑mall front‑end, identifies architectural and code‑organization pain points, and demonstrates how applying Clean Architecture together with Vue 3's Composition API can decouple business logic from UI, improve maintainability, and streamline development.
Clean software architecture, built on principles like vertical and horizontal separation and proper module qualification, reduces complexity and technical debt, boosts scalability, flexibility, and reliability, and guides organizations in proactively managing architectural health through continuous assessment, AI-driven observability, and targeted team training.
This guide explains the purpose of UseCases, best practices for their responsibilities, naming conventions, thread‑safety considerations, common anti‑patterns, and answers frequent questions, providing Kotlin code examples to illustrate correct and incorrect implementations.
The team refactored a high‑traffic Vue2 detail page to Vue3 using Clean Architecture, separating entities, use‑cases, adapters, and framework layers, while employing AST‑based tooling, comprehensive unit/E2E/visual tests, and a gray‑release strategy, resulting in reduced duplication, better test coverage, and a reusable migration pipeline.
This article examines the role of UseCase in Android's modern architecture, clarifies its responsibilities, demonstrates proper naming, thread‑safety, signature design, referential transparency, and interface abstraction, and provides concrete Kotlin examples of both incorrect and correct implementations.
This article explains how to organize Android Gradle modules using component design principles—covering cohesion, coupling, module splitting, encapsulation, and integration—while relating them to SOLID and providing concrete examples, formulas, and best‑practice guidelines.
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.
This article explains how to start a new project using Domain-Driven Design, covering IAAS/PAAS/SAAS terminology, architecture evolution, bounded contexts, the four DDD boundaries, clean layered, hexagonal, and onion architectures, and their impact on microservice design.
UseCase objects, placed in the Domain layer of modern Android architecture, encapsulate complex business logic that was previously crammed into ViewModels, thereby enforcing clean separation of concerns, adhering to the Single Responsibility Principle, and making the codebase clearer, more maintainable, and scalable.
This article shares practical experiences and detailed technical solutions for applying Domain‑Driven Design, Clean (Onion) Architecture, CQRS, and Saga patterns in backend systems, covering theory recap, modeling methods, module separation, code examples, and distributed transaction strategies.
The article explains clean, hexagonal, and DDD layered architectures, detailing each layer’s responsibilities, principles, and evolution, and shows how DDD layering enhances microservice design, promotes strict separation, supports architectural evolution, and guides the transition from traditional three‑tier systems to modern domain‑driven microservices.
This article provides a detailed overview of the latest 2023 trends, tools, libraries, architectural patterns, and best practices for developing modern Android applications, covering everything from Kotlin and Jetpack Compose to Clean Architecture, modularization, performance optimization, and Google Play features.
This article explains why software architecture matters, defines the essence of Clean Architecture, compares it with Hexagonal and DDD layered models, and walks through a practical, step‑by‑step process—from business analysis and domain modeling to layer implementation and code examples—showing how to reduce complexity and maintenance cost.
The article explains why solid software architecture matters, introduces Robert C. Martin’s Clean Architecture and its framework‑, UI‑, database‑, and service‑independent principles, compares it with Hexagonal and DDD layered styles, details strategic and tactical phases for front‑end MVVM projects, provides layered code samples, and weighs its benefits against the initial overhead, urging teams to choose the approach that fits their project’s complexity and lifespan.
This article introduces a DDD scaffolding project, explains its theoretical foundations, presents the layered architecture and generation commands, details coding conventions for each module, and addresses frequent questions and solutions for practical adoption.
This article explains how to apply Clean Architecture principles to a frontend React/TypeScript project, covering the three‑layer structure, dependency rules, domain modeling, use‑case design, adapter implementation, code organization, trade‑offs, and practical tips for building a cookie‑store example.
This article explains why code architecture matters, compares Clean, Hexagonal, Onion and COLA patterns, describes their layered structures and separation‑of‑concerns principles, and provides a practical Go project layout with concrete code examples to illustrate how each layer interacts.
This article walks through the historical evolution of backend architecture—from early N‑layered designs, through DDD, Hexagonal, Onion, and finally Clean Architecture—explaining why each style emerged, how they differ, and what practical rules developers can follow to manage complexity and dependencies.
This article explains the COLA (Clean Object‑Oriented and Layered Architecture) framework, its layered structure, component breakdown, and practical implementation details with SpringBoot, including code examples, module organization, and design principles for building maintainable backend systems.
This article explains clean architecture concepts—domain, use case, and application layers—and demonstrates how to apply them in a frontend React/TypeScript project, covering design principles, layer responsibilities, dependency rules, advantages, costs, and concrete code examples for a cookie‑shop example.
This article explains how to start a new project using Domain‑Driven Design, covering key terminology, architecture evolution, bounded contexts, the four DDD boundaries, and common architectural styles such as clean layered, hexagonal, and onion architectures.
This article explains how to start a new project using Domain‑Driven Design (DDD), covering service terminology, architectural evolution from monolith to microservices, bounded contexts, the four DDD boundaries, clean layered, hexagonal, and onion architectures, and their practical benefits for backend systems.
This article explains how to apply Domain-Driven Design (DDD) from project inception, covering key terminology, architectural evolution, bounded contexts, the four DDD boundaries, and various layered architectures such as clean, hexagonal, and onion models to achieve modular, maintainable systems.
This article explains how the author applied Domain‑Driven Design to build a microservice for an internal trading center, reviewing DDD strategic and tactical design, various architecture layer theories, a customized layered architecture, Maven module structure, and detailed responsibilities of each layer while sharing practical tips and challenges.
This article walks through the author’s two‑year experience applying Domain‑Driven Design to payment, settlement and fund services, explains strategic vs tactical design, compares classic DDD layers, Clean, Hexagonal and Diamond architectures, details module organization, CQRS, and shares practical pros, cons and implementation tips.
This article explains how to apply Domain‑Driven Design (DDD) to a brand‑new project, covering essential terminology, architecture evolution across SaaS, PaaS, IaaS, bounded‑context segmentation, the four DDD boundaries, clean layered, hexagonal, and onion architectures, and provides practical guidance for effective system design.
This article explains how to start a new project using Domain‑Driven Design, covering terminology, architecture evolution from monolith to microservices, bounded‑context definition, the four DDD boundaries, clean layered, hexagonal and onion architectures, and practical guidelines for effective system design.
This article explains how to start a new project using Domain‑Driven Design, covering key terminology, the evolution of architecture layers, bounded context concepts, the four DDD boundaries, and various architectural styles such as clean layered, hexagonal, and onion architectures.
This article explains how to start a new project using Domain‑Driven Design, covering terminology, the evolution from SaaS to IaaS, bounded‑context concepts and division rules, the four DDD boundaries, and how clean, hexagonal, and onion architectures realize these principles for scalable backend systems.
This article explains how to start a new project using Domain‑Driven Design, covering key terminology, architecture evolution from monolith to microservices, bounded context division, the four DDD boundaries, clean layered, hexagonal and onion architectures, and practical design guidelines for backend systems.
The team combats outdated documentation and costly front‑end maintenance by treating unit tests for the use‑case layer as living documentation, using BDD‑style Given‑When‑Then tests that assert only observable behavior, which improves code readability, eases onboarding, and provides a reliable safety net for future changes.
This article explains how to apply Domain-Driven Design (DDD) to a new project, detailing the evolution from monolithic to microservice architectures, the concepts of IaaS, PaaS, SaaS, bounded contexts, the four DDD boundaries, and clean, hexagonal, and onion architectural patterns.
This article explains how to start a new project using Domain‑Driven Design, covering terminology, architecture evolution from monolith to microservices, bounded‑context concepts, four‑layer DDD boundaries, clean layered, hexagonal and onion architectures, and practical division rules.
This article explains how to start a new project using Domain‑Driven Design, describes the evolution from SaaS to PaaS to IaaS, introduces bounded contexts, the four‑layer DDD boundaries, and compares clean, hexagonal, and onion architectures for building maintainable backend systems.
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.
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.
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.
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.
This tutorial walks through adding pagination and flexible where‑filters to the User List interface, configuring gqlgen extensions, handling GraphQL errors, wrapping mutations in transactions, and building unit, integration, and end‑to‑end tests for a Go clean‑architecture project using Ent and gqlgen.
This article walks through integrating the four Clean Architecture layers—entity, use‑case, interface‑adapter, and framework/driver—into a Go application using ent for ORM and gqlgen for GraphQL, covering folder layout, ULID primary keys, Node interface support, and pagination implementation.
This tutorial walks through creating a maintainable GraphQL application using Go, demonstrating how to set up a Docker‑based MySQL database, configure Viper and Echo, define ent schemas, run migrations, integrate gqlgen with ent, and implement queries and mutations following Clean Architecture principles.
This article explores software architecture concepts by drawing parallels with building design, explains the goals of architectural design such as scalability and maintainability, and demonstrates a practical Android MVVM implementation using WanAndroid with clean‑architecture patterns, Kotlin, and modular project structure.
To tame the growing complexity of QQ Music’s Android playback page, the team replaced the monolithic MVC/SubController design with a clean, layered architecture that uses lightweight, lifecycle‑aware ViewDelegates and LiveData, enabling on‑demand module loading, clear separation of concerns, reduced memory usage, and reusable UI components.
This article explains the principles and benefits of Domain-Driven Design, covering its strategic and tactical design processes, bounded contexts, layered and hexagonal architectures, integration with micro‑services, CQRS, and the practical challenges of applying DDD in complex business systems.
This article introduces Domain‑Driven Design, explains its strategic and tactical layers, walks through domain‑model discovery methods such as Event Storming and the Four‑Color model, details aggregate design, cross‑database query solutions, CQRS, Event Sourcing, and several clean‑architecture styles to help engineers build maintainable, business‑driven systems.
This article walks through a simple e‑commerce order flow, highlights the drawbacks of tightly coupled service code, and demonstrates step‑by‑step refactorings—introducing repository abstractions, domain entities, an anti‑corruption layer, and a generic message producer—to achieve a clean, extensible, and testable backend architecture.
This article surveys recent advances such as running Node.js directly in the browser with WebContainers, GitHub's large‑scale adoption of Web Components, the principles of Clean Architecture, the zx shell‑script tool, and a product‑reliability "3+1" evaluation method.
This article explains the concept of Explicit Architecture, describing how core modules, tools, ports, adapters, and component organization combine hexagonal, onion, clean, and CQRS patterns to achieve a loosely‑coupled, highly‑cohesive software system suitable for both monolithic and micro‑service applications.
The article explains how monolithic drawbacks—complexity, technical debt, and scaling issues—drive the shift to microservices, then details applying Domain‑Driven Design principles such as bounded contexts, aggregates, and layered architecture to design cohesive, loosely‑coupled services, illustrated with e‑commerce examples and code snippets.
This article details how Ctrip's ticket‑search list page was refactored with clean‑architecture principles, introducing a unidirectional data flow, business Service layer, and plugin‑based aspect‑oriented modules to improve maintainability, testability, and cross‑platform reuse of front‑end code.
Domain‑Driven Design, a mindset rather than a rigid methodology, clarifies business complexity through a central domain model, layered and hexagonal architectures, bounded contexts, and repository patterns—dispelling myths that it suits only large projects or adds excessive boiler‑plate, and showing practical Java implementation.
This article distills the core concepts of the book “Clean Architecture,” outlining software system value, architecture goals, programming paradigms, design principles such as OCP, SRP, DIP, and practical guidelines for component splitting, dependency handling, and boundary design to build maintainable systems.
This article explores the principles of Clean Architecture, explains layered thinking and dependency rules, discusses how to apply them in real projects, and reflects on the broader meaning of software architecture, including domain‑driven design and practical advice for developers seeking to improve their design skills.
This article revisits the author’s earlier talk on software architecture, reorganizes and expands it with detailed explanations of Clean Architecture’s layered design, dependency rules, and related concepts such as DDD, while reflecting on how these ideas can reduce code modification difficulty and guide personal growth as an architect.
The article describes how Ctrip's front‑end team refactored a complex React Native flight‑search list page using Clean Architecture, detailing the layered module design, TypeScript implementation, data flow, and why alternatives such as Redux, React components, and Hooks were rejected.
This article explains why placing business logic directly in controllers or models leads to redundancy in Laravel applications and introduces action classes as a modular, testable alternative, detailing their design principles, nesting, and decoration with practical code examples.
This guide explains how to apply clean architecture principles to Android development by separating concerns into presentation, domain, and data layers, ensuring framework, UI, and database independence, and providing testing strategies and error‑handling techniques for a maintainable app.
