Tagged articles
clean architecture
75 articles · Page 1 of 1
This article details a systematic refactoring of a chat assistant Android app, applying SRP, DIP, OCP, layered architecture, and naming conventions to eliminate god classes and tight coupling, while uncovering a JNI symbol mismatch bug that only appears at runtime, and sharing insights on AI-assisted coding limitations.
AI-assisted codingAndroid developmentJNI
0 likes · 18 min read

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.
JavaReconciliation ServiceSDK Integration
0 likes · 7 min read

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.
Layered Testingbusiness rules isolationclean architecture
0 likes · 22 min read


webdreamJul 18, 2026 · Backend Development
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.
JavaLayered Architecturearchitecture
0 likes · 11 min read

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.
Layered ArchitectureSOLIDclean architecture
0 likes · 12 min read

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.
FacadeSpring BootUse Case
0 likes · 15 min read

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.
DDDLayered ArchitectureOnion Architecture
0 likes · 12 min read

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.
AI‑Driven RefactoringFrontend ArchitectureReact
0 likes · 27 min read

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.
Onion Architectureclean architecturedependency inversion
0 likes · 12 min read

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.
Dependency Inversion PrincipleOnion Architectureclean architecture
0 likes · 11 min read

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.
Dependency RuleLayered ArchitectureOnion Architecture
0 likes · 12 min read


ZhiKe AIJun 1, 2026 · Backend Development
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.
CAPPACELCclean architecture
0 likes · 12 min read

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.
Aggregate RootBounded ContextDDD
0 likes · 37 min read

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.
CRUDGoHTTP
0 likes · 14 min read

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.
DDDclean architecturedomain-driven design
0 likes · 8 min read

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.
AmapArkTSFlutter
0 likes · 19 min read

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.
AndroidKotlinMVVM
0 likes · 19 min read

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.
BackendDDDarchitecture
0 likes · 18 min read

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.
Composition APIclean architecturesoftware design
0 likes · 22 min read


21CTONov 13, 2024 · Fundamentals
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.
clean architecturemicroservicessoftware design
0 likes · 9 min read

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.
KotlinUseCaseclean architecture
0 likes · 11 min read

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.
Vue3automationclean architecture
0 likes · 23 min read

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.
AndroidBest PracticesDomain Layer
0 likes · 10 min read

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.
AndroidCohesionComponent Principles
0 likes · 24 min read

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.
DDDJavaPricing System
0 likes · 14 min read

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.
Bounded Contextarchitectureclean architecture
0 likes · 10 min read

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.
AndroidDomain LayerMVVM
0 likes · 7 min read

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.
BackendDDDSaga
0 likes · 28 min read

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.
DDDLayered Architectureclean architecture
0 likes · 21 min read

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.
AndroidJetpack ComposeKotlin
0 likes · 16 min read

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.
BackendDDDclean architecture
0 likes · 21 min read

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.
Architecture Patternsclean architecturedomain-driven design
0 likes · 21 min read

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.
DDDbackend architectureclean architecture
0 likes · 11 min read

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.
Dependency RuleReactTypeScript
0 likes · 34 min read

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.
clean architecturecode organizationsoftware architecture
0 likes · 19 min read

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.
DDDN‑layeredOnion Architecture
0 likes · 17 min read

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.
COLAJavaLayered Architecture
0 likes · 17 min read

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.
clean architecturedomain-driven designfrontend
0 likes · 40 min read

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.
Bounded ContextDDDclean architecture
0 likes · 9 min read

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.
BackendDDDHexagonal
0 likes · 8 min read

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.
Bounded Contextclean architecturedomain-driven design
0 likes · 9 min read

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.
DDDclean architecturecqrs
0 likes · 16 min read

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.
DDDJavaclean architecture
0 likes · 22 min read

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.
Bounded ContextOnion Architectureclean architecture
0 likes · 9 min read

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.
Bounded ContextOnion Architectureclean architecture
0 likes · 9 min read

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.
Bounded Contextclean architecturedomain-driven design
0 likes · 10 min read

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.
BackendBounded ContextOnion Architecture
0 likes · 9 min read

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.
Onion Architecturebackend developmentclean architecture
0 likes · 10 min read

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.
BDDJavaScriptMocking
0 likes · 13 min read

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.
Bounded ContextDDDOnion Architecture
0 likes · 9 min read

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.
DDDHexagonalOnion
0 likes · 9 min read

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.
BackendDDDOnion Architecture
0 likes · 9 min read

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.
Bounded ContextDDDclean architecture
0 likes · 9 min read

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.
Bounded Contextclean architecturedomain-driven design
0 likes · 10 min read

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.
Go backendclean architecturecode organization
0 likes · 14 min read

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.
clean architecturecqrsdesign patterns
0 likes · 22 min read


Code DAOJan 18, 2022 · Backend Development
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.
GoPaginationclean architecture
0 likes · 23 min read


Code DAOJan 15, 2022 · Backend Development
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.
GoGraphQLPagination
0 likes · 19 min read


Code DAOJan 1, 2022 · Backend Development
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.
DockerECHOGo
0 likes · 22 min read

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.
AndroidKotlinMVVM
0 likes · 13 min read

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.
AndroidLiveDataMVVM
0 likes · 23 min read

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.
clean architecturedomain-driven designmicroservices
0 likes · 39 min read

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.
clean architecturecqrsdomain modeling
0 likes · 15 min read

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.
JavaService Layerclean architecture
0 likes · 9 min read


Aotu LabMay 27, 2021 · Frontend Development
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.
WebContainersclean architectureproduct evaluation
0 likes · 8 min read

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.
Onion Architectureclean architecturecqrs
0 likes · 22 min read

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.
Javaaggregatesclean architecture
0 likes · 26 min read

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.
Aspect-Oriented ProgrammingMVPTypeScript
0 likes · 10 min read

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.
Javaclean architecturedomain-driven design
0 likes · 20 min read

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.
Design PrinciplesProgramming Paradigmsclean architecture
0 likes · 21 min read


21CTOAug 9, 2019 · Fundamentals
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.
Dependency RuleLayered Architectureclean architecture
0 likes · 15 min read

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.
Architecture PrinciplesDependency RuleGo
0 likes · 15 min read

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.
Frontend ArchitectureReact NativeTypeScript
0 likes · 18 min read

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.
Action ClassesLaravelPHP
0 likes · 7 min read


21CTONov 22, 2015 · Mobile Development
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.
AndroidMVPclean architecture
0 likes · 9 min read
