BestHub
Sign in
Tagged articles
1187 articles
Page 8 of 12
IT Architects Alliance
IT Architects Alliance
Jun 30, 2021 · Fundamentals

Understanding Software Architecture: Systems, Subsystems, Modules, Components, Frameworks, and Architecture

This article explains the fundamental concepts of software architecture—including systems, subsystems, modules, components, frameworks, and architecture itself—by defining each term, illustrating their relationships with real‑world examples, and clarifying common misconceptions for technical professionals.

ComponentFrameworkSoftware Architecture
0 likes · 10 min read
Understanding Software Architecture: Systems, Subsystems, Modules, Components, Frameworks, and Architecture
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jun 30, 2021 · Fundamentals

Who Is Software Architecture Designed For? Exploring 4+1 Views and Documentation

This article examines the purpose of software architecture by identifying its diverse stakeholders, detailing the refinement process, illustrating the 4+1 view model with diagrams, outlining documentation practices, summarizing key takeaways, and previewing the next installment on deployment architecture.

4+1 viewSoftware ArchitectureSystem Design
0 likes · 4 min read
Who Is Software Architecture Designed For? Exploring 4+1 Views and Documentation
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 28, 2021 · Fundamentals

Why Architecture Diagrams Matter: Principles, Methods, and Tools for Effective Software Design

This article explains the essence of software architecture, its core elements, why clear diagrams are crucial for communication and quality, and presents practical principles, patterns like UML, 4+1, C4, arc42, and tools such as draw.io and PlantUML to help engineers create accurate, consistent, and maintainable architectural documentation.

C4 ModelDiagrammingDraw.io
0 likes · 34 min read
Why Architecture Diagrams Matter: Principles, Methods, and Tools for Effective Software Design
IT Architects Alliance
IT Architects Alliance
Jun 27, 2021 · Cloud Native

From Monolith to Microservices: A Complete Evolution Guide

This article traces the evolution of software architecture from monolithic applications through vertical splitting, distributed services, and SOA to modern microservices, and then details the essential technology stack—including service communication, API gateways, authentication, fault tolerance, logging, configuration, containers, orchestration, and CI/CD—required to build scalable, resilient cloud‑native systems.

Cloud NativeContainersKubernetes
0 likes · 19 min read
From Monolith to Microservices: A Complete Evolution Guide
IT Architects Alliance
IT Architects Alliance
Jun 27, 2021 · Fundamentals

Software Architecture Design and the 4+1 View Model Overview

This article explains software architecture concepts, the 4+1 view model, various architectural styles, the evolution of layered client‑server architectures, and the MVC/MVP patterns, providing a comprehensive overview of design principles and their practical implications.

4+1 viewMVCSoftware Architecture
0 likes · 16 min read
Software Architecture Design and the 4+1 View Model Overview
IT Architects Alliance
IT Architects Alliance
Jun 24, 2021 · Industry Insights

Why Is Domain-Driven Design Suddenly Trending? A Deep Dive into Its Rise

Domain-Driven Design (DDD) has surged in popularity as microservices dominate, and this article traces its historical background, explains the architectural shifts that created its need, outlines strategic and tactical design concepts, and provides a three‑step method for defining domain models and service boundaries.

Domain-Driven DesignMicroservicesSoftware Architecture
0 likes · 10 min read
Why Is Domain-Driven Design Suddenly Trending? A Deep Dive into Its Rise
IT Architects Alliance
IT Architects Alliance
Jun 23, 2021 · Fundamentals

10 Essential Software Architecture Patterns Every Enterprise Engineer Should Know

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

Architecture PatternsDesign PatternsSoftware Architecture
0 likes · 10 min read
10 Essential Software Architecture Patterns Every Enterprise Engineer Should Know
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 9, 2021 · Fundamentals

Chain of Responsibility Pattern – Concept, UML Diagram, Java Implementation, Pros, Cons, and Use Cases

This article explains the Chain of Responsibility design pattern, covering its concept, UML class diagram, Java code examples, advantages, disadvantages, typical application scenarios, extensions, and comparison with the Decorator pattern in software development.

Chain of ResponsibilityObject-OrientedSoftware Architecture
0 likes · 7 min read
Chain of Responsibility Pattern – Concept, UML Diagram, Java Implementation, Pros, Cons, and Use Cases
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 7, 2021 · Fundamentals

Why Domain Models Are the Secret Weapon for Stable, Scalable Software

This article explains the concept of domain models, why they are crucial business assets, how to create and use them with UML diagrams and simple examples, highlights common misconceptions, and shows how explicit modeling improves communication, code readability, and software adaptability.

DDDDomain ModelingSoftware Architecture
0 likes · 16 min read
Why Domain Models Are the Secret Weapon for Stable, Scalable Software
Java High-Performance Architecture
Java High-Performance Architecture
Jun 7, 2021 · Fundamentals

23 Essential Design Patterns Explained with Fun 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—by mapping each to everyday relationship scenarios.

AdapterBuilderDesign Patterns
0 likes · 18 min read
23 Essential Design Patterns Explained with Fun Real‑World Analogies
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 6, 2021 · Fundamentals

Understanding the Chain of Responsibility Design Pattern with Real‑World Stories and Java Implementations

This article explains the Chain of Responsibility design pattern by linking a historical story of Guan Yu’s five passes with an OA leave‑approval workflow, provides a clear definition, discusses its pros and cons, and presents comprehensive Java code examples illustrating abstract handlers, concrete handlers, and client usage.

Chain of ResponsibilityOO DesignSoftware Architecture
0 likes · 12 min read
Understanding the Chain of Responsibility Design Pattern with Real‑World Stories and Java Implementations
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jun 6, 2021 · Fundamentals

