BestHub
Sign in
Tagged articles

Software Architecture

1352 articles · Page 8 of 14
Architects' Tech Alliance
Architects' Tech Alliance
May 29, 2022 · Fundamentals

Understanding Software Architecture: History, Concepts, and Definitions

This article explores the evolution of software development from machine code to high‑level languages, explains the two software crises and their solutions, defines system, subsystem, module, component, framework and architecture, and concludes that software architecture is a strategic response to system complexity requiring careful judgment and trade‑offs.

Object-Oriented ProgrammingSoftware Architectureprogramming languages
0 likes · 12 min read
Understanding Software Architecture: History, Concepts, and Definitions
IT Architects Alliance
IT Architects Alliance
May 28, 2022 · Backend Development

Eight Common Software Architecture Design Patterns and Their Pros and Cons

This article introduces eight typical software architecture design patterns—including single-database single-application, content distribution, query separation, microservices, multi-level caching, sharding, elastic scaling, and multi-datacenter deployment—explaining their structures, typical use cases, advantages, disadvantages, and practical considerations for building scalable, reliable systems.

BackendDesign PatternsSoftware Architecture
0 likes · 21 min read
Eight Common Software Architecture Design Patterns and Their Pros and Cons
Architect
Architect
May 26, 2022 · Backend Development

Eight Common Software Architecture Design Patterns and Their Pros and Cons

This article explains eight widely used software architecture design patterns—including single‑database single‑application, content distribution, query separation, microservices, multi‑level caching, database sharding, elastic scaling, and multi‑data‑center—detailing their typical scenarios, advantages, and disadvantages for backend developers.

Software Architecturebackend developmentmicroservices
0 likes · 20 min read
Eight Common Software Architecture Design Patterns and Their Pros and Cons
Top Architect
Top Architect
May 26, 2022 · Backend Development

Eight Common Software Architecture Design Patterns and Their Advantages & Disadvantages

The article introduces eight widely used software architecture design patterns—including single‑database, content distribution, query separation, microservices, multi‑level caching, sharding, elastic scaling, and multi‑datacenter deployment—explaining their typical structures, suitable scenarios, and the key pros and cons of each.

BackendCachingDesign Patterns
0 likes · 21 min read
Eight Common Software Architecture Design Patterns and Their Advantages & Disadvantages
Top Architect
Top Architect
May 26, 2022 · Backend Development

Designing API Return Codes and Messages: Best Practices for Backend Services

This article explains how to design clear, consistent API return codes and messages by referencing HTTP status codes, defining code‑message pairs, supporting personalized messages for different clients, and using unified handling for monitoring and alerting, ultimately improving communication and maintenance costs.

API DesignHTTP status codesMonitoring
0 likes · 6 min read
Designing API Return Codes and Messages: Best Practices for Backend Services
JavaEdge
JavaEdge
May 24, 2022 · Fundamentals

Why Inheritance Fails: Mastering the Decorator Pattern in Java

This article explains the Decorator design pattern, contrasting it with inheritance, and shows how to dynamically extend Java classes—especially I/O streams—using composition, complete with code examples, class diagrams, advantages, drawbacks, and practical usage scenarios.

CompositionDecorator PatternDesign Patterns
0 likes · 15 min read
Why Inheritance Fails: Mastering the Decorator Pattern in Java
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
May 21, 2022 · Fundamentals

What Makes a Great Software Architect? Insights from Meituan’s Logistics Lead

In this interview, Meituan Selection architect Xu Po shares his 14‑year journey, explains how logistics architecture balances process and result quality, outlines the four pillars for successful architecture implementation, discusses the core value of architects, team organization models, essential skills, and the role of domain‑driven design.

Domain-Driven DesignSoftware Architecturearchitect career
0 likes · 15 min read
What Makes a Great Software Architect? Insights from Meituan’s Logistics Lead
IT Architects Alliance
IT Architects Alliance
May 19, 2022 · Industry Insights

Why All Low‑Code Platforms Rely on Declarative Code: A Deep Technical Dive

The article analyses low‑code platforms by defining low‑code as visual programming, contrasting declarative and imperative approaches, examining front‑end and back‑end implementation schemes, interaction models, storage options, workflow engines, and future trends, ultimately showing that declarative foundations drive both strengths and limitations.

Software Architecturebackend developmentdeclarative programming
0 likes · 37 min read
Why All Low‑Code Platforms Rely on Declarative Code: A Deep Technical Dive
Baidu Geek Talk
Baidu Geek Talk
May 19, 2022 · Fundamentals

Singleton Design Pattern: Implementation and Practical Applications

The Singleton design pattern guarantees a single, globally accessible instance, reducing memory overhead and global variables, with eager (init) and lazy (sync.Once) thread‑safe implementations in Go, and practical uses such as configuration management in Python, shared DB connections in PHP, and UI components like toasts in JavaScript.

Design PatternsGo ProgrammingJavaScript Programming
0 likes · 16 min read
Singleton Design Pattern: Implementation and Practical Applications
NetEase Yanxuan Technology Product Team
NetEase Yanxuan Technology Product Team
May 18, 2022 · R&D Management

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

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

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

Strategic and Tactical Design Principles for Technical Architecture

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

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

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

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

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

Master 23 Classic Design Patterns with Real-World Analogies

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

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

Cross‑Platform Frontend Evolution and Low‑Code Flutter Implementation

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

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

30 Essential Architecture Principles Every Software Architect Should Follow

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

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

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

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

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

Application Layering Best Practices and Alibaba Specification

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

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

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

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

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

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

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

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

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

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

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

30 Architectural Principles for Software Engineers

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

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

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

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

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

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

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

Software ArchitectureTeam LeadershipTechnical Management
0 likes · 9 min read
Why Traditional Software Architects Fail and How Everyone Can Be an Architect
Top Architect
Top Architect
Apr 2, 2022 · Backend Development

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

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

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

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

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

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

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

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

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

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

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

Software Architecturebounded contextdomain modeling
0 likes · 9 min read
Understanding Domain-Driven Design: Core Concepts, Building Blocks, and Modeling Practices
Open Source Linux
Open Source Linux
Mar 22, 2022 · Fundamentals

30 Essential Architecture Principles Every Engineer Should Follow

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

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

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

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

Anemic ModelRich Domain ModelSoftware Architecture
0 likes · 18 min read
How to Tame Software Complexity: Entropy, Constructal Law, and Design Strategies
IT Architects Alliance
IT Architects Alliance
Mar 20, 2022 · Fundamentals

Overview of Architectural Thinking and Layered Architecture Models

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Understanding the 4+1 View Model of Software Architecture

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

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

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

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

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

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

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

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

30 Architectural Principles for Software Engineers

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

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

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

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

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

Understanding Technical Debt: Classification, Impact, and Mitigation Strategies

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

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

Differences Between Microservices and Monolithic Architecture

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

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

30 Software Architecture Principles for Effective System Design

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

Software Architecturedesign principlesdistributed systems
0 likes · 12 min read
30 Software Architecture Principles for Effective System Design
21CTO
21CTO
Mar 5, 2022 · Fundamentals

30 Essential Architecture Principles Every Engineer Should Follow

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

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

30 Architectural Principles for Software Architects

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

Software Architecturedesign principlessoftware engineering
0 likes · 12 min read
30 Architectural Principles for Software Architects
IT Architects Alliance
IT Architects Alliance
Mar 1, 2022 · Fundamentals

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

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

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

Comprehensive Overview of 23 Java Design Patterns

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

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

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

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

CQRSDesign PatternsDomain-Driven Design
0 likes · 22 min read
Why Clean Architecture, DDD, and CQRS Together Create Scalable, Testable Systems
Java Interview Crash Guide
Java Interview Crash Guide
Feb 22, 2022 · Backend Development

Ensuring API Idempotency: Prevent Duplicate Requests in Scalable Systems

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Mastering Software Architecture Diagrams: A Practical C4 Methodology

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

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

Master the Proxy Pattern with a Fun Story and Go Example

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

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

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

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

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

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

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

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

Designing Consistent API Return Codes: Lessons from HTTP Status Codes

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

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

Technical Architecture Design Principles: Strategy and Tactics for Backend Systems

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

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

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

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

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

A Complete 19‑Part Knowledge Map for Software Architects

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Mastering Software Architecture: Strategic & Tactical Design Principles

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

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

What Really Defines Software Architecture? Core Concepts and Layers Explained

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

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

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

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

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

Context Mapping Patterns in Domain-Driven Design

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

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

What Really Defines Software Architecture? Core Concepts and Layers Explained

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

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

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

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

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

Understanding Rule Engines: Concepts, Patterns, and Practical Applications

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

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

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

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

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

How to Standardize Business Architecture: A Layered Design Blueprint

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

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

Bridging the Language Gap in Domain‑Driven Design

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

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

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

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

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

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

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

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

Common Software Architecture Patterns and Their Characteristics

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

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

Understanding Software Architecture: From Basic Concepts to the COLA Framework

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

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

Mastering Domain-Driven Design: Key Principles and Practical Insights

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

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

Key Capabilities for Continuous Delivery and DevOps Performance

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

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

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

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

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

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

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

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

Understanding Software Architecture and the COLA Application Architecture

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

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

Mastering Software Architecture: From Basics to Evolution

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

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

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

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

Software Architecturearchitecture patternsmicroservices
0 likes · 21 min read
Understanding Software Architecture: Concepts, Layers, Levels, Evolution, and Common Pitfalls
Java Interview Crash Guide
Java Interview Crash Guide
Nov 16, 2021 · Fundamentals

Why the Anemic Domain Model Is a Design Pitfall and How the Rich Model Saves You

Anemic domain models separate data and behavior, leading to procedural code and maintenance challenges, while rich (or “充血”) models embed logic within objects, offering clearer OOP design, better encapsulation, and scalability, though they require careful design to avoid complexity.

Anemic ModelDomain-Driven DesignObject-Oriented Design
0 likes · 10 min read
Why the Anemic Domain Model Is a Design Pitfall and How the Rich Model Saves You
Architecture Digest
Architecture Digest
Nov 13, 2021 · Fundamentals

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

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

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

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

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

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

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

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

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

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

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

High ConcurrencySoftware Architecturedesign principles
0 likes · 15 min read
Technical Architecture Design Principles: Strategy, Tactics, and Practical Guidelines