BestHub
Sign in
Tagged articles

Software Architecture

1324 articles · Page 5 of 14
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Mar 21, 2024 · Fundamentals

Refactoring Multi‑Board SDK Integration Using Abstract Factory, Adapter, and Facade Patterns

The article analyzes a multi‑board Android SDK integration problem, identifies hard‑coded type checks and inconsistent APIs, and proposes a refactor that employs the Abstract Factory, Adapter, and Facade design patterns with Kotlin examples to achieve loose coupling, extensibility, and clearer business concepts.

Abstract FactoryDesign PatternsKotlin
0 likes · 10 min read
Refactoring Multi‑Board SDK Integration Using Abstract Factory, Adapter, and Facade Patterns
Tencent Cloud Developer
Tencent Cloud Developer
Mar 13, 2024 · R&D Management

From Building to Dismantling Middle Platform: Enterprise Software Architecture Evolution

The article traces the rise and recent re‑configuration of the enterprise “middle platform” strategy—originally adopted to reduce redundancy, speed R&D, and improve stability—while highlighting its boundary, flexibility, and governance challenges, and advises firms to adopt or decentralize such platforms according to their growth stage and business complexity.

Platform strategyR&D managementSoftware Architecture
0 likes · 10 min read
From Building to Dismantling Middle Platform: Enterprise Software Architecture Evolution
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Mar 12, 2024 · Fundamentals

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

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

DDDDesign PatternsDomain-Driven Design
0 likes · 10 min read
Understanding Domain-Driven Design (DDD) Architecture: Concepts, Layers, and Core Principles
Programmer DD
Programmer DD
Mar 11, 2024 · Fundamentals

How to Master Architecture Thinking and Fast‑Track Your Path to CTO

This article explains why becoming a software architect requires more than coding excellence, outlines the architect's responsibilities, thinking models, career stages, and presents four practical laws and a roadmap from programmer to CTO, all drawn from the book "Architecture Thinking: From Programmer to CTO".

CTOSoftware Architecturearchitectural thinking
0 likes · 9 min read
How to Master Architecture Thinking and Fast‑Track Your Path to CTO
Su San Talks Tech
Su San Talks Tech
Mar 6, 2024 · Backend Development

Mastering Java Design Patterns: From High Cohesion to Low Coupling in Spring

This article explains the core concepts of high cohesion and low coupling, introduces common Java design patterns, demonstrates how Spring applies these patterns such as Singleton, Factory, Proxy, Observer, Chain of Responsibility, and Template Method, and provides practical code examples for real‑world scenarios.

Design PatternsHigh CohesionJava
0 likes · 19 min read
Mastering Java Design Patterns: From High Cohesion to Low Coupling in Spring
Java Captain
Java Captain
Feb 26, 2024 · Fundamentals

Principles, Advantages, Challenges, and Future of Multithreaded Architecture

This article examines multithreaded architecture, explaining its core principles, highlighting efficiency and resource utilization benefits, discussing synchronization, communication, and management challenges along with mitigation strategies, and exploring its future impact on cloud computing, big data, AI, and overall system performance.

Parallel ComputingSoftware Architecture
0 likes · 5 min read
Principles, Advantages, Challenges, and Future of Multithreaded Architecture
JD Tech
JD Tech
Feb 16, 2024 · Fundamentals

Understanding Software Architecture: Definitions, Boundaries, and Design Principles

This article explores the core concepts of software architecture, presenting various definitions from IEEE, Martin Fowler, Ralph Johnson and Neil Ford, and discusses architecture boundaries, the relationship between architecture and detailed design, patterns versus styles, and the knowledge models needed for architects and developers.

Design PrinciplesSoftware ArchitectureSystem Design
0 likes · 16 min read
Understanding Software Architecture: Definitions, Boundaries, and Design Principles
MaGe Linux Operations
MaGe Linux Operations
Feb 8, 2024 · Fundamentals

Why Layered Architecture Remains the Backbone of Modern Software Design

The article explains layered (n‑tier) architecture as a universal software design pattern, detailing its purpose, typical four‑layer structure, design considerations, advantages, and drawbacks such as limited agility, deployment challenges, and potential for the sinkhole anti‑pattern, while offering guidance for effective implementation.

Software ArchitectureSystem Designlayered architecture
0 likes · 9 min read
Why Layered Architecture Remains the Backbone of Modern Software Design
21CTO
21CTO
Feb 7, 2024 · Fundamentals

Mastering Architectural Abstraction: Simplify Complex Systems

This article explains how architects manage complexity through abstraction, offering practical induction and deduction techniques to identify commonalities, relationships, and characteristics, and illustrating these methods with real‑world examples like installment financing and Java technology.

Software Architectureabstractioncomplexity management
0 likes · 9 min read
Mastering Architectural Abstraction: Simplify Complex Systems
Architect
Architect
Feb 2, 2024 · Backend Development

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

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

Clean ArchitectureDDDDomain-Driven Design
0 likes · 14 min read
How DDD Transforms a Complex Pricing System: A Step‑by‑Step Architectural Guide
21CTO
21CTO
Jan 25, 2024 · Fundamentals

Why Software Architecture Fails: Entropy, Broken Windows, and Sustainable Design

This article explains how entropy, the broken‑window effect, and accumulated complexity erode software systems, compares behavior and architecture value dimensions, and presents fundamental principles such as Ockham's razor, SOLID, layering, and anti‑corruption layers to build maintainable, low‑cost architectures.

ComplexityDesign PrinciplesSOLID
0 likes · 17 min read
Why Software Architecture Fails: Entropy, Broken Windows, and Sustainable Design
Architect
Architect
Jan 25, 2024 · Fundamentals

