BestHub
Sign in
Tagged articles

Software Architecture

1352 articles · Page 5 of 14
Selected Java Interview Questions
Selected Java Interview Questions
Jul 1, 2024 · Fundamentals

Java Design Patterns: Strategy, Factory, Singleton, Proxy, Observer, Template Method, Adapter and More

This article provides a comprehensive introduction to common Java design patterns—including Strategy, Factory, Singleton, Proxy, Observer, Template Method, and Adapter—explaining their concepts, typical use‑cases, and complete code implementations with Spring Boot integration for practical application development.

Design PatternsFactory PatternJava
0 likes · 20 min read
Java Design Patterns: Strategy, Factory, Singleton, Proxy, Observer, Template Method, Adapter and More
DevOps
DevOps
Jun 30, 2024 · Fundamentals

Understanding Systems, Architecture, and Complexity: A Comprehensive Overview

This article explores system theory, architectural design, and complexity, presenting a structured view of systems, their characteristics, modeling approaches like 4+1 and C4, microservice concepts, and the Cynefin framework, offering developers practical insights to manage and evolve software systems effectively.

C4 modelComplexityCynefin framework
0 likes · 19 min read
Understanding Systems, Architecture, and Complexity: A Comprehensive Overview
FunTester
FunTester
Jun 28, 2024 · Industry Insights

Why System Thinking Matters: From Architecture Basics to Managing Complexity

An in‑depth exploration shows how viewing software as a system, mastering architectural models like 4+1, C4 and TOGAF, and applying the Cynefin framework for complexity can guide developers from basic system concepts to effective microservice design and complexity management.

C4 modelCynefinSoftware Architecture
0 likes · 20 min read
Why System Thinking Matters: From Architecture Basics to Managing Complexity
Tencent Cloud Developer
Tencent Cloud Developer
Jun 26, 2024 · Fundamentals

Why System Thinking and Architecture Matter: A Deep Dive into Complexity and Design

This article explores how a systematic, high‑dimensional view of software systems—covering system theory, architectural models like 4+1, C4 and TOGAF, micro‑service design, and the Cynefin complexity framework—helps developers move from code‑writing to strategic architecture while managing complexity.

C4 modelCynefin frameworkSoftware Architecture
0 likes · 21 min read
Why System Thinking and Architecture Matter: A Deep Dive into Complexity and Design
DevOps
DevOps
Jun 17, 2024 · Product Management

Understanding Software Requirement Changes and the Software Value Model

The article examines why software requirements frequently change, introduces a four‑layer software value model—from business value to UI aesthetics—and explains how this model guides product managers and engineers in handling requirement volatility, balancing flexibility, and maintaining architectural integrity.

Software Architecturebusiness valueproduct management
0 likes · 8 min read
Understanding Software Requirement Changes and the Software Value Model
DaTaobao Tech
DaTaobao Tech
Jun 12, 2024 · Backend Development

Refactoring Large-Scale Video Streaming Engineering: Theory and Practice

The article presents a comprehensive guide to large‑scale video‑streaming system refactoring, combining theory on continuous improvement, architectural evolution, code‑quality criteria, and challenges with a practical roadmap that leverages automation, systematic analysis, engineering safeguards, static‑analysis tools, and design patterns to safely transform legacy monoliths into modular, containerized platforms.

Component ArchitectureEngineering PracticesSoftware Architecture
0 likes · 16 min read
Refactoring Large-Scale Video Streaming Engineering: Theory and Practice
JD Tech Talk
JD Tech Talk
Jun 12, 2024 · Backend Development

Applying Domain-Driven Design: A Restaurant Case Study for Architecture and Domain Modeling

This article presents a comprehensive, restaurant‑based case study that demonstrates how to apply Domain‑Driven Design principles—including domain analysis, unified language, domain division, service design, modeling, upstream/downstream relationships, layered architecture, and microservice decomposition—to create a clear, maintainable software architecture aligned with business requirements.

DDDDomain-Driven DesignSoftware Architecture
0 likes · 22 min read
Applying Domain-Driven Design: A Restaurant Case Study for Architecture and Domain Modeling
JD Cloud Developers
JD Cloud Developers
Jun 12, 2024 · Backend Development

How to Turn a Restaurant Scenario into Concrete DDD Architecture

This article walks through a complete Domain‑Driven Design case study using a restaurant example, covering domain analysis, unified language, domain division, service design, modeling, upstream/downstream relationships, layered architecture, microservice boundaries, and functional implementation to illustrate how business concepts map to software structures.