What Does a Complete Enterprise Technology Middle‑Platform Architecture Look Like?

An extensive diagram presents a panoramic view of an enterprise technology middle‑platform architecture, illustrating its layered components, data flow, service governance, capability services, and integration points, offering a comprehensive visual guide for architects and engineers designing scalable internal platforms.

Software ArchitectureSystem Designtechnology platform
0 likes · 1 min read
What Does a Complete Enterprise Technology Middle‑Platform Architecture Look Like?
IT Architects Alliance
IT Architects Alliance
May 29, 2021 · Industry Insights

Mastering System Scalability: How to Predict and Handle Change in Architecture

The article explains why scalability is crucial for software systems, outlines the difficulty of accurately predicting future changes, and presents two architectural approaches—layer separation and abstraction/implementation layers—illustrated with diagrams and design‑pattern examples to help architects manage complexity.

Design PatternsScalabilitySoftware Architecture
0 likes · 9 min read
Mastering System Scalability: How to Predict and Handle Change in Architecture
IT Architects Alliance
IT Architects Alliance
May 24, 2021 · R&D Management

What Is Software Architecture? Core Concepts, Types, and Best Practices

This article explains the essence of software architecture, outlines its main components, classifies various architecture layers such as business, application, code, and technical architecture, discusses evolution stages, measurement criteria, common pitfalls, and provides a comprehensive knowledge framework for architects.

R&D managementSoftware ArchitectureSystem Design
0 likes · 15 min read
What Is Software Architecture? Core Concepts, Types, and Best Practices
IT Architects Alliance
IT Architects Alliance
May 23, 2021 · Fundamentals

Understanding Software Architecture: History, Concepts, and Definitions

This article explains the evolution of software development from machine language to high‑level languages, describes the two software crises and the emergence of structured, object‑oriented, and component‑based design, and clarifies key architectural concepts such as systems, subsystems, modules, components, frameworks, and architecture itself.

ComponentSoftware ArchitectureSystem Design
0 likes · 11 min read
Understanding Software Architecture: History, Concepts, and Definitions
ITFLY8 Architecture Home
ITFLY8 Architecture Home
May 21, 2021 · Backend Development

When Should You Adopt CQRS? Balancing Read and Write Models for Scalable Systems

This article examines how evolving software requirements can lock systems into rigid data models, explains the Command Query Responsibility Segregation (CQRS) pattern, and outlines when CQRS is beneficial or detrimental, helping architects decide if separating read and write models will improve scalability and maintainability.

CQRSScalabilitySoftware Architecture
0 likes · 8 min read
When Should You Adopt CQRS? Balancing Read and Write Models for Scalable Systems
JD Retail Technology
JD Retail Technology
May 17, 2021 · Interview Experience

How a JD Architect Turns PaaS Challenges into Career Growth

In this interview, senior architect Li Zunjing shares his two‑stage journey at JD.com—from stabilizing e‑commerce systems to pioneering B‑PaaS—highlighting the importance of technical fundamentals, a "empty‑cup" mindset, collaborative execution, and self‑driven learning for engineering success.

Career DevelopmentJD.comPaaS
0 likes · 9 min read
How a JD Architect Turns PaaS Challenges into Career Growth
IT Architects Alliance
IT Architects Alliance
May 16, 2021 · Fundamentals

Why Domain-Driven Design Is the Key to Taming Complex Business Logic

Domain-Driven Design (DDD) offers a systematic approach to separate business complexity from technical concerns, using ubiquitous language, bounded contexts, layered and hexagonal architectures, CQRS, and strategic and tactical patterns, enabling teams to build flexible, scalable systems that quickly adapt to evolving requirements.

Bounded ContextCQRSDomain-Driven Design
0 likes · 41 min read
Why Domain-Driven Design Is the Key to Taming Complex Business Logic
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 16, 2021 · Fundamentals

Builder Design Pattern: Introduction, UML Diagram, Java Implementation, Use Cases, Advantages and Disadvantages

This article introduces the Builder design pattern, explains its role in separating object construction from representation, provides UML class diagrams and Java code examples, outlines typical application scenarios, and discusses its advantages and disadvantages.

Builder PatternDesign PatternsObject Creation
0 likes · 5 min read
Builder Design Pattern: Introduction, UML Diagram, Java Implementation, Use Cases, Advantages and Disadvantages
Top Architect
Top Architect
May 15, 2021 · Fundamentals

Overview of Software Architecture: Monolithic, Distributed, Microservices, and Serverless

This article introduces the concept of software architecture and compares four major styles—monolithic, distributed, microservices, and serverless—detailing their structures, advantages, disadvantages, and typical use cases, helping developers understand how architectural choices affect scalability, maintainability, and operational complexity.

DistributedScalabilityServerless
0 likes · 12 min read
Overview of Software Architecture: Monolithic, Distributed, Microservices, and Serverless
Programmer DD
Programmer DD
May 15, 2021 · Backend Development

How to Build a Flexible Rule Engine with Java: Design, Implementation, and Tips

This article walks through a real‑world scenario of extending trial‑user eligibility rules, explains the logical flow using AND/OR short‑circuiting, and presents a modular Java rule engine design with abstract templates, concrete rules, a service builder, and a test case, highlighting its advantages and drawbacks.

Code ExampleDesign PatternsSoftware Architecture
0 likes · 8 min read
How to Build a Flexible Rule Engine with Java: Design, Implementation, and Tips
Python Programming Learning Circle
Python Programming Learning Circle
May 10, 2021 · Backend Development