Key Principles of Software Architecture: Entropy, Broken Windows, Complexity, SOLID, and Design Strategies

This article explains essential software architecture concepts such as entropy and broken‑window effects, the sources and symptoms of complexity, the importance of orthogonality and consistency, and classic design principles like SOLID, DRY, and layered abstraction to guide architects in building maintainable, flexible systems.

ComplexityDRYDesign Principles
0 likes · 18 min read
Key Principles of Software Architecture: Entropy, Broken Windows, Complexity, SOLID, and Design Strategies
DevOps
DevOps
Jan 24, 2024 · R&D Management

The Impossible Triangle of Low‑Code Platforms: Balancing Ease of Use, Power, and Complexity

This article analyses the inherent trade‑offs of low‑code platforms, explaining why the three core goals—easy to use, powerful functionality, and low system complexity—cannot be simultaneously achieved, and proposes focusing on the most common scenarios while providing escape‑hatch mechanisms for advanced needs.

DevOpsPlatform designSoftware Architecture
0 likes · 10 min read
The Impossible Triangle of Low‑Code Platforms: Balancing Ease of Use, Power, and Complexity
Sohu Tech Products
Sohu Tech Products
Jan 24, 2024 · Mobile Development

The Purpose of UseCase in Android Architecture

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.

AndroidClean ArchitectureDomain Layer
0 likes · 7 min read
The Purpose of UseCase in Android Architecture
DevOps
DevOps
Jan 22, 2024 · Fundamentals

Understanding Software Architecture: Concepts, Types, Principles, and Common Pitfalls

This article explains the fundamental concepts of software architecture, distinguishes between systems, subsystems, modules, components, frameworks and architectures, outlines the evolution from monolithic to distributed and micro‑service designs, presents fifteen universal design principles, and highlights typical mistakes architects should avoid.

Design PrinciplesSoftware ArchitectureSystem Design
0 likes · 21 min read
Understanding Software Architecture: Concepts, Types, Principles, and Common Pitfalls
Architect
Architect
Jan 19, 2024 · Fundamentals

Module Tree Driven Design (MTDD): A New Approach to Reducing Software Complexity

The article introduces Module Tree Driven Design (MTDD), a methodology that visualizes system modules as a hierarchical tree to align business, product, and development teams, thereby addressing documentation gaps, high software complexity, and maintenance costs while providing concrete Java annotation examples and a comparison with TMF.

Java AnnotationsMTDDSoftware Architecture
0 likes · 19 min read
Module Tree Driven Design (MTDD): A New Approach to Reducing Software Complexity
Tencent Cloud Developer
Tencent Cloud Developer
Jan 19, 2024 · Backend Development

Should You Use Exceptions in Modern C++? A Deep Dive into Consistency, Coroutines, and Real‑World Trade‑offs

This article revisits a 2017 decision to ban exceptions in a large codebase, examines the technical and organizational reasons behind that rule, analyzes exception mechanics, coroutine interactions, and performance impacts with concrete C++ examples, and finally proposes a pragmatic action plan for safely adopting exception‑driven design.

C++PerformanceSoftware Architecture
0 likes · 33 min read
Should You Use Exceptions in Modern C++? A Deep Dive into Consistency, Coroutines, and Real‑World Trade‑offs
Didi Tech
Didi Tech
Jan 18, 2024 · Backend Development

XIAOJUSURVEY: A Lightweight and Secure Open-Source Survey System

XIAOJUSURVEY is an open-source, lightweight yet secure enterprise-grade survey platform derived from Didi’s internal system, offering end-to-end questionnaire creation, distribution, collection, analysis and reporting, with customizable question types, schema-based architecture, pluggable security, and future extensions for collaboration and market-place features.

Software ArchitectureSurvey Systementerprise-platform
0 likes · 9 min read
XIAOJUSURVEY: A Lightweight and Secure Open-Source Survey System
政采云技术
政采云技术
Jan 16, 2024 · Fundamentals

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

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

Design PatternDomain-Driven DesignFinite State Machine
0 likes · 13 min read
Understanding Finite State Machines: Definitions, Usage, Advantages, and Their Relation to Domain‑Driven Design
Architects Research Society
Architects Research Society
Jan 15, 2024 · Fundamentals

Evolution of Software Architecture Styles and Domains

This article outlines the evolution of software architecture styles, describing various architectural domains and sub‑domains—from web and mobile applications to integration, data, and analytics architectures—and their typical implementations, illustrated with a detailed classification table.

AnalyticsDomain ArchitectureSoftware Architecture
0 likes · 8 min read
Evolution of Software Architecture Styles and Domains
IT Architects Alliance
IT Architects Alliance
Jan 8, 2024 · Fundamentals

Five Common Software Architecture Patterns and Their Ideal Use Cases

This article examines five prevalent software architecture styles—monolithic, microservices, client‑server, distributed, and cloud‑native—explaining their characteristics, advantages, and suitable scenarios to help developers choose the most appropriate design for their projects in modern software development.

Design PatternsSoftware Architecturecloud-native
0 likes · 5 min read
Five Common Software Architecture Patterns and Their Ideal Use Cases
DevOps
DevOps
Jan 2, 2024 · Fundamentals

Understanding Software Architecture: Principles, Design, and Practices

This article explores the fundamentals of software architecture, discussing entropy, the dual value of behavior and structure, core design principles such as SOLID, DRY, layering, orthogonality, component coupling, boundary definition, communication patterns, and modeling tools, while also offering practical guidance for building maintainable systems.

DRYDesign PrinciplesSOLID
0 likes · 18 min read
Understanding Software Architecture: Principles, Design, and Practices
21CTO
21CTO
Dec 31, 2023 · Backend Development