DDDDomain-Driven DesignSoftware Architecture
0 likes · 23 min read
How to Turn a Restaurant Scenario into Concrete DDD Architecture
Continuous Delivery 2.0
Continuous Delivery 2.0
Jun 12, 2024 · Fundamentals

Major Changes in Software Engineering Over the Past 20 Years and Enduring Core Principles

Over the past two decades, software engineering has shifted from waterfall to agile, embraced DevOps, cloud and micro‑services, containerization, CI/CD, open‑source, AI, heightened security, diverse languages, remote collaboration, user‑centered design, dependency management, and continuous learning, while core concepts such as requirements analysis, design principles, testing, version control, and architecture remain unchanged.

AgileCloud ComputingDevOps
0 likes · 8 min read
Major Changes in Software Engineering Over the Past 20 Years and Enduring Core Principles
Architect's Guide
Architect's Guide
Jun 6, 2024 · Backend Development

Backend Implementation Method and Device Based on SpringBoot

The Chinese Patent CN112905176B granted to Industrial and Commercial Bank of China describes a SpringBoot‑based backend implementation method that extracts operation data, maps business IDs to configuration, builds conditional expressions, and processes data, aiming to reduce development changes, lower costs, and improve system stability.

JavaSoftware ArchitectureSpringBoot
0 likes · 3 min read
Backend Implementation Method and Device Based on SpringBoot
Architecture and Beyond
Architecture and Beyond
May 25, 2024 · R&D Management

Applying Conway's Law and Inverse Conway's Law to Improve Software Development Efficiency and Manage Team Cognitive Load

The article explores how organizational structure, Conway's Law and its inverse, and the management of team cognitive load influence software architecture stability and development efficiency, offering practical measures for team design, governance, and architectural practices to align teams with desired system outcomes.

Conway's lawR&D ManagementSoftware Architecture
0 likes · 18 min read
Applying Conway's Law and Inverse Conway's Law to Improve Software Development Efficiency and Manage Team Cognitive Load
macrozheng
macrozheng
May 24, 2024 · Backend Development

Master Java Design Patterns: Strategy, Chain, Template, Observer, Factory & Singleton

This article explains the core concepts, typical business scenarios, definitions, and concrete Java implementations of six fundamental design patterns—Strategy, Chain of Responsibility, Template Method, Observer, Factory, and Singleton—showing how they improve code maintainability, extensibility, and adherence to SOLID principles.

Software ArchitectureStrategy Patternsingleton
0 likes · 24 min read
Master Java Design Patterns: Strategy, Chain, Template, Observer, Factory & Singleton
Architect
Architect
May 23, 2024 · Fundamentals

Unlocking Software Architecture: How Domain‑Driven Design Elevates Teams and Careers

This article explains Domain‑Driven Design (DDD) from its origins to practical modeling, compares it with MVC, outlines business and personal benefits, discusses drawbacks, details strategic and tactical concepts, and walks through a real‑world VOC product example using event‑storming and four‑color modeling.

DDDDomain-Driven DesignSoftware Architecture
0 likes · 34 min read
Unlocking Software Architecture: How Domain‑Driven Design Elevates Teams and Careers
dbaplus Community
dbaplus Community
May 20, 2024 · Backend Development

When Architects Overdesign: Tales of Microservices, MQ, Caches, and Database Chaos

The article humorously chronicles a series of real‑world over‑design incidents—excessive microservice splitting, needless multi‑database sharding, ubiquitous message‑queue usage, over‑engineered caching, design‑pattern abuse, and bloated database schemas—highlighting why simplicity (KISS) remains the best practice for backend systems.

CachingKISSSoftware Architecture
0 likes · 11 min read
When Architects Overdesign: Tales of Microservices, MQ, Caches, and Database Chaos
Top Architect
Top Architect
May 20, 2024 · Fundamentals

Designing Clear Software Architecture Diagrams: Concepts, Types, and the C4 Model

This article explains the fundamental concepts of software architecture, defines what architecture diagrams are and their purposes, evaluates what makes a good diagram, introduces the C4 modeling approach with system context, container, component, and class diagrams, and provides practical case examples and reference resources.

Architecture DiagramsC4 modelSoftware Architecture
0 likes · 12 min read
Designing Clear Software Architecture Diagrams: Concepts, Types, and the C4 Model
DeWu Technology
DeWu Technology
May 20, 2024 · Fundamentals

Domain-Driven Design (DDD): Concepts, Value, and Modeling Techniques

Domain‑Driven Design aligns software architecture with business needs by establishing a shared language, clear bounded contexts, and strategic‑tactical patterns—entities, value objects, aggregates, services, and events—while using techniques such as Event Storming and Four‑Color Modeling to visualize domains, guide micro‑service boundaries, and produce maintainable, adaptable systems.

Domain-Driven DesignSoftware ArchitectureStrategic Design
0 likes · 28 min read
Domain-Driven Design (DDD): Concepts, Value, and Modeling Techniques
Open Source Linux
Open Source Linux
May 20, 2024 · Backend Development

What Is Middleware and Why It’s Crucial for Modern Software Architecture

Middleware is software that connects system software and application software, enabling communication between components and centralizing application logic toward the system layer; it is widely employed in modern IT frameworks such as web services and service‑oriented architectures to streamline integration and functionality.

Software Architecturebackend developmentmiddleware
0 likes · 3 min read
What Is Middleware and Why It’s Crucial for Modern Software Architecture
ByteDance Data Platform
ByteDance Data Platform
May 8, 2024 · Backend Development

How DataTester’s Architecture Upgrade Uses DDD to Tame Code Complexity

DataTester’s A/B testing platform underwent a comprehensive architectural overhaul, applying domain‑driven design, modular refactoring, automated validation, and dependency inversion to reduce change amplification, cognitive load, and unknown unknowns, ultimately improving code readability, maintainability, scalability, and development efficiency across its lifecycle.

A/B testingDDDSoftware Architecture
0 likes · 29 min read
How DataTester’s Architecture Upgrade Uses DDD to Tame Code Complexity
21CTO
21CTO
Apr 20, 2024 · Backend Development

Why Backend Development Is Harder Today Than 20 Years Ago

Over the past two decades, backend development has shifted from simple server‑side coding to a complex, multidisciplinary field, driven by soaring user expectations, massive system scale, an overwhelming array of technologies, and the need for cloud, container, and cross‑team collaboration skills.

BackendSoftware Architecturedevelopment trends
0 likes · 9 min read
Why Backend Development Is Harder Today Than 20 Years Ago
MoonWebTeam
MoonWebTeam
Apr 16, 2024 · Frontend Development

Mastering Dependency Injection in Frontend: Boost Maintainability and Testability

This article explains the concept of Dependency Injection for frontend projects, compares it with Inversion of Control, showcases practical code examples, discusses popular DI libraries and frameworks, and details implementation techniques such as decorators, reflection, singleton handling, and circular dependency resolution to improve maintainability and testability.

Dependency InjectionDesign PatternsIOC
0 likes · 26 min read
Mastering Dependency Injection in Frontend: Boost Maintainability and Testability
21CTO
21CTO
Apr 14, 2024 · Fundamentals

8 Hard‑Won Lessons on Software Architecture Every Engineer Should Know

This reflective essay shares eight practical insights on software architecture—from the challenge of asking the right questions and deciding what not to build, to the pivotal role of non‑functional requirements, risk‑first design, and the paradox of simplicity—offering engineers actionable guidance for better architectural decisions.

Software Architecturecontinuous codingnon-functional requirements
0 likes · 13 min read
8 Hard‑Won Lessons on Software Architecture Every Engineer Should Know
php Courses
php Courses
Apr 10, 2024 · Fundamentals

What Is the State Pattern? Explanation and PHP Implementation Example

The article introduces the State design pattern as a behavioral pattern that lets objects change their behavior when their internal state changes, compares it with the Strategy pattern, and provides a detailed PHP example illustrating its components and usage.

Design PatternSoftware ArchitectureState Pattern
0 likes · 5 min read
What Is the State Pattern? Explanation and PHP Implementation Example
Ops Development & AI Practice
Ops Development & AI Practice
Apr 4, 2024 · Fundamentals

Mastering the Facade Pattern in Go: Simplify Complex Systems

This article explains the Facade design pattern, outlines its core roles, provides step‑by‑step guidance for implementing it in Go, showcases a complete code example, and discusses its advantages and typical use cases such as API gateways in microservice architectures.

Code ExampleDesign PatternsFacade Pattern
0 likes · 5 min read
Mastering the Facade Pattern in Go: Simplify Complex Systems
Liangxu Linux
Liangxu Linux
Mar 28, 2024 · Fundamentals

Why Do Web Services Need Ports? Understanding the Hidden Layer Behind URLs

Ports act as an essential indirection layer that maps network requests to specific processes, enabling protocols like HTTP and HTTPS to function, while default ports simplify user interaction; this article explains common ports, default values, the role of IPC, naming services, and how ports embody inversion of control principles.

IPCNetworkingSoftware Architecture
0 likes · 18 min read
Why Do Web Services Need Ports? Understanding the Hidden Layer Behind URLs
Java Tech Enthusiast
Java Tech Enthusiast
Mar 23, 2024 · Cloud Native

Why Over‑Engineering with Microservices Is a Trap

Over‑engineering with micro‑services creates needless complexity, high costs, and fragile systems, as many startups and developers adopt them for hype rather than scale, while successful companies like Dropbox and Netflix began as monoliths and thrive, proving that simple, well‑designed architectures usually outweigh distributed solutions.

Software Architecturemonolith
0 likes · 9 min read
Why Over‑Engineering with Microservices Is a Trap
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Mar 21, 2024 · Fundamentals

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

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

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

From Building to Dismantling Middle Platform: Enterprise Software Architecture Evolution

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

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

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

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

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

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

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

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

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

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

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

Principles, Advantages, Challenges, and Future of Multithreaded Architecture

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

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

Understanding Software Architecture: Definitions, Boundaries, and Design Principles

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

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

Why Layered Architecture Remains the Backbone of Modern Software Design

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

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

Mastering Architectural Abstraction: Simplify Complex Systems

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

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

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

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

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

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

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

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

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

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

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

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

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

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

The Purpose of UseCase in Android Architecture

UseCase objects, placed in the Domain layer of modern Android architecture, encapsulate complex business logic that was previously crammed into ViewModels, thereby enforcing clean separation of concerns, adhering to the Single Responsibility Principle, and making the codebase clearer, more maintainable, and scalable.

AndroidDomain LayerMVVM
0 likes · 7 min read
The Purpose of UseCase in Android Architecture
DevOps
DevOps
Jan 22, 2024 · Fundamentals

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

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

Software Architecturearchitecture fundamentalsdesign principles
0 likes · 21 min read
Understanding Software Architecture: Concepts, Types, Principles, and Common Pitfalls
Architect
Architect
Jan 19, 2024 · Fundamentals

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

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

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

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

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

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

XIAOJUSURVEY: A Lightweight and Secure Open-Source Survey System

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

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

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

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

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

Evolution of Software Architecture Styles and Domains

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

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

Five Common Software Architecture Patterns and Their Ideal Use Cases

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

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

Understanding Software Architecture: Principles, Design, and Practices

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

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

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

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

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

Unlock DDD: Practical Hexagonal Architecture and Repository Patterns

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

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

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

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

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

Software Architecture Design: Principles, Complexity, and Best Practices

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

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

Fundamentals of Software Modeling and Design Documentation

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

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

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

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

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

9 Essential Microservices Best Practices to Build Scalable, Secure Systems

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

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

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

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

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

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

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

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

Understanding the Five Creational Design Patterns

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

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

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

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

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

Comprehensive Guide to Software Architecture Design and Practices

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

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

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

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

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

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

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

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

Seven Fundamental Design Principles Behind Design Patterns

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

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

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

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

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

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

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

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

Understanding the Proxy Design Pattern with Java Examples

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

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

Understanding the Chain of Responsibility Design Pattern

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

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

Common Design Patterns in Python

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

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

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

This article explains why software architecture matters, defines the essence of Clean Architecture, compares it with Hexagonal and DDD layered models, and walks through a practical, step‑by‑step process—from business analysis and domain modeling to layer implementation and code examples—showing how to reduce complexity and maintenance cost.

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

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

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

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

Understanding the Command Pattern with Python Examples

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

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

Design Patterns Employed in the MyBatis Framework

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

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

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

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

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

DDD Principles Overview and Lecture Series

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

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

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

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

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

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

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

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

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

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

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

Software Engineering Principles: Code Review, Testing, and Architecture

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

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

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

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

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

How Rich Models Supercharge DDD Entity Design and Boost Maintainability

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

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

Understanding the Strategy Pattern in JavaScript

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

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

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

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

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

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

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

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

Why Learning Multiple Programming Languages Boosts Your Backend Skills

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

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

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

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

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

Cloud-Native Architecture Evolution and Practices at ZEEK Automotive

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

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

Why Architecture Visualization Matters and How to Apply the C4 Model

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

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

The Seven SOLID Principles in Java Software Design

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

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

Understanding the Strategy Design Pattern with Java Examples

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

Design PatternsJavaObject-Oriented Programming
0 likes · 9 min read
Understanding the Strategy Design Pattern with Java Examples