Functional Dependency Injection in Python: From Simple Thresholds to Contextual Composition

This article explores how to combine typed functional concepts with traditional object‑oriented dependency injection in Python, using a Django‑based word‑guessing game to illustrate naive parameter passing, its drawbacks, and a functional approach based on factories, transparent dependencies, and static typing.

Software ArchitectureType Safetydependency-injection
0 likes · 11 min read
Functional Dependency Injection in Python: From Simple Thresholds to Contextual Composition
Top Architect
Top Architect
May 10, 2021 · Fundamentals

Why UML Really Died: Historical Causes and What Replaced It

The article analyses the rise and fall of UML, tracing its origins in the 1990s, the impact of CASE tools, the shift toward agile development, and the technical and cultural reasons for its decline, while also exploring emerging lightweight modeling alternatives such as C4 and masala diagrams.

Agile DevelopmentCASE toolsSoftware Architecture
0 likes · 13 min read
Why UML Really Died: Historical Causes and What Replaced It
Top Architect
Top Architect
May 9, 2021 · Backend Development

Principles and Practices for Effective Code Review and Software Architecture

This article shares a senior backend engineer's insights on why code review is essential, common pitfalls that degrade code quality, and a set of concrete principles—ranging from simplicity and composition to transparency and error handling—to guide developers in writing maintainable, scalable Go code and robust system designs.

Code reviewEngineeringGolang
0 likes · 39 min read
Principles and Practices for Effective Code Review and Software Architecture
Intelligent Backend & Architecture
Intelligent Backend & Architecture
May 8, 2021 · Fundamentals

Mastering Behavioral Design Patterns: When and How to Use Them

This article provides a comprehensive overview of behavioral design patterns—including Chain of Responsibility, Command, Mediator, Memento, Observer, State, Strategy, Template Method, and Visitor—explaining their motivations, class diagrams, advantages, disadvantages, and typical scenarios for applying each pattern in software development.

Behavioral PatternsDesign PatternsObject-Oriented
0 likes · 20 min read
Mastering Behavioral Design Patterns: When and How to Use Them
Open Source Linux
Open Source Linux
May 8, 2021 · Fundamentals

Why Understanding Software Architecture Evolution Matters for Developers

This article outlines the evolution of software architecture—from monolithic to distributed, microservice, and serverless models—detailing each pattern’s structure, advantages, and drawbacks, helping developers understand how architectural choices impact scalability, maintenance, and innovation in modern software projects.

Distributed SystemsMicroservicesScalability
0 likes · 12 min read
Why Understanding Software Architecture Evolution Matters for Developers
Intelligent Backend & Architecture
Intelligent Backend & Architecture
May 7, 2021 · Fundamentals

Unlocking Behavioral Design Patterns: When and How to Use Them

This article explains behavioral design patterns—how they manage complex runtime interactions among classes or objects, outlines the eleven classic patterns with their motivations, class diagrams, advantages, disadvantages, and typical scenarios, and shows why object‑based patterns offer greater flexibility than class‑based ones.

Behavioral PatternsDesign PatternsObject-Oriented Design
0 likes · 22 min read
Unlocking Behavioral Design Patterns: When and How to Use Them
Python Programming Learning Circle
Python Programming Learning Circle
May 6, 2021 · Fundamentals

Understanding 23 Classic Design Patterns Through Everyday Analogies

This article explains twenty‑three classic software design patterns—including 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 humorous real‑world scenarios to illustrate their intent and structure.

Design PatternsObject-OrientedSoftware Architecture
0 likes · 17 min read
Understanding 23 Classic Design Patterns Through Everyday Analogies
Intelligent Backend & Architecture
Intelligent Backend & Architecture
Apr 30, 2021 · Fundamentals

Mastering Java Design Patterns and SOLID Principles: A Practical Guide

This comprehensive tutorial explores the origins, concepts, classifications, and practical applications of software design patterns—including the classic 23 GoF patterns—and explains the seven SOLID principles with clear Java code examples, helping developers write more reusable, readable, and maintainable code.

Design PatternsObject-OrientedSOLID
0 likes · 34 min read
Mastering Java Design Patterns and SOLID Principles: A Practical Guide
Top Architect
Top Architect
Apr 30, 2021 · Fundamentals

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

This article explains the fundamental notion of software architecture, why it is needed, the responsibilities of architects, various architecture classifications, typical application architectures such as layered, CQRS, hexagonal and onion models, and introduces Alibaba's open‑source COLA framework with its layered design, extension mechanisms and standards.

COLACQRSHexagonal Architecture
0 likes · 13 min read
Understanding Software Architecture: Concepts, Classifications, and the COLA Framework
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Apr 29, 2021 · Fundamentals

Understanding the Singleton Pattern: Definition, Nine Implementations, Pros & Cons, and Android Applications

This article explains the Singleton design pattern, its core concept of ensuring a single instance, presents nine Java implementations with code examples, compares their advantages and disadvantages, discusses real‑world usage in Android and general development, and offers guidelines for when to apply the pattern.

AndroidDesign PatternsObject Creation
0 likes · 15 min read
Understanding the Singleton Pattern: Definition, Nine Implementations, Pros & Cons, and Android Applications
Top Architect
Top Architect
Apr 29, 2021 · Fundamentals

Five Ways to Replace If‑Else Statements: From Basic Refactoring to Advanced Patterns

This article explores why traditional if‑else constructs often lead to tangled, hard‑to‑maintain code and presents five progressively sophisticated techniques—including removing unnecessary else blocks, using guard clauses, value‑assignment shortcuts, dictionary‑based dispatch, and strategy‑pattern refactoring—to write cleaner, more readable software.