Why Prime Video Dropped Microservices for a Monolith and Cut Costs 90%

Prime Video’s engineers detail how abandoning a costly micro‑service and serverless setup for a streamlined monolithic architecture on EC2/ECS cut infrastructure expenses by over 90 % while boosting scalability, challenging the prevailing cloud‑native hype.

AWSSoftware Architecturecloud cost optimization
0 likes · 6 min read
Why Prime Video Dropped Microservices for a Monolith and Cut Costs 90%
JD Cloud Developers
JD Cloud Developers
Dec 26, 2023 · Fundamentals

Unlock DDD: Practical Hexagonal Architecture and Repository Patterns

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

Anemic ModelDDDDomain-Driven Design
0 likes · 23 min read
Unlock DDD: Practical Hexagonal Architecture and Repository Patterns
Liangxu Linux
Liangxu Linux
Dec 21, 2023 · Fundamentals

Why Global Variables Kill Embedded C Projects—and How to Tame Them

The article warns that overusing global variables in os‑less embedded C projects creates tangled code, blurs system layers, and leads to maintenance nightmares, then offers two core principles and practical tips to limit, encapsulate, and manage globals for more reliable firmware.

Embedded CSoftware Architecturebest practices
0 likes · 7 min read
Why Global Variables Kill Embedded C Projects—and How to Tame Them
Tencent Cloud Developer
Tencent Cloud Developer
Dec 21, 2023 · Fundamentals

Software Architecture Design: Principles, Complexity, and Best Practices

The article explains that good software architecture must be deliberately designed and continuously refactored to combat entropy and the broken‑window effect, balancing behavior and architecture value while managing complexity through principles like Ockham’s razor, orthogonality, DRY, stable dependencies, layered abstractions, and clear boundaries, supported by UML visualizations.

ComplexityDRYDesign Principles
0 likes · 19 min read
Software Architecture Design: Principles, Complexity, and Best Practices
Code Ape Tech Column
Code Ape Tech Column
Dec 21, 2023 · Fundamentals

Fundamentals of Software Modeling and Design Documentation

This article introduces the fundamentals of software modeling and design documentation, explaining how UML diagrams such as class, sequence, component, deployment, use‑case, state and activity charts are used across requirement analysis, conceptual design, and detailed design phases to create clear architectural blueprints.

Software ArchitectureUMLdesign documentation
0 likes · 16 min read
Fundamentals of Software Modeling and Design Documentation
Java High-Performance Architecture
Java High-Performance Architecture
Dec 16, 2023 · Backend Development

Master System Design: Key Concepts, Best Practices, and Real‑World Resources

This article introduces the open‑source system‑design‑101 repository, explaining why learning system design matters, and walks through essential topics such as API performance, the CAP theorem, caching strategies, microservice best practices, and secure password storage, with links to video courses and the project’s GitHub address.

API performanceSoftware ArchitectureSystem Design
0 likes · 5 min read
Master System Design: Key Concepts, Best Practices, and Real‑World Resources
21CTO
21CTO
Dec 15, 2023 · Backend Development

9 Essential Microservices Best Practices to Build Scalable, Secure Systems

This article outlines nine practical microservices best practices—from applying the Single Responsibility Principle and forming cross‑functional teams to using proper DevSecOps tools, asynchronous communication, independent data stores, and robust monitoring—to help developers design scalable, maintainable, and secure backend architectures.

DevOpsSoftware Architecturebackend
0 likes · 12 min read
9 Essential Microservices Best Practices to Build Scalable, Secure Systems
dbaplus Community
dbaplus Community
Dec 13, 2023 · Fundamentals

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

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

Domain-Driven DesignLoggingMonitoring
0 likes · 27 min read
How to Design Scalable, Maintainable Software Architecture: From Principles to Practice
Architecture and Beyond
Architecture and Beyond
Dec 2, 2023 · Operations

Four Dimensions of System Complexity: Component, Structure, Function, and Description

The article examines recent large‑scale service outages to illustrate how system complexity can be analyzed through four dimensions—component, structural, functional, and descriptive complexity—highlighting the need for comprehensive assessment to improve resilience and sustainable development.

Complexity AnalysisReliabilitySoftware Architecture
0 likes · 11 min read
Four Dimensions of System Complexity: Component, Structure, Function, and Description
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 22, 2023 · Fundamentals

Understanding the Five Creational Design Patterns

This article provides a comprehensive overview of the five creational design patterns—Singleton, Abstract Factory, Factory Method, Builder, and Prototype—explaining their concepts, UML structures, implementation details, typical use cases, advantages, disadvantages, and includes Java code examples and diagrams.

Creational PatternsDesign PatternsJava
0 likes · 9 min read
Understanding the Five Creational Design Patterns
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 17, 2023 · Fundamentals

Factory Method Pattern: Definition, Structure, Implementation, Advantages, and Use Cases

This article explains the Factory Method design pattern, covering its definition, UML diagram, key participants, the problems it solves compared to the Simple Factory, step‑by‑step Java implementation with code examples, advantages, disadvantages, application scenarios, and differences from the Simple Factory pattern.

Design PatternsFactory MethodJava
0 likes · 8 min read
Factory Method Pattern: Definition, Structure, Implementation, Advantages, and Use Cases
政采云技术
政采云技术
Nov 16, 2023 · Fundamentals

Comprehensive Guide to Software Architecture Design and Practices

This article provides an extensive overview of software architecture, covering its definition, history, core concepts, design principles, complexity sources, design process, performance, high availability, scalability, and practical implementation techniques for large‑scale web systems.

Design PrinciplesSoftware Architecturehigh availability
0 likes · 24 min read
Comprehensive Guide to Software Architecture Design and Practices
DevOps
DevOps
Nov 12, 2023 · Fundamentals

Software Engineer Self‑Improvement: Principles for Code Review, Testing, and Architecture

This article extends the ideas from "13 Years of Coding at Tencent" by presenting a comprehensive set of engineering self‑cultivation principles—including bias, entropy control, test‑driven design, early and automated testing, unified terminology, domain‑driven design, framework decoupling, and disciplined code encapsulation—to help developers write higher‑quality, maintainable code.

DevOpsSoftware Architecturebest practices
0 likes · 23 min read
Software Engineer Self‑Improvement: Principles for Code Review, Testing, and Architecture
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 7, 2023 · Frontend Development

How to Turn Technical Debt into Growth: Refactoring Lessons from Alibaba Cloud

This article shares a developer’s three‑year journey on Alibaba Cloud’s platform, exploring the nature of technical debt, categorizing its causes, and illustrating how micro‑refactorings and configuration‑driven upgrades can steadily improve code quality, accelerate feature delivery, and align engineering with business goals.

ConfigurationRefactoringSoftware Architecture
0 likes · 10 min read
How to Turn Technical Debt into Growth: Refactoring Lessons from Alibaba Cloud
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 6, 2023 · Fundamentals

Seven Fundamental Design Principles Behind Design Patterns

This article provides a comprehensive overview of design patterns by first explaining the seven core design principles—Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion, and others—detailing their definitions, benefits, UML diagrams, practical examples, and offering a downloadable PDF for deeper study.

Design PatternsSOLIDSoftware Architecture
0 likes · 12 min read
Seven Fundamental Design Principles Behind Design Patterns
DaTaobao Tech
DaTaobao Tech
Nov 3, 2023 · Fundamentals

Mastering the Strategy Pattern: From Simple IF‑ELSE to Scalable Design

This article explains why hard‑coded if‑else logic hinders extensibility, introduces the Strategy pattern, shows its structure and Java implementation for data synchronization, then enhances the design with a Factory to decouple object creation, concluding with best‑practice recommendations.

Design PatternsFactory PatternJava
0 likes · 8 min read
Mastering the Strategy Pattern: From Simple IF‑ELSE to Scalable Design
Top Architect
Top Architect
Nov 2, 2023 · Fundamentals

Designing Effective Software Architecture Diagrams: Concepts, Types, and Best Practices

This article explains the fundamental concepts of software architecture, the purpose and classification of architecture diagrams, criteria for good diagrams, and introduces the C4 modeling approach with practical examples to help engineers create clear, self‑describing visualizations for various audiences.

C4 modelSoftware ArchitectureSystem Design
0 likes · 13 min read
Designing Effective Software Architecture Diagrams: Concepts, Types, and Best Practices
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Nov 2, 2023 · Fundamentals

Understanding the Proxy Design Pattern with Java Examples

This article explains the Proxy design pattern, illustrates its core participants with clear Chinese idiom analogies, and provides a complete static‑proxy implementation in Java—including interface, real subject, proxy class, and client code—while also noting the distinction between static and dynamic proxies.

Design PatternsJavaProxy Pattern
0 likes · 6 min read
Understanding the Proxy Design Pattern with Java Examples
DaTaobao Tech
DaTaobao Tech
Nov 1, 2023 · Fundamentals

Understanding the Chain of Responsibility Design Pattern

The Chain of Responsibility pattern links a series of handler objects so that a request can be passed along until one processes it, decoupling sender and receiver, supporting dynamic composition, runtime flexibility, and the Open/Closed principle, as illustrated by a Java leave‑approval workflow.

Chain of ResponsibilityCode ExampleDesign Pattern
0 likes · 12 min read
Understanding the Chain of Responsibility Design Pattern
Test Development Learning Exchange
Test Development Learning Exchange
Oct 29, 2023 · Fundamentals

Common Design Patterns in Python

This article lists and briefly explains fifteen common Python design patterns, including Singleton, Factory, Abstract Factory, Builder, Prototype, Adapter, Decorator, Proxy, Observer, Strategy, Template Method, Iterator, Chain of Responsibility, Command, and State, helping developers understand their purposes and usage.

Design PatternsPythonSoftware Architecture
0 likes · 4 min read
Common Design Patterns in Python
Architect
Architect
Oct 27, 2023 · Fundamentals

Can Clean Architecture Transform Your Codebase? A Deep Dive into Design

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.

Clean ArchitectureDDDDomain-Driven Design
0 likes · 21 min read
Can Clean Architecture Transform Your Codebase? A Deep Dive into Design
Bilibili Tech
Bilibili Tech
Oct 27, 2023 · Game Development

Optimizing Global Game Publishing Efficiency with ONE SDK/API: Architecture, Metrics, and Practices

Bilibili’s ONE SDK/API unifies 22 fragmented game SDK variants across brands, regions, and devices into a single, adapter‑based package with centralized parameter management and automated multi‑channel builds, slashing global integration time from 60 to 15 days, cutting parameter awareness by 90 % and duplicate development effort by at least 75 %.

SDKSoftware Architectureefficiency
0 likes · 30 min read
Optimizing Global Game Publishing Efficiency with ONE SDK/API: Architecture, Metrics, and Practices
Test Development Learning Exchange
Test Development Learning Exchange
Oct 25, 2023 · Fundamentals

Understanding the Command Pattern with Python Examples

This article explains the Command design pattern, describes its key participants and advantages, and provides five Python examples demonstrating command encapsulation, undo/redo functionality, file operations, shopping‑cart management, and menu handling to illustrate how the pattern decouples request senders from receivers.

Command PatternDecouplingDesign Patterns
0 likes · 9 min read
Understanding the Command Pattern with Python Examples
Java Architect Essentials
Java Architect Essentials
Oct 23, 2023 · Backend Development

Design Patterns Employed in the MyBatis Framework

This article analyzes the MyBatis source code, illustrating how it applies a variety of design patterns—including Factory, Singleton, Builder, Adapter, Proxy, Composite, Decorator, Template, Strategy, and Iterator—to solve complex architectural challenges and improve modularity, extensibility, and maintainability.

Design PatternsFactory PatternJava
0 likes · 8 min read
Design Patterns Employed in the MyBatis Framework
Test Development Learning Exchange
Test Development Learning Exchange
Oct 22, 2023 · Fundamentals

Master 10 Essential Python Design Patterns with Ready-to-Run Code

This article introduces ten classic software design patterns—Singleton, Factory, Observer, Strategy, Adapter, Builder, Prototype, Decorator, Template Method, and Facade—explaining their purpose, structure, and providing complete Python code examples that demonstrate how to implement and apply each pattern in real projects.

CreationalDesign PatternsSoftware Architecture
0 likes · 9 min read
Master 10 Essential Python Design Patterns with Ready-to-Run Code
DaTaobao Tech
DaTaobao Tech
Oct 20, 2023 · Backend Development

DDD Principles Overview and Lecture Series

This article provides direct links to a comprehensive DDD lecture series covering domain primitives, architectural fundamentals, the repository pattern, and best practices for designing a robust domain‑driven design in their projects, offering developers practical examples and essential guidance for implementing effective domain‑driven design.

DDDSoftware Architecturebackend development
0 likes · 1 min read
DDD Principles Overview and Lecture Series
MaGe Linux Operations
MaGe Linux Operations
Oct 18, 2023 · Fundamentals

Mastering Software Architecture Diagrams: From 4+1 to C4 Views

This article explains the purpose and definition of system architecture, outlines the differences between business, application, technical, and data architectures, and introduces the 4+1 and C4 diagram models with practical guidance on creating clear, audience‑focused architectural drawings.

4+1 viewC4 modelSoftware Architecture
0 likes · 9 min read
Mastering Software Architecture Diagrams: From 4+1 to C4 Views
Architecture Digest
Architecture Digest
Oct 18, 2023 · Fundamentals

How to Create Clear System Architecture Diagrams: 4+1 and C4 Views

This article explains the purpose and classification of system architecture diagrams, introduces the 4+1 and C4 view models, and provides practical guidance on drawing effective, audience‑focused diagrams that are self‑descriptive, consistent, and aligned with code.

4+1 viewArchitecture DiagramC4 model
0 likes · 10 min read
How to Create Clear System Architecture Diagrams: 4+1 and C4 Views
Continuous Delivery 2.0
Continuous Delivery 2.0
Oct 17, 2023 · Fundamentals

Software Engineering Principles: Code Review, Entropy Control, Test Design, and Architectural Practices

This article presents a comprehensive set of software engineering principles—including obsessive code detail, entropy control, test‑driven design, domain‑driven modeling, and disciplined coding habits—to improve code quality, maintainability, and team collaboration across development projects.

DDDSoftware Architecturesoftware testing
0 likes · 21 min read
Software Engineering Principles: Code Review, Entropy Control, Test Design, and Architectural Practices
Tencent Cloud Developer
Tencent Cloud Developer
Oct 16, 2023 · Fundamentals

Software Engineering Principles: Code Review, Testing, and Architecture

The article expands on prior reflections by urging engineers to adopt a paranoid, entropy‑controlling mindset, design for testability, apply domain‑driven design, keep frameworks peripheral, enforce purposeful encapsulation and explicitness, and treat code as a craft, inviting community discussion.

DDDSoftware Architecturecode review
0 likes · 22 min read
Software Engineering Principles: Code Review, Testing, and Architecture
JD Tech
JD Tech
Oct 11, 2023 · Fundamentals

Key Considerations for Building System Engineering Architecture: Design, Technology Selection, and Consensus

This article comprehensively discusses the essential aspects of constructing a system engineering architecture, emphasizing value‑first decision making, layered and DDD architectural patterns, technology selection criteria, exception handling, logging, monitoring, and the importance of establishing shared consensus among teams.

DDDLoggingMonitoring
0 likes · 26 min read
Key Considerations for Building System Engineering Architecture: Design, Technology Selection, and Consensus
JD Cloud Developers
JD Cloud Developers
Sep 26, 2023 · Backend Development

How Rich Models Supercharge DDD Entity Design and Boost Maintainability

Rich (or active) models embed behavior and aggregation relationships directly within DDD entities, contrasting with anemic models; this approach clarifies business logic, reduces glue code, and improves readability, though it can cause entity bloat, prompting strategies like external service classes, utility helpers, and careful injection handling.

DDDEntity DesignRich Model
0 likes · 6 min read
How Rich Models Supercharge DDD Entity Design and Boost Maintainability
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Sep 26, 2023 · Fundamentals

Understanding the Strategy Pattern in JavaScript

This article explains the Strategy design pattern, demonstrates its implementation in JavaScript through three code versions, discusses the drawbacks of naïve if‑else approaches, and outlines the pattern's advantages and disadvantages for creating flexible, maintainable code.

Design PatternsJavaScriptRefactoring
0 likes · 6 min read
Understanding the Strategy Pattern in JavaScript
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 20, 2023 · Fundamentals

Observer Design Pattern in Java: Concepts, UML, and Full Code Example

This article explains the Observer behavioral design pattern, describes its participants, illustrates a real‑world e‑commerce scenario, and provides complete Java code for the observer interface, subject interface, concrete subject, concrete observers, and a test client, concluding with the pattern’s benefits.

Design PatternsJavaObserver Pattern
0 likes · 7 min read
Observer Design Pattern in Java: Concepts, UML, and Full Code Example
Amap Tech
Amap Tech
Sep 15, 2023 · R&D Management

Understanding Architecture: Goals, Resources, Behaviors, and Decision‑Making for Architects

The article broadens software architecture beyond structural design to encompass people, processes, and business value, urging architects to balance realistic, flexible goals, limited resources, commercial‑focused behaviors, and industry trends so they can deliver cost‑effective, scalable solutions that align technology with organizational objectives.

Business ValueSoftware Architecturedecision making
0 likes · 18 min read
Understanding Architecture: Goals, Resources, Behaviors, and Decision‑Making for Architects
Senior Brother's Insights
Senior Brother's Insights
Aug 30, 2023 · Backend Development

Why Learning Multiple Programming Languages Boosts Your Backend Skills

The author reflects on how studying several programming languages—Java, Go, and Python—mirrors learning foreign tongues, revealing that cross‑language comparison sharpens understanding of data structures, HTTP fundamentals, and framework implementations, ultimately deepening overall software development expertise.

GoJavaProgramming Languages
0 likes · 5 min read
Why Learning Multiple Programming Languages Boosts Your Backend Skills
JD Retail Technology
JD Retail Technology
Aug 25, 2023 · Fundamentals

From Traditional Layered Architecture to Hexagonal and Clean Architecture: Principles, Problems, and Dependency Inversion

This article explains the traditional strict and loose layered architectures, highlights their coupling issues, introduces the Dependency Inversion Principle as a solution, and shows how applying it leads to hexagonal and clean architecture designs with illustrative diagrams and code examples.

DDDDependency InversionSoftware Architecture
0 likes · 7 min read
From Traditional Layered Architecture to Hexagonal and Clean Architecture: Principles, Problems, and Dependency Inversion
Wukong Talks Architecture
Wukong Talks Architecture
Aug 25, 2023 · Cloud Native

Cloud-Native Architecture Evolution and Practices at ZEEK Automotive

This article details ZEEK Automotive's transition to a cloud‑native architecture, describing how the company adopted Kubernetes, containerization, micro‑service unification, and full‑link gray release to improve system stability, scalability, and development efficiency across its APP ecosystem.

AutomotiveDevOpsKubernetes
0 likes · 18 min read
Cloud-Native Architecture Evolution and Practices at ZEEK Automotive
JD Tech
JD Tech
Aug 24, 2023 · Fundamentals

Why Architecture Visualization Matters and How to Apply the C4 Model

This article explains the importance of architecture visualization for clear communication, compares wireframe, UML, and sketch approaches, and details how the C4 model’s layered abstractions—system, container, component, and code—provide a low‑cognitive‑load, consistent way to document software systems.

C4 modelSoftware ArchitectureUML
0 likes · 14 min read
Why Architecture Visualization Matters and How to Apply the C4 Model
Top Architecture Tech Stack
Top Architecture Tech Stack
Aug 19, 2023 · Fundamentals

The Seven SOLID Principles in Java Software Design

This article explains the seven SOLID principles of Java software design—Single Responsibility, Open‑Closed, Liskov Substitution, Interface Segregation, Dependency Inversion, Law of Demeter, and Composite Reuse—illustrating each with clear Java code examples that demonstrate how to write more maintainable, extensible, and flexible object‑oriented code.

JavaObject-OrientedSOLID
0 likes · 18 min read
The Seven SOLID Principles in Java Software Design
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Aug 18, 2023 · Fundamentals

Understanding the Strategy Design Pattern with Java Examples

This article explains the Strategy design pattern, its definition, structure, and how to refactor a typical e‑commerce discount calculation in Java using interfaces, concrete strategy classes, and a context, highlighting benefits, drawbacks, and best‑practice considerations.

Design PatternsJavaSoftware Architecture
0 likes · 9 min read
Understanding the Strategy Design Pattern with Java Examples
MaGe Linux Operations
MaGe Linux Operations
Aug 16, 2023 · Fundamentals

How Layered Architecture Keeps a 30K‑File Python Codebase Manageable

This article explains how a massive Python project with nearly 30,000 files uses a layered architecture and Import Linter to enforce dependency rules, reduce complexity, track technical debt, and improve maintainability, while also discussing the trade‑offs and practical implementation details.

Code OrganizationPythonSoftware Architecture
0 likes · 15 min read
How Layered Architecture Keeps a 30K‑File Python Codebase Manageable
Java Backend Technology
Java Backend Technology
Aug 16, 2023 · Fundamentals

Why Overusing the Chain of Responsibility Bloats Your Code—and How to Refactor It

This article explains the Chain of Responsibility design pattern, shows its typical use cases, demonstrates how naïve implementations can lead to tangled, hard‑to‑maintain code, and provides step‑by‑step refactorings—including abstract handlers, linked chains, and a factory‑based configuration—to produce clean, extensible Java solutions.

Chain of ResponsibilityJavaSoftware Architecture
0 likes · 13 min read
Why Overusing the Chain of Responsibility Bloats Your Code—and How to Refactor It
Tech Architecture Stories
Tech Architecture Stories
Aug 15, 2023 · Cloud Native

Why ‘Microservice Design’ and ‘Systems Thinking’ Are Essential Reads for Architects

The author revisits two concise yet powerful books—‘Microservice Design’ and ‘Systems Thinking’—explaining how the former guides architects through microservice boundaries, deployment, and scaling, while the latter offers a systematic mindset for designing and governing complex software systems, making both indispensable for modern architects.

Design PrinciplesSoftware ArchitectureSystems Thinking
0 likes · 5 min read
Why ‘Microservice Design’ and ‘Systems Thinking’ Are Essential Reads for Architects
Architect
Architect
Aug 12, 2023 · Backend Development

Understanding Code Architecture: Clean, Hexagonal, Onion, COLA and a Go Implementation Guide

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
Understanding Code Architecture: Clean, Hexagonal, Onion, COLA and a Go Implementation Guide
DaTaobao Tech
DaTaobao Tech
Aug 9, 2023 · Fundamentals

Understanding Domain-Driven Design: Principles, Challenges, and Practical Insights

The article likens blind adoption of Domain‑Driven Design to Forrest Gump’s run, explains how tangled business logic and over‑abstracted layers increase maintenance, shows DDD’s role in clarifying domains and mapping SOLID principles, offers practical tips for splitting responsibilities and building reusable capabilities, and concludes DDD is a valuable—not magical—lens for sustainable, extensible software.

DDDDesign PrinciplesSoftware Architecture
0 likes · 21 min read
Understanding Domain-Driven Design: Principles, Challenges, and Practical Insights
Tech Architecture Stories
Tech Architecture Stories
Aug 8, 2023 · Fundamentals

How Systems Theory Shapes Modern Software Architecture

Systems Theory, originating in the 1940s, provides a holistic framework for understanding and designing complex software architectures, emphasizing component interaction, feedback, and adaptability, with practical examples ranging from microservices and Kubernetes to chaos engineering, illustrating its impact on scalability, resilience, and modular design.

Design PrinciplesSoftware Architecturecloud-native
0 likes · 16 min read
How Systems Theory Shapes Modern Software Architecture
Architect
Architect
Aug 6, 2023 · Backend Development

From N‑Layered to Clean Architecture: Tracing the Evolution of Backend Design

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.

Clean ArchitectureDDDN‑layered
0 likes · 17 min read
From N‑Layered to Clean Architecture: Tracing the Evolution of Backend Design
Architect
Architect
Aug 4, 2023 · Fundamentals

What Exactly Is Software Architecture? A Deep Dive into Systems, Modules, and Design Principles

The article systematically defines software architecture, distinguishes systems, subsystems, modules, and components, compares frameworks with architectures, explores TOGAF and RUP classifications, traces the evolution from monoliths to micro‑services, and presents concrete design principles and common pitfalls for building scalable, maintainable systems.

Design PrinciplesSoftware ArchitectureSystem Design
0 likes · 25 min read
What Exactly Is Software Architecture? A Deep Dive into Systems, Modules, and Design Principles
Tencent Cloud Developer
Tencent Cloud Developer
Aug 2, 2023 · Backend Development

How to Do Architecture Design Well: A Tencent Architect's Experience

A Tencent architect explains that effective software architecture requires clear distinctions between systems, subsystems, modules and components, understanding frameworks versus structural design, applying TOGAF classifications, evolving from monoliths to microservices, and following fifteen practical principles while avoiding common misconceptions such as over‑design and technology‑driven choices.

Software ArchitectureSystem DesignTOGAF
0 likes · 20 min read
How to Do Architecture Design Well: A Tencent Architect's Experience
JD Retail Technology
JD Retail Technology
Aug 2, 2023 · Backend Development

Key Principles and Practices for Engineering Architecture Design

This article explores engineering architecture design, emphasizing value‑first decision making, layered and DDD architectures, technology selection criteria, and best practices for consensus, exception, logging, and monitoring to build scalable, maintainable, and secure software systems.

DDDSoftware Architectureengineering design
0 likes · 23 min read
Key Principles and Practices for Engineering Architecture Design
Alibaba Terminal Technology
Alibaba Terminal Technology
Jul 27, 2023 · Artificial Intelligence

How LLMs Transform Industrial Configuration Software: Architecture & Use Cases

This article explains how integrating large language models into industrial configuration tools creates AI‑driven features such as knowledge Q&A, automatic application generation, smart drawing, script and material generation, and outlines the three‑layer architecture, prompt engineering, and implementation lessons for developers.

AI integrationLLMPrompt Engineering
0 likes · 30 min read
How LLMs Transform Industrial Configuration Software: Architecture & Use Cases
Alibaba Cloud Developer
Alibaba Cloud Developer
Jul 27, 2023 · Backend Development

How Gaode’s GBF Framework Eliminates Glue Code with Domain‑Driven Design

This article explains how Gaode's Information Business team tackled fragmented portal implementations across multiple industries by adopting the Gaode Business Framework (GBF) and domain‑driven design, achieving unified architecture, reduced duplication, improved reusability, and enhanced system stability and maintainability.

Domain-Driven DesignSoftware Architecturebackend
0 likes · 17 min read
How Gaode’s GBF Framework Eliminates Glue Code with Domain‑Driven Design
21CTO
21CTO
Jul 19, 2023 · Operations

Scaling a Fast‑Growing Supply Chain Platform: Architecture and Ops Insights

This article details how a rapidly expanding B2B fresh‑food company restructured its R&D organization, adopted a matrix management model, and built a comprehensive distributed infrastructure—including task scheduling, service discovery, messaging, logging, file storage, CDN, configuration, sharding, search, caching, and monitoring—to support nationwide warehouse operations and future growth.

DevOpsSoftware Architecturebackend development
0 likes · 7 min read
Scaling a Fast‑Growing Supply Chain Platform: Architecture and Ops Insights
DaTaobao Tech
DaTaobao Tech
Jul 17, 2023 · Fundamentals

Comprehensive Overview of 23 Design Patterns with Examples and Code

This article provides a systematic, example‑driven guide to all 23 classic design patterns—covering creational, structural, and behavioral types—explaining their intent, real‑world analogies, benefits, and offering clear diagrams and runnable code snippets to illustrate each pattern in practice.

BehavioralCreationalDesign Patterns
0 likes · 40 min read
Comprehensive Overview of 23 Design Patterns with Examples and Code
ITPUB
ITPUB
Jul 14, 2023 · R&D Management

Why Becoming an Architect Is Really About Upgrading Your Cognition

The article shares the author’s years of architecture experience at Alipay, arguing that growth into a true architect is a cognitive upgrade, explains what architectural ability really means, illustrates it with a multithreading interview example, and presents systematic thinking methods and practical steps for building architectural competence.

R&D managementSoftware ArchitectureSystem Design
0 likes · 26 min read
Why Becoming an Architect Is Really About Upgrading Your Cognition
Ctrip Technology
Ctrip Technology
Jul 13, 2023 · Backend Development

Refactoring Practices and Strategies for Large‑Scale Microservice Systems

This article outlines the definition, motivations, impact levels, planning, communication, layered design, gray‑release techniques, quality improvement measures, and observability considerations for large‑scale backend refactoring in microservice architectures, drawing on practical experience from Ctrip's end‑to‑end refactoring project.

RefactoringSoftware Architecturecode quality
0 likes · 11 min read
Refactoring Practices and Strategies for Large‑Scale Microservice Systems
Test Development Learning Exchange
Test Development Learning Exchange
Jul 7, 2023 · Fundamentals

Understanding the Object Factory Design Pattern with Python Examples

This article explains the Object Factory design pattern, its benefits such as decoupling, extensibility, and centralized instance management, and demonstrates five practical Python examples covering basic product creation, configuration‑driven factories, logger factories, singleton factories, and object caching factories.

Design PatternFactory MethodObject Factory
0 likes · 7 min read
Understanding the Object Factory Design Pattern with Python Examples
macrozheng
macrozheng
Jul 5, 2023 · Backend Development

Mastering Domain-Driven Design: From Concepts to Clean Architecture

This article explains how to apply Domain‑Driven Design (DDD) to a new project, covering key terminology, architectural evolution, bounded contexts, the four DDD boundaries, and various layered architectures such as clean, hexagonal, and onion models.

DDDOnion ArchitectureSoftware Architecture
0 likes · 9 min read
Mastering Domain-Driven Design: From Concepts to Clean Architecture
Su San Talks Tech
Su San Talks Tech
Jul 2, 2023 · Fundamentals

Master Design Patterns: Chain, Template, Pub/Sub & Strategy in Java

This article explains the concepts, advantages, disadvantages, and real-world use cases of four essential design patterns—Chain of Responsibility, Template Method, Publish‑Subscribe, and Strategy—providing detailed Java and Spring code examples to help developers apply them effectively.

Design PatternsJavaSoftware Architecture
0 likes · 41 min read
Master Design Patterns: Chain, Template, Pub/Sub & Strategy in Java
Java Architect Essentials
Java Architect Essentials
Jun 29, 2023 · Fundamentals

Understanding Domain-Driven Design: Boundaries, Contexts, and Architectural Patterns

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.

Clean ArchitectureDomain-Driven DesignSoftware Architecture
0 likes · 9 min read
Understanding Domain-Driven Design: Boundaries, Contexts, and Architectural Patterns
21CTO
21CTO
Jun 28, 2023 · Fundamentals

What Is Software Architecture? Definitions, Types, and Design Principles Explained

This comprehensive guide clarifies the concept of software architecture, explores related notions such as systems, subsystems, modules, components, frameworks, and various architectural classifications, and outlines design goals, evolution paths, common pitfalls, and recommended reading for building effective, scalable, and maintainable systems.

Software ArchitectureSystem Designarchitecture patterns
0 likes · 35 min read
What Is Software Architecture? Definitions, Types, and Design Principles Explained
ByteFE
ByteFE
Jun 28, 2023 · Frontend Development

How GPT is Transforming Frontend Development and UI Interaction

The article examines the rapid rise of GPT models, their technical capabilities and limitations, and how their integration is reshaping software interaction from command‑line to GUI‑plus‑Language UI, offering frontend engineers new opportunities, practical examples, and guidance on leveraging large‑model AI in product design.

AI integrationGPTLLM
0 likes · 21 min read
How GPT is Transforming Frontend Development and UI Interaction
21CTO
21CTO
Jun 20, 2023 · R&D Management

When Architects Turn Into PMs: Risks and How to Stop It

This article explains what architect‑to‑PM transformation means, outlines its characteristic signs and harmful impacts on projects, organizations, and individuals, and offers practical organizational, personal, and cultural measures—including automation pipelines—to keep architects focused on real technical work.

R&D managementSoftware Architectureteam culture
0 likes · 7 min read
When Architects Turn Into PMs: Risks and How to Stop It
JD Tech
JD Tech
Jun 20, 2023 · Fundamentals

Design Patterns, Architectural Patterns, and Programming Paradigms: Theory, Examples, and Practical Guidance

This article analyses the relationship between design patterns, architectural patterns and programming paradigms, explains core concepts and principles, provides extensive examples in Java and Python, presents common pattern catalogs, and offers practical implementation guidelines and case studies for software developers.

Object-OrientedProgramming ParadigmsSoftware Architecture
0 likes · 28 min read
Design Patterns, Architectural Patterns, and Programming Paradigms: Theory, Examples, and Practical Guidance