BestHub
Sign in
Tagged articles
1187 articles
Page 3 of 12
JD Tech Talk
JD Tech Talk
Oct 9, 2024 · Operations

What Is RPA? Advantages, Applications, Architecture, and Future Outlook

This article explains Robotic Process Automation (RPA), its cost‑saving and efficiency benefits, common use cases such as private‑domain operations, HR and e‑commerce, the business and technical architecture of a large‑scale RPA system, Android accessibility service fundamentals, sample code, and future AI‑driven enhancements.

AI integrationAndroid accessibilityAutomation
0 likes · 12 min read
What Is RPA? Advantages, Applications, Architecture, and Future Outlook
macrozheng
macrozheng
Sep 26, 2024 · Cloud Native

Why 2023 Marks the Decline of Microservices: Lessons from Google, Amazon, and Others

In 2023, leading tech firms like Google and Amazon publicly questioned the microservice paradigm, revealing performance, cost, and complexity drawbacks, and showcasing a shift toward monolithic or runtime‑driven architectures that promise lower latency, reduced expenses, and simpler scaling.

Cloud NativeSoftware Architecturemonolith
0 likes · 11 min read
Why 2023 Marks the Decline of Microservices: Lessons from Google, Amazon, and Others
JD Retail Technology
JD Retail Technology
Sep 25, 2024 · Big Data

From a Personal Journey to Data Platform Architecture: Insights on Big Data, Cloud Computing, and System Design

The article narrates the author’s 30‑year programming career and shares technical reflections on building business‑agnostic, configurable data platforms, covering batch, streaming, interactive computing, big‑data sharding, Spark, Flink, cloud migration, and the philosophy of software architecture.

Batch ProcessingSoftware ArchitectureSystem Design
0 likes · 23 min read
From a Personal Journey to Data Platform Architecture: Insights on Big Data, Cloud Computing, and System Design
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Sep 23, 2024 · Fundamentals

Understanding UML Deployment Diagrams

This article explains the purpose, components, and relationships of UML deployment diagrams, illustrates a basic deployment example with client, web, application, and database nodes, and provides visual references while also promoting additional architecture resources from the author.

ArtifactDeployment DiagramNode
0 likes · 5 min read
Understanding UML Deployment Diagrams
Architect
Architect
Sep 22, 2024 · Fundamentals

Understanding Software Architecture: Definitions, Vertical Layers, Three‑Layer, Four‑Layer, and Horizontal Designs

This article explains what software architecture means, breaks down its constituent elements such as systems, modules, components and subsystems, and then details vertical layered architectures (including three‑layer and four‑layer models), horizontal modular architectures, complexity evaluation, design principles, and cross‑platform considerations for modern mobile applications.

Software Architecturedesign principleslayered architecture
0 likes · 11 min read
Understanding Software Architecture: Definitions, Vertical Layers, Three‑Layer, Four‑Layer, and Horizontal Designs
DevOps
DevOps
Sep 19, 2024 · Fundamentals

Understanding Software Architecture: Concepts, Layers, and Design Principles

This article explains the fundamentals of software architecture, covering its definition, key components such as systems, modules, components, and subsystems, and explores vertical (layered) and horizontal (modular) architectures, design principles, complexity evaluation, cross‑platform considerations, and practical guidelines for building maintainable applications.

App DevelopmentLayered DesignSoftware Architecture
0 likes · 10 min read
Understanding Software Architecture: Concepts, Layers, and Design Principles
Architecture and Beyond
Architecture and Beyond
Sep 14, 2024 · R&D Management

How Does Technical Debt Affect Development Costs and What Strategies Can Tame It?

This article explains the concept of technical debt, its various classifications, the distinct impacts on front‑end and back‑end development, the multi‑dimensional cost consequences, and practical governance methods—including identification, prioritisation, repayment planning and preventive measures—to help teams manage and reduce debt effectively.

BackendCost ManagementR&D management
0 likes · 30 min read
How Does Technical Debt Affect Development Costs and What Strategies Can Tame It?
FunTester
FunTester
Sep 14, 2024 · R&D Management

Why Does Software Architecture Turn Into a Nightmare and How to Fix It

The article examines why software architectures become tangled—citing resource constraints, poor organization, unmanaged technical debt, outdated tech, and missing documentation—and offers practical strategies such as background analysis, continuous refactoring, training, communication, design‑pattern adoption, engineering culture, and comprehensive testing to restore health.

Engineering CultureSoftware ArchitectureTechnical Debt
0 likes · 25 min read
Why Does Software Architecture Turn Into a Nightmare and How to Fix It
Top Architect
Top Architect
Sep 12, 2024 · Fundamentals

Understanding SPI vs API: Interface Placement and Design Principles

The article explains the distinction between Service Provider Interfaces (SPI) and Application Programming Interfaces (API), discusses three possible package placements for interfaces, outlines rules and advantages of each, and provides guidance on choosing between SPI and API based on extensibility, interaction, and stability.

APIBackendInterface Design
0 likes · 9 min read
Understanding SPI vs API: Interface Placement and Design Principles
Architect
Architect
Sep 10, 2024 · Fundamentals

Understanding SPI vs API: When to Use Service Provider Interfaces versus Application Programming Interfaces

This article explains the distinction between Service Provider Interfaces (SPI) and Application Programming Interfaces (API), examines where interfaces can be placed in a codebase, outlines their respective rules, compares their trade‑offs, and offers guidance on choosing the appropriate approach in software architecture.

APIDDDInterface Design
0 likes · 6 min read
Understanding SPI vs API: When to Use Service Provider Interfaces versus Application Programming Interfaces
Architect
Architect
Sep 5, 2024 · R&D Management

Mastering UML Architecture Diagrams: When and How to Use Each Type

This article explains why architecture diagrams are essential for software engineers, introduces the seven most common UML diagram types, and provides practical guidance on selecting and applying each diagram during requirements analysis, high‑level design, and detailed design phases.

Design DiagramsR&D managementSoftware Architecture
0 likes · 12 min read
Mastering UML Architecture Diagrams: When and How to Use Each Type
JD Tech
JD Tech
Sep 5, 2024 · Fundamentals

Overview of System Complexity and Strategies for Reducing Business Complexity

The article explains what software complexity is, classifies its types, describes the negative impacts of high business complexity, identifies common causes, and presents practical methods such as domain decomposition, layered architecture, structured decomposition, annotation, configurability, and coding standards to effectively reduce complexity.

Code RefactoringConfigurationSoftware Architecture
0 likes · 13 min read
Overview of System Complexity and Strategies for Reducing Business Complexity
Zhuanzhuan Tech
Zhuanzhuan Tech
Sep 5, 2024 · Backend Development

Challenges of Abstraction and Reuse in Business Middle‑Platform Development

The article reflects on the difficulties of turning abstract design concepts such as GOF patterns and DDD into practical, reusable middle‑platform services for an e‑commerce business, discussing when to abstract, the trade‑offs between thin and thick services, and how to balance efficiency with evolving business needs.

Backend DevelopmentSoftware Architectureabstraction
0 likes · 16 min read
Challenges of Abstraction and Reuse in Business Middle‑Platform Development
21CTO
21CTO
Aug 26, 2024 · Backend Development

Monolith vs Microservices: Which Architecture Wins in Real‑World Scenarios?

This article compares monolithic and microservice architectures across latency, complexity, reliability, resource usage, scalability, throughput, deployment speed, and communication cost, revealing where each approach excels and offering guidance on choosing the right style for different team sizes and workloads.

MicroservicesScalabilitySoftware Architecture
0 likes · 16 min read
Monolith vs Microservices: Which Architecture Wins in Real‑World Scenarios?
JavaEdge
JavaEdge
Aug 24, 2024 · Backend Development

When to Use Simple vs Detailed Events in Event‑Driven Architecture

This article examines the trade‑offs between simple and detailed events in event‑driven architectures, illustrating their impact on scalability, coupling, and system design through concrete examples, design guidelines, and considerations from domain‑driven design to practical implementation.

Event-Driven ArchitectureSoftware Architecturebackend design
0 likes · 12 min read
When to Use Simple vs Detailed Events in Event‑Driven Architecture
Architect
Architect
Aug 24, 2024 · Fundamentals

From Business Modeling to Use Case Diagrams: Vision, Business Cases, and System Design

This article guides developers through business modeling, defining a clear vision, creating business and system use‑case diagrams, drawing business sequence diagrams, and refining requirements with use‑case specifications, emphasizing how proper modeling adds real value to software projects.

Software ArchitectureUse Case Diagrambusiness modeling
0 likes · 18 min read
From Business Modeling to Use Case Diagrams: Vision, Business Cases, and System Design
Architecture and Beyond
Architecture and Beyond
Aug 23, 2024 · R&D Management

Core Competencies of a Software Architect: System Design, Technical Skills, Global Perspective, Communication, Project Management, Quality Assurance, and Innovation

This comprehensive guide outlines the seven essential abilities—system design and modeling, broad and deep technical expertise, global and systemic thinking, effective communication and collaboration, project management, quality assurance with technical debt control, and innovative foresight—that together define a successful software architect.

InnovationProject ManagementSoftware Architecture
0 likes · 39 min read
Core Competencies of a Software Architect: System Design, Technical Skills, Global Perspective, Communication, Project Management, Quality Assurance, and Innovation
Senior Tony
Senior Tony
Aug 13, 2024 · Fundamentals

How to Refactor Course Display Logic with the Decorator Pattern in Java

This article demonstrates how to identify long‑method and duplicated code smells in a Java curriculum‑display service and refactor the implementation using the Decorator pattern, providing clear component diagrams, full code examples, and a runnable demo that showcases flexible extensions for different course types.

Bad SmellDecorator PatternDesign Patterns
0 likes · 11 min read
How to Refactor Course Display Logic with the Decorator Pattern in Java
DevOps
DevOps
Aug 12, 2024 · Fundamentals

The Importance of Design and Modeling in Software Development

This article explains why software engineers should perform design and modeling—such as business modeling, process analysis, and system modeling—before writing code, highlighting how these practices align development with business goals, improve collaboration, and reduce costly rework caused by changing requirements.

ModelingObject-OrientedSoftware Architecture
0 likes · 9 min read
The Importance of Design and Modeling in Software Development
Go Programming World
Go Programming World
Aug 4, 2024 · Fundamentals

Applying the Adapter Pattern in Go: From Payment Systems to Multi‑Cloud Management and Model Training Platforms

This article explains the Adapter design pattern, illustrates its real‑world analogy, demonstrates a complete Go implementation for payment processing, and shows how the pattern can be used in production scenarios such as a multi‑cloud management platform and a model‑training service, highlighting its role in unifying incompatible interfaces.

Adapter PatternCloud NativeDesign Patterns
0 likes · 13 min read
Applying the Adapter Pattern in Go: From Payment Systems to Multi‑Cloud Management and Model Training Platforms
Architecture Digest
Architecture Digest
Jul 30, 2024 · Fundamentals

Understanding the Chain of Responsibility Design Pattern with Java Examples

This article explains the Chain of Responsibility design pattern, its typical use cases, demonstrates a flawed nested‑if implementation for a multi‑level game, and then shows step‑by‑step refactorings—including an abstract handler, concrete handlers, and a factory‑based dynamic chain—using Java code examples.

Chain of ResponsibilityJavaSoftware Architecture
0 likes · 10 min read
Understanding the Chain of Responsibility Design Pattern with Java Examples
Java Tech Enthusiast
Java Tech Enthusiast
Jul 29, 2024 · Industry Insights

10 Warning Signs That a Technical Architect Is Not Up to the Role

The article outlines eleven common shortcomings—ranging from weak technical fundamentals and lack of business understanding to poor project management, over‑design, communication failures, low execution, insufficient hands‑on experience, ignorance of framework internals, health issues, and missing global perspective—that indicate a software architect may be unqualified for the position.

Project ManagementSoftware ArchitectureSoftware Engineering
0 likes · 9 min read
10 Warning Signs That a Technical Architect Is Not Up to the Role
Architect
Architect
Jul 24, 2024 · Fundamentals

Master Design Patterns: Real‑World Examples and Complete Java Implementations

This article introduces design patterns, lists the most common patterns such as Strategy, Factory, Singleton, Proxy, Factory Method, Observer, Template Method, and Adapter, and walks through concrete Java code examples, step‑by‑step explanations, and practical scenarios that demonstrate how each pattern solves specific design problems.

AdapterDesign PatternsFactory Pattern
0 likes · 23 min read
Master Design Patterns: Real‑World Examples and Complete Java Implementations
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jul 24, 2024 · Backend Development

Mastering Domain-Driven Design: Core Concepts, Layers, and Practical C# Examples

Domain-Driven Design (DDD) is a software development methodology that bridges business and technology by defining clear domain models, improving communication, code quality, and handling complexity through layered architecture, with concrete C# examples of entities, value objects, aggregates, and domain services.

Backend DevelopmentCDDD
0 likes · 7 min read
Mastering Domain-Driven Design: Core Concepts, Layers, and Practical C# Examples
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jul 22, 2024 · Backend Development

Understanding Domain-Driven Design (DDD) Architecture

This article introduces Domain-Driven Design (DDD), explains its core concepts, benefits, and the four-layered DDD architecture—including UI, Application, Domain, and Infrastructure layers—while also offering resources for deeper study and interview preparation.

Backend DevelopmentDDDDesign Patterns
0 likes · 6 min read
Understanding Domain-Driven Design (DDD) Architecture
DevOps
DevOps
Jul 18, 2024 · Fundamentals

Architectural Thinking: Five Core Principles for Managing Complexity

The article explains architectural thinking as a systematic approach to decompose problems, highlighting five core principles—abstraction, global perspective, layered design, evolutionary mindset, and standardization—that help engineers manage complexity, improve design quality, and adapt software systems over time.

Software Architectureabstractioncomplexity management
0 likes · 10 min read
Architectural Thinking: Five Core Principles for Managing Complexity
Architect
Architect
Jul 14, 2024 · Fundamentals

How to Build Technical Depth as a Software Architect

The article explains how developers can transform ordinary requirement work into a platform for gaining technical depth by adopting a product‑owner mindset, focusing on quality, continuous improvement, and aligning deep technical challenges with business goals to earn leadership support and career growth.

Career DevelopmentSoftware Architectureprofessional growth
0 likes · 9 min read
How to Build Technical Depth as a Software Architect
Python Crawling & Data Mining
Python Crawling & Data Mining
Jul 14, 2024 · Fundamentals

Why Design Patterns Matter: Master Reusable Solutions in OOP

This article explains what design patterns are, why they are essential for creating reusable and maintainable object‑oriented code, outlines their main categories, learning steps, and provides a Python command‑pattern example along with a guide to a comprehensive Python design‑patterns book.

Behavioral PatternsCreational PatternsDesign Patterns
0 likes · 7 min read
Why Design Patterns Matter: Master Reusable Solutions in OOP
php Courses
php Courses
Jul 11, 2024 · Fundamentals

Understanding SOLID Principles with Java Examples

This article explains the five SOLID design principles—SRP, OCP, LSP, ISP, and DIP—detailing their definitions, common violations, and Java code examples that demonstrate how to refactor classes for better modularity, extensibility, and maintainability.

JavaObject-OrientedSOLID
0 likes · 7 min read
Understanding SOLID Principles with Java Examples
Alibaba Cloud Developer
Alibaba Cloud Developer
Jul 5, 2024 · Fundamentals

Why Every Developer Should Think Like an Architect: A Practical Guide

This article explores what software architecture means, distinguishes vertical and horizontal architects, outlines the essential skills and methodology for architects, and provides a step‑by‑step framework—from understanding requirements and quality attributes to modeling business and system domains—so anyone can develop an architect’s mindset.

Domain-Driven DesignSoftware Architecturearchitectural thinking
0 likes · 30 min read
Why Every Developer Should Think Like an Architect: A Practical Guide
Architect
Architect
Jul 4, 2024 · Industry Insights

How DDD Transforms Complex Marketing Systems: Strategic and Tactical Design Insights

This article explains how Meituan applied Domain‑Driven Design to build a scalable B‑side marketing platform, covering background challenges, core DDD concepts, strategic use‑case modeling, tactical code mapping, aggregation design, and practical architectural patterns for large‑scale systems.

DDDDomain-Driven DesignMarketing System
0 likes · 20 min read
How DDD Transforms Complex Marketing Systems: Strategic and Tactical Design Insights
Continuous Delivery 2.0
Continuous Delivery 2.0
Jul 4, 2024 · Databases

Designing Bugzilla for Multi‑Database Support: A Case Study

The article recounts how the Bugzilla project, originally tied to a single proprietary database (OldDB), was refactored to support multiple databases—including NewDB—through a comprehensive redesign that involved breaking the work into smaller, well‑tested tasks, improving maintainability and expanding support to four database systems.

Code RefactoringMulti-Database SupportSoftware Architecture
0 likes · 6 min read
Designing Bugzilla for Multi‑Database Support: A Case Study
Model Perspective
Model Perspective
Jul 2, 2024 · Fundamentals

How to Quantify Tight vs Loose Coupling with Graph Theory

Understanding tight and loose coupling in system design, this article explains their trade‑offs, introduces a coupling degree metric based on graph theory, demonstrates calculations with example module dependencies, and discusses when each approach is preferable for performance, maintainability, and scalability.

CouplingSoftware ArchitectureSystem Design
0 likes · 6 min read
How to Quantify Tight vs Loose Coupling with Graph Theory
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 ModelCynefin frameworkMicroservices
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 ModelCynefinMicroservices
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 frameworkMicroservices
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 ArchitectureSoftware Architecturecode quality
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 ModelingDomain-Driven Design
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 ModelingDomain-Driven Design
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.

DevOpsSoftware Architectureagile
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.

Backend DevelopmentJavaSoftware Architecture
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
Top Architect
Top Architect
May 25, 2024 · Mobile Development

Cross‑Platform Architecture for WeChat Pay: Reducing Code, Improving Quality and Productivity

This article describes how a C++‑based cross‑platform framework and a unified routing mechanism were built for WeChat Pay to eliminate platform‑specific bugs, streamline data flow, improve crash stability, cut code size by nearly 45%, and boost development productivity across iOS and Android.

CMobile DevelopmentSoftware Architecture
0 likes · 16 min read
Cross‑Platform Architecture for WeChat Pay: Reducing Code, Improving Quality and Productivity
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.

SingletonSoftware ArchitectureStrategy Pattern
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 DesignModeling
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.

Database designKISSMicroservices
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.

C4 ModelSoftware ArchitectureSystem Design
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 DesignModelingSoftware Architecture
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.

Backend DevelopmentSoftware Architecturemiddleware
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 testingCode RefactoringDDD
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.

BackendDistributed SystemsSoftware Architecture
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.

Design PatternsIoCSoftware Architecture
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.

Non-functional RequirementsSoftware Architecturecontinuous coding
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.

Software ArchitectureState Patternbehavioral 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.

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

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

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

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".

CTOCareer DevelopmentSoftware Architecture
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.

Backend DevelopmentDesign PatternsHigh Cohesion
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.

Architecture PatternsSoftware ArchitectureSoftware Engineering
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 ArchitectureSystem Design
0 likes · 9 min read
Why Layered Architecture Remains the Backbone of Modern Software Design
21CTO
21CTO
Feb 7, 2024 · Fundamentals

Mastering Architectural Abstraction: Simplify Complex Systems

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

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

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

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

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

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

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

SOLIDSoftware Architecturecomplexity
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.

DRYLayered DesignMicroservices
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.

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

The Purpose of UseCase in Android Architecture

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

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

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

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

MicroservicesSoftware ArchitectureSystem Design
0 likes · 21 min read
Understanding Software Architecture: Concepts, Types, Principles, and Common Pitfalls
Architects Research Society
Architects Research Society
Jan 21, 2024 · Fundamentals

Software Architect vs Enterprise Architect: Roles, Responsibilities, and Differences

The article explains the distinct roles of software architects, enterprise architects, solution architects, and technical architects, outlining their responsibilities, focus areas, and how they differ in scope, technical depth, and alignment with business goals within an organization.

Design PatternsSoftware Architectureenterprise architecture
0 likes · 6 min read
Software Architect vs Enterprise Architect: Roles, Responsibilities, and Differences
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.

CConsistencyException Handling
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 SystemUser experience
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.

Domain-Driven DesignFinite State MachineSoftware Architecture
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.

AnalyticsData ArchitectureDomain 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.

AWSCloud Cost OptimizationMicroservices
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.

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

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

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

Embedded CMicrocontrollerSoftware Architecture
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.

DRYSOLIDSoftware Architecture
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 EngineeringSoftware Modeling
0 likes · 16 min read
Fundamentals of Software Modeling and Design Documentation
Java High-Performance Architecture
Java High-Performance Architecture
Dec 16, 2023 · Backend Development

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

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

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

9 Essential Microservices Best Practices to Build Scalable, Secure Systems

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

BackendDevOpsMicroservices
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 DesignException HandlingMicroservices
0 likes · 27 min read
How to Design Scalable, Maintainable Software Architecture: From Principles to Practice