Code RefactoringSoftware Architectureif-else
0 likes · 6 min read
Five Ways to Replace If‑Else Statements: From Basic Refactoring to Advanced Patterns
IT Architects Alliance
IT Architects Alliance
Apr 28, 2021 · Fundamentals

Understanding Software Architecture: Concepts, Classifications, and the COLA Application Architecture

This article explains what software architecture is, why it is needed, the responsibilities of architects, various architecture classifications, common architectural styles such as layered, CQRS, hexagonal and onion, and introduces the COLA application architecture with its layered design, extension mechanisms and normative guidelines.

COLACQRSDesign Patterns
0 likes · 12 min read
Understanding Software Architecture: Concepts, Classifications, and the COLA Application Architecture
Swan Home Tech Team
Swan Home Tech Team
Apr 27, 2021 · Backend Development

The Evolution and QA Challenges of the Home Service Order System: From Bronze to Diamond

This article chronicles the six‑year evolution of the Tian'e Home Service order platform—from its early embedded form in 2015 to a unified, multi‑service order system—detailing architectural milestones, functional upgrades, and the testing challenges faced by the QA team throughout each phase.

QASoftware ArchitectureSystem Integration
0 likes · 14 min read
The Evolution and QA Challenges of the Home Service Order System: From Bronze to Diamond
WeDoctor Frontend Technology
WeDoctor Frontend Technology
Apr 20, 2021 · Fundamentals

Master Design Patterns: Boost Code Reusability, Readability, and Maintainability

This comprehensive guide explains what design patterns are, why they matter, the fundamentals of object‑oriented programming, ten core SOLID principles, a mnemonic for 23 patterns, and detailed examples of creational, structural, and behavioral patterns with real‑world code snippets to help developers write cleaner, more maintainable software.

Design PatternsSOLID principlesSoftware Architecture
0 likes · 28 min read
Master Design Patterns: Boost Code Reusability, Readability, and Maintainability
Alibaba Cloud Developer
Alibaba Cloud Developer
Apr 19, 2021 · Backend Development

How to Build Scalable Business Architecture: Standards, Reuse, and Continuous Refactoring

This article examines common pain points in building and maintaining business applications, proposes a design specification that standardizes technical details, encourages component reuse, promotes continuous refactoring, and introduces a service orchestration engine to streamline complex workflow integration.

Service OrchestrationSoftware Architecturebackend-development
0 likes · 15 min read
How to Build Scalable Business Architecture: Standards, Reuse, and Continuous Refactoring
Top Architect
Top Architect
Apr 18, 2021 · Fundamentals

How to Create Effective Software Architecture Diagrams: Concepts, Types, and Best Practices

This article explains the fundamentals of software architecture diagrams, introduces the 4+1 view taxonomy and the C4 model, describes how to choose the right diagram for different audiences, and shares practical tips, common pitfalls, and tool recommendations for clear, self‑describing architecture visuals.

C4 ModelSoftware ArchitectureSystem Design
0 likes · 11 min read
How to Create Effective Software Architecture Diagrams: Concepts, Types, and Best Practices
Architects' Tech Alliance
Architects' Tech Alliance
Apr 17, 2021 · Fundamentals

Evolution of Software Architecture: Monolithic, Distributed, Microservices, and Serverless

The article explains the progression of software architecture from simple monolithic designs through distributed applications and microservices to modern serverless solutions, outlining each model's structure, advantages, disadvantages, and impact on development, deployment, and operational complexity.

MicroservicesServerlessSoftware Architecture
0 likes · 12 min read
Evolution of Software Architecture: Monolithic, Distributed, Microservices, and Serverless
IT Architects Alliance
IT Architects Alliance
Apr 17, 2021 · Backend Development

Domain‑Oriented Microservice Architecture (DOMA) at Uber: Design, Benefits, and Practical Guidance

This article explains Uber’s Domain‑Oriented Microservice Architecture (DOMA), describing why the company adopted it, how domains, layer design, gateways and extensions are organized, the operational benefits achieved, and practical advice for companies of different sizes considering a similar evolution.

Backend EngineeringMicroservicesScalability
0 likes · 18 min read
Domain‑Oriented Microservice Architecture (DOMA) at Uber: Design, Benefits, and Practical Guidance
IT Architects Alliance
IT Architects Alliance
Apr 15, 2021 · Backend Development

Why Understanding Software Architecture Evolution Is Key for Developers

This article outlines the four main software architecture styles—monolithic, distributed, microservices, and serverless—detailing their structures, advantages, drawbacks, and how each impacts development, maintenance, scalability, and operational costs for modern software engineers.

MicroservicesServerlessSoftware Architecture
0 likes · 11 min read
Why Understanding Software Architecture Evolution Is Key for Developers
Alibaba Cloud Developer
Alibaba Cloud Developer
Apr 14, 2021 · Fundamentals

Unlock the Core Logic of Design Patterns: Identify and Encapsulate Change

This article explains why mastering the underlying logic of design patterns—recognizing what changes and how to encapsulate those changes—is essential for developers to select appropriate patterns, improve object‑oriented design, and solve real‑world software problems effectively.

Object-Oriented DesignSoftware Architecturechange encapsulation
0 likes · 15 min read
Unlock the Core Logic of Design Patterns: Identify and Encapsulate Change
21CTO
21CTO
Apr 13, 2021 · Fundamentals

Choosing the Right Architecture: Monolith, Distributed, Microservices, and Serverless

Software developers need to understand the evolution of software architectures—from simple monolithic designs to distributed applications, microservices, and serverless platforms—because each model has distinct advantages and drawbacks that affect scalability, maintainability, deployment frequency, operational complexity, and overall cost.

Distributed SystemsMicroservicesSoftware Architecture
0 likes · 13 min read
Choosing the Right Architecture: Monolith, Distributed, Microservices, and Serverless
21CTO
21CTO
Apr 8, 2021 · Fundamentals

Uncovering the True Essence of Software Architecture: From Machine Code to Modern Design

This article explores the evolution of software development—from machine language and assembly to high‑level languages—examines the two software crises that spurred structured and object‑oriented programming, and explains how software architecture emerged to manage system scale, coupling, and complexity.

Software Architecturearchitecture fundamentalssoftware development
0 likes · 12 min read
Uncovering the True Essence of Software Architecture: From Machine Code to Modern Design
Architecture Digest
Architecture Digest
Apr 8, 2021 · Fundamentals

Understanding Domain-Driven Design: Core Concepts, Layers, and Patterns

This article explains the fundamentals of Domain-Driven Design, describing how a shared ubiquitous language and a well‑crafted domain model drive software architecture across presentation, application, domain, and infrastructure layers, and it covers key patterns such as aggregates, entities, value objects, repositories, CQRS, Event Sourcing, and DCI.

AggregatesCQRSDomain-Driven Design
0 likes · 36 min read
Understanding Domain-Driven Design: Core Concepts, Layers, and Patterns
IT Architects Alliance
IT Architects Alliance
Apr 4, 2021 · Fundamentals

Understanding Software Architecture: History, Concepts, and Principles

This article explores the evolution of software development from machine code to high‑level languages, explains the two software crises, and defines software architecture by clarifying related concepts such as systems, subsystems, modules, components, and frameworks, ultimately highlighting architecture as a solution to system complexity.

Software Architectureprogrammingsoftware-engineering
0 likes · 12 min read
Understanding Software Architecture: History, Concepts, and Principles
Architects' Tech Alliance
Architects' Tech Alliance
Apr 3, 2021 · Fundamentals

Understanding Software Architecture: History, Concepts, and Definitions

This article explores the evolution of software development from machine language to high‑level languages, explains the two software crises, and defines software architecture by distinguishing systems, subsystems, modules, components, and frameworks, emphasizing architecture as a top‑level structural solution for managing complexity.

ComponentObject-OrientedSoftware Architecture
0 likes · 11 min read
Understanding Software Architecture: History, Concepts, and Definitions
Selected Java Interview Questions
Selected Java Interview Questions
Apr 2, 2021 · Backend Development

Design Patterns in MyBatis: Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, and Iterator

This article analyses how MyBatis applies nine classic design patterns—Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, and Iterator—by examining its source code, illustrating each pattern with explanations and concrete Java examples to deepen understanding of software design in backend development.

Design PatternsMyBatisSoftware Architecture
0 likes · 20 min read
Design Patterns in MyBatis: Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, and Iterator
IT Architects Alliance
IT Architects Alliance
Mar 29, 2021 · Fundamentals

How to Create Clear Architecture Diagrams: Concepts, Types, and Best Practices

This article explains why architecture diagrams are essential for communication, defines key concepts, introduces the 4+1 view classification, outlines criteria for good diagrams, and presents the C4 modeling method with practical examples to help teams produce self‑describing, audience‑focused system visuals.

C4 ModelSoftware ArchitectureSystem Design
0 likes · 9 min read
How to Create Clear Architecture Diagrams: Concepts, Types, and Best Practices
Top Architect
Top Architect
Mar 29, 2021 · Fundamentals

Understanding Software Architecture: History, Concepts, and Goals

This article explains the evolution of software development from machine code to high‑level languages, describes the two software crises that led to structured programming and OOP, and defines software architecture as the top‑level structure that manages system complexity through clear components, modules, and rules.

Software Architecturearchitecture fundamentalscomponent-based design
0 likes · 11 min read
Understanding Software Architecture: History, Concepts, and Goals
Top Architect
Top Architect
Mar 28, 2021 · Fundamentals

Anemic vs Rich Domain Model: Understanding DDD Concepts

The article explains the difference between anemic (transaction‑script) and rich (domain‑model) designs in DDD, outlines their historical origins, advantages and drawbacks, and argues why embedding behavior in domain objects aligns better with object‑oriented principles despite added complexity.

Domain-Driven DesignRich ModelSoftware Architecture
0 likes · 8 min read
Anemic vs Rich Domain Model: Understanding DDD Concepts
Architect
Architect
Mar 26, 2021 · Fundamentals

Anemic vs. Rich Domain Model: Core Concepts and Trade‑offs in Domain‑Driven Design

The article explains the fundamental differences between the anemic (transaction‑script) and rich (domain‑model) approaches in DDD, discusses their historical origins, advantages, disadvantages, and provides concrete examples to help developers decide when to apply each model in software architecture.

Domain-Driven DesignObject-Oriented DesignRich Model
0 likes · 8 min read
Anemic vs. Rich Domain Model: Core Concepts and Trade‑offs in Domain‑Driven Design
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Mar 26, 2021 · Fundamentals

Design Patterns and SOLID Principles for Building a Message Sending Service

This article explains how to apply classic design patterns and the six SOLID principles—Liskov Substitution, Single Responsibility, Dependency Inversion, Interface Segregation, Law of Demeter, and Open‑Closed—to design a maintainable, extensible message‑sending system with task scheduling and dynamic provider configuration.

BackendDesign PatternsPHP
0 likes · 17 min read
Design Patterns and SOLID Principles for Building a Message Sending Service
Architect
Architect
Mar 17, 2021 · Fundamentals

Understanding Domains, Subdomains, and Core Domains in Domain-Driven Design

This article explains the distinction between technical and business domains, defines domains and subdomains, describes how to identify core, generic, and supporting subdomains, and outlines practical methods such as domain vision statements and highlighted cores for effective domain‑driven design.

Core DomainDDDDomain-Driven Design
0 likes · 10 min read
Understanding Domains, Subdomains, and Core Domains in Domain-Driven Design
IT Architects Alliance
IT Architects Alliance
Mar 16, 2021 · Fundamentals

Layered Thinking and Modeling in Architecture Design

This article explains how layered thinking and layered models guide architecture design, covering decomposition and integration, cloud three‑tier (IaaS‑PaaS‑SaaS) and SOA layering, the role of service and data layers, and how to combine cloud and SOA concepts into coherent architectural diagrams.

Layered DesignSOASoftware Architecture
0 likes · 15 min read
Layered Thinking and Modeling in Architecture Design
IT Architects Alliance
IT Architects Alliance
Mar 14, 2021 · Fundamentals

Common Software Architecture Patterns: Layered, Multi‑Layer, Pipe‑Filter, Client‑Server, MVC, Event‑Driven, and Microservices

The article explains seven widely used software architecture patterns—layered, multi‑layer, pipe‑filter, client‑server, MVC, event‑driven, and microservices—detailing their contexts, problems they solve, typical structures, strengths, weaknesses, and suitable application scenarios.

Design PatternsEvent-drivenMVC
0 likes · 10 min read
Common Software Architecture Patterns: Layered, Multi‑Layer, Pipe‑Filter, Client‑Server, MVC, Event‑Driven, and Microservices
Programmer DD
Programmer DD
Mar 12, 2021 · Backend Development

Why Your “Distributed Monolith” Undermines Microservice Success

Many companies attempt microservice transformations only to end up with a “distributed monolith” that looks like microservices but retains monolithic flaws, leading to increased complexity, reduced stability, and minimal performance gains, as this article explains the root causes and how to avoid them.

Software Architecturedistributed monolithsystem stability
0 likes · 8 min read
Why Your “Distributed Monolith” Undermines Microservice Success
Huawei Cloud Developer Alliance
Huawei Cloud Developer Alliance
Mar 10, 2021 · Fundamentals

Mastering Clean Code: SOLID Principles, Architecture Patterns, and Naming Strategies

This article distills essential software design knowledge—covering the five SOLID principles, three common architecture styles, effective diagramming, naming conventions, and techniques for simplifying nested if‑else logic—providing concrete Python examples and visual aids to help developers write more maintainable and robust code.

Design PatternsPythonSoftware Architecture
0 likes · 22 min read
Mastering Clean Code: SOLID Principles, Architecture Patterns, and Naming Strategies
Programmer DD
Programmer DD
Mar 2, 2021 · Backend Development

How to Properly Layer Your Project: Best Practices and Alibaba Guidelines

This article explains why clear application layering matters, outlines Alibaba's recommended layers, proposes an optimized layering approach, details domain model mappings for each layer, and offers practical tips to improve maintainability and team collaboration in backend development.

Alibaba guidelinesLayered DesignSoftware Architecture
0 likes · 9 min read
How to Properly Layer Your Project: Best Practices and Alibaba Guidelines
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Feb 18, 2021 · Cloud Native

What Is Cloud Native? Key Concepts, Principles, and Practices Explained

This article explains the cloud native paradigm—originating from Matt Stine in 2013—and its core components such as DevOps, continuous delivery, microservices, agile infrastructure, and the Twelve‑Factor App, showing how they enable resilient, scalable applications built directly on cloud services.

Continuous DeliveryDevOpsMicroservices
0 likes · 18 min read
What Is Cloud Native? Key Concepts, Principles, and Practices Explained
21CTO
21CTO
Feb 17, 2021 · Backend Development

Mastering API Design for Microservices: Principles, Pitfalls, and Best Practices

Effective API design is crucial for microservice architectures, reducing communication overhead, preventing API decay, and ensuring scalability; this article outlines common pitfalls, core design principles such as simplicity, focus, extensibility, compatibility, thorough testing, and documentation to help developers build robust, maintainable services.

MicroservicesSoftware Architectureapi-design
0 likes · 11 min read
Mastering API Design for Microservices: Principles, Pitfalls, and Best Practices
21CTO
21CTO
Feb 15, 2021 · Backend Development

From Java Developer to Architect: Lessons on Building High‑Concurrency Systems

The author reflects on their path from a senior Java developer to a software architect, describing early misconceptions, the pitfalls of over‑focusing on code, the importance of mastering existing components, and how design patterns and maintainability become essential when assembling high‑concurrency, distributed architectures.

Design PatternsDistributed SystemsSoftware Architecture
0 likes · 8 min read
From Java Developer to Architect: Lessons on Building High‑Concurrency Systems
Code Ape Tech Column
Code Ape Tech Column
Feb 4, 2021 · Backend Development

From Monolith to Microservices: Tracing the Architecture Evolution

The article traces the evolution of software architecture—from monolithic applications through vertical splitting, distributed services, and finally microservices—detailing their advantages, drawbacks, and the essential technology stack such as service discovery, API gateways, authentication, logging, containerization, orchestration, and CI/CD, while providing practical examples and references.

Cloud NativeMicroservicesSoftware Architecture
0 likes · 19 min read
From Monolith to Microservices: Tracing the Architecture Evolution
iQIYI Technical Product Team
iQIYI Technical Product Team
Jan 29, 2021 · Frontend Development

Efficient Front-End Componentization Practices at iQIYI Knowledge Web Team

The iQIYI Knowledge Web front‑end team built a developer‑oriented component library that splits UI and business logic into reusable basic and business Vue components, enforces clear input/output contracts, uses on‑demand loading and Storybook documentation, achieving high code reuse, maintainability, and consistent UI across independent projects while tackling bundle size and CI/CD challenges.

ComponentizationSoftware ArchitectureUI components
0 likes · 14 min read
Efficient Front-End Componentization Practices at iQIYI Knowledge Web Team
21CTO
21CTO
Jan 26, 2021 · Fundamentals

Mastering the 21 Essential Software Architecture Characteristics

This article explains the twenty‑one key non‑functional characteristics of software architecture—such as performance, reliability, scalability, security and maintainability—detailing their definitions, typical metrics, and practical techniques for improvement, while linking each trait to ISO‑25010 and real‑world engineering practices.

DevOpsNon-functional RequirementsReliability
0 likes · 20 min read
Mastering the 21 Essential Software Architecture Characteristics
dbaplus Community
dbaplus Community
Jan 9, 2021 · Backend Development

How We Refactored a 30k‑Line Ad Engine in One Month: Key Lessons

In this detailed case study, a team describes how they successfully refactored a 30,000‑line advertising engine within a month, covering the system's legacy challenges, preparation steps, execution tactics, testing strategies, and the seven critical takeaways that ensured a smooth, low‑risk rollout.

Ad TechBackendProject Management
0 likes · 11 min read
How We Refactored a 30k‑Line Ad Engine in One Month: Key Lessons
Youzan Coder
Youzan Coder
Jan 6, 2021 · Backend Development

Decoupling Chain Business Logic: Challenges, Design Principles, and Implementation

The article examines the tangled code and maintenance pain points of multi‑store (chain) product management, then proposes separating generic and chain‑specific logic into distinct services—mei‑goods for single‑store functions and mei‑chain for cross‑store rules—using OCP, SRP, and domain‑driven design to achieve decoupling, isolated deployment, clearer responsibilities, and improved system stability and developer productivity.

Code DecouplingMicroservicesSoftware Architecture
0 likes · 16 min read
Decoupling Chain Business Logic: Challenges, Design Principles, and Implementation
Programmer DD
Programmer DD
Dec 26, 2020 · R&D Management

Why Alibaba Is Thinning Its Mid‑Platform and What It Means for Innovation

The article analyzes Alibaba's recent decision to dismantle and thin its mid‑platform, tracing its origins, evaluating its impact on business agility and innovation, and discussing why a leaner architecture suits combination‑style innovation while disruptive breakthroughs require a different approach.

AlibabaInnovationSoftware Architecture
0 likes · 7 min read
Why Alibaba Is Thinning Its Mid‑Platform and What It Means for Innovation
Beike Product & Technology
Beike Product & Technology
Dec 24, 2020 · Frontend Development

Improving Frontend Efficiency with the YuanShi Platform: Team Structure, Collaboration, and Component‑Based Development

The article explains how the YuanShi platform was created to address front‑end talent shortage by standardising tools, redefining team structures, introducing component‑based cooperation, and outlining the evolution, benefits, challenges, and future directions of this approach within a large B‑end organization.

Component LibrarySoftware Architecturefrontend
0 likes · 14 min read
Improving Frontend Efficiency with the YuanShi Platform: Team Structure, Collaboration, and Component‑Based Development
Architects' Tech Alliance
Architects' Tech Alliance
Dec 22, 2020 · Fundamentals

Understanding Software Architecture: Concepts, Classifications, and the COLA Application Architecture

This article explains the abstract nature of software architecture, why it is essential for any system, the responsibilities of architects, various architecture classifications, typical patterns such as layered, CQRS, hexagonal and onion, and introduces the open‑source COLA architecture with its layered design, extension and specification concepts.

COLADesign PatternsDomain-Driven Design
0 likes · 13 min read
Understanding Software Architecture: Concepts, Classifications, and the COLA Application Architecture
Huawei Cloud Developer Alliance
Huawei Cloud Developer Alliance
Dec 17, 2020 · Operations

How DevOps and Microservices Enable Fast, Stable Software Delivery

This article compares ancient warfare logistics with modern software delivery, defines DevOps and microservices, presents survey data on DevOps adoption, explains microservice characteristics, outlines suitable scenarios, and discusses the benefits and challenges of adopting a microservice‑based DevOps approach.

Cloud NativeContinuous DeliveryMicroservices
0 likes · 10 min read
How DevOps and Microservices Enable Fast, Stable Software Delivery
Code Ape Tech Column
Code Ape Tech Column
Dec 13, 2020 · Fundamentals

Common Software Architecture Patterns and Their Characteristics

This article introduces seven common software architecture patterns—layered, multilayer, pipe‑filter, client‑server, MVC, event‑driven, and microservices—explaining their context, typical problems they address, core solutions, inherent drawbacks, and suitable application scenarios for developers and system designers.

Design PatternsEvent-drivenMVC
0 likes · 10 min read
Common Software Architecture Patterns and Their Characteristics
vivo Internet Technology
vivo Internet Technology
Dec 9, 2020 · Backend Development

Applying Domain‑Driven Design in Microservice Architecture: Practices and Principles

The article explains how monolithic drawbacks—complexity, technical debt, and scaling issues—drive the shift to microservices, then details applying Domain‑Driven Design principles such as bounded contexts, aggregates, and layered architecture to design cohesive, loosely‑coupled services, illustrated with e‑commerce examples and code snippets.

AggregatesClean ArchitectureDomain-Driven Design
0 likes · 26 min read
Applying Domain‑Driven Design in Microservice Architecture: Practices and Principles
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Dec 6, 2020 · Fundamentals

Mastering 7 Core Software Architecture Patterns: When and How to Use Them

This article explains seven fundamental software architecture patterns—layered, multi‑layer, pipe‑filter, client‑server, MVC, event‑driven, and microservices—detailing their contexts, problems they solve, typical solutions, drawbacks, and ideal use cases for developers seeking robust system designs.

Design PatternsMVCMicroservices
0 likes · 12 min read
Mastering 7 Core Software Architecture Patterns: When and How to Use Them
macrozheng
macrozheng
Dec 4, 2020 · Fundamentals

Mastering the Chain of Responsibility Pattern with a Qing Dynasty Journey Example

This article introduces the Chain of Responsibility design pattern using a whimsical Qing dynasty south‑tour scenario, walks through class design, UML diagrams, and Java code examples—including abstract officials, a singleton emperor, and a prime minister orchestrating the travel—demonstrating flexible, extensible workflow construction.

OOPSoftware Architecture
0 likes · 13 min read
Mastering the Chain of Responsibility Pattern with a Qing Dynasty Journey Example
IT Architects Alliance
IT Architects Alliance
Nov 29, 2020 · Backend Development

Why High Performance Makes Software Architecture So Complex—and How to Tame It

The article analyzes how the relentless pursuit of high performance drives both single‑machine and cluster‑level architectural complexity, explaining the evolution from batch processing to multi‑core CPUs, the trade‑offs of processes, threads, SMP/NUMA/MPP, and the challenges of task allocation and decomposition in large‑scale systems.

BackendDistributed SystemsScalability
0 likes · 16 min read
Why High Performance Makes Software Architecture So Complex—and How to Tame It
Top Architect
Top Architect
Nov 29, 2020 · Backend Development

Software Architecture Patterns: Traditional Three‑Tier, Cluster, Distributed, and Microservice Architectures

This article explains common software architecture patterns—including traditional three‑tier, cluster (horizontal scaling), distributed (vertical splitting), and microservice (vertical division) architectures—detailing their components, advantages, drawbacks, and configuration examples such as Tomcat clustering with Nginx load balancing.

BackendDistributed SystemsMicroservices
0 likes · 9 min read
Software Architecture Patterns: Traditional Three‑Tier, Cluster, Distributed, and Microservice Architectures
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Nov 28, 2020 · Fundamentals

What 19 Core Topics Every Software Architect Must Master

This article outlines a comprehensive knowledge framework for software architects, covering nineteen essential areas such as responsibilities, foundational concepts, internet system challenges, distributed caching, messaging, load balancing, performance testing, operating systems, algorithms, networking, database design, JVM internals, flash-sale systems, microservices, domain‑driven design, security, high‑availability, big data, and blockchain.

Big DataMicroservicesSoftware Architecture
0 likes · 6 min read
What 19 Core Topics Every Software Architect Must Master
IT Architects Alliance
IT Architects Alliance
Nov 27, 2020 · R&D Management

Why Do We Really Need Software Architecture? Uncovering the True Purpose

This article examines common misconceptions about software architecture, explains that its core purpose is to manage system complexity, offers practical guidance for identifying complexity hotspots, and presents a concrete university student‑management system case study to illustrate effective architectural decision‑making.

R&DSoftware ArchitectureSystem Design
0 likes · 11 min read
Why Do We Really Need Software Architecture? Uncovering the True Purpose
Top Architect
Top Architect
Nov 27, 2020 · Fundamentals

Common Software Architecture Patterns and Their Applications

This article introduces ten widely used software architecture patterns—including layered, client‑server, master‑slave, pipe‑filter, broker, P2P, blackboard, interpreter, and MVC—explaining their structures, typical use cases, advantages, and disadvantages, and provides a comparative table to help developers select the most suitable pattern for enterprise‑level system design.

Architecture PatternsSoftware ArchitectureSystem Design
0 likes · 11 min read
Common Software Architecture Patterns and Their Applications
IT Architects Alliance
IT Architects Alliance
Nov 26, 2020 · Industry Insights

Why Did Software Architecture Emerge? A Journey Through Programming History

The article traces the evolution of software development—from early machine code and assembly, through high‑level languages, the first and second software crises, structured and object‑oriented programming, to the rise of software architecture in the 1990s—explaining the historical forces that shaped modern architectural design.

Object-OrientedSoftware Architectureprogramming history
0 likes · 13 min read
Why Did Software Architecture Emerge? A Journey Through Programming History
NetEase Cloud Music Tech Team
NetEase Cloud Music Tech Team
Nov 25, 2020 · Fundamentals

Implementing IoC and DI in TypeScript: A Practical Guide

This guide shows how to build a lightweight Inversion of Control container in TypeScript and use Reflect‑Metadata decorators to register providers and inject dependencies, demonstrating how constructor‑based injection decouples classes, simplifies testing, and mirrors patterns used in frameworks such as NestJS, Midway, and Angular.

DecoratorInversion of ControlIoC
0 likes · 16 min read
Implementing IoC and DI in TypeScript: A Practical Guide
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 24, 2020 · Fundamentals

Why Classification Thinking Is the Core of Application Architecture

This article explains how classification thinking—organizing software into modules, components, and packages—forms the foundation of application architecture, illustrates the COLA framework’s evolution, and shows how proper layering and domain‑oriented packaging improve maintainability and scalability.

COLAComponentPackage
0 likes · 15 min read
Why Classification Thinking Is the Core of Application Architecture