BestHub
Sign in
Tagged articles
848 articles
Page 5 of 9
Baidu Geek Talk
Baidu Geek Talk
Sep 2, 2022 · Fundamentals

Understanding Factory Patterns: Simple Factory, Factory Method, and Abstract Factory with Code Samples

The article explains the Factory design pattern’s three main variants—Simple Factory for limited product types, Factory Method for extensible hierarchies, and Abstract Factory for creating families of related objects—illustrated with Java code examples for document parsing, automated testing, and cross‑platform membership systems.

Abstract FactoryDesign PatternsFactory Method
0 likes · 11 min read
Understanding Factory Patterns: Simple Factory, Factory Method, and Abstract Factory with Code Samples
Architects Research Society
Architects Research Society
Sep 1, 2022 · Cloud Computing

Cloud Design Patterns: Challenges and a Comprehensive Catalog for Building Reliable, Scalable, and Secure Applications

This article explains the key challenges of cloud development—data management, design and implementation, and messaging—then presents a detailed catalog of cloud design patterns, each with problem statements, Azure examples, and categories such as reliability, security, and performance efficiency.

Design PatternsReliabilityScalability
0 likes · 9 min read
Cloud Design Patterns: Challenges and a Comprehensive Catalog for Building Reliable, Scalable, and Secure Applications
Architects Research Society
Architects Research Society
Aug 29, 2022 · Cloud Native

Resilient Software Strategies Every Developer Should Know

Effective software resilience requires strategies such as dead‑letter queues, feature toggles, robust design patterns like bulkhead and circuit breaker, loose coupling, and sidecar containers, enabling developers to isolate failures, reduce impact, and maintain performance in distributed, cloud‑native systems.

Cloud NativeDead Letter QueueDesign Patterns
0 likes · 10 min read
Resilient Software Strategies Every Developer Should Know
Top Architect
Top Architect
Aug 29, 2022 · Mobile Development

Understanding OkHttp: Request Flow, Dispatcher, Interceptors, Connection Reuse, and Design Patterns

This article provides a comprehensive overview of OkHttp, covering its overall request process, the role of the dispatcher, how application and network interceptors work, TCP connection reuse via the connection pool, idle‑connection cleanup, key advantages, and the design patterns employed in the framework.

AndroidConnection PoolDesign Patterns
0 likes · 15 min read
Understanding OkHttp: Request Flow, Dispatcher, Interceptors, Connection Reuse, and Design Patterns
Selected Java Interview Questions
Selected Java Interview Questions
Aug 16, 2022 · Backend Development

Spring Framework Design Patterns Overview

This article explains how Spring implements various design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—detailing their implementation approaches, underlying principles, and practical code examples within the Spring container.

Backend DevelopmentDesign PatternsFactory
0 likes · 13 min read
Spring Framework Design Patterns Overview
Java High-Performance Architecture
Java High-Performance Architecture
Aug 13, 2022 · Fundamentals

Mastering the Chain of Responsibility Pattern: From Flawed Code to Clean Design

This article explains the Chain of Responsibility design pattern, its typical use cases, shows a problematic nested‑if implementation for a game level system, and demonstrates step‑by‑step refactorings—including a linked‑handler chain and an enum‑based factory—to produce maintainable, extensible Java code.

Chain of ResponsibilityDesign PatternsJava
0 likes · 12 min read
Mastering the Chain of Responsibility Pattern: From Flawed Code to Clean Design
IT Architects Alliance
IT Architects Alliance
Aug 13, 2022 · Backend Development

Understanding VO, DTO, DO, and PO: Concepts and Their Application in Three‑Tier Architecture

This article explains the definitions, differences, and practical usage of View Object (VO), Data Transfer Object (DTO), Domain Object (DO), and Persistent Object (PO) within a three‑layer architecture, offering design guidelines, conversion flows, and considerations for when to merge or separate these objects.

BackendDODesign Patterns
0 likes · 13 min read
Understanding VO, DTO, DO, and PO: Concepts and Their Application in Three‑Tier Architecture
Top Architect
Top Architect
Aug 12, 2022 · Backend Development

Understanding VO, DTO, DO, and PO: Concepts and Best Practices

This article explains the definitions, differences, and appropriate usage scenarios of View Objects (VO), Data Transfer Objects (DTO), Domain Objects (DO), and Persistent Objects (PO) in layered software architecture, offering practical guidance for backend developers on design and implementation choices.

DODesign PatternsJava
0 likes · 14 min read
Understanding VO, DTO, DO, and PO: Concepts and Best Practices
Architect's Guide
Architect's Guide
Aug 3, 2022 · Backend Development

Eight Common Software Architecture Design Patterns and Their Pros and Cons

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

Backend DevelopmentDesign PatternsScalability
0 likes · 20 min read
Eight Common Software Architecture Design Patterns and Their Pros and Cons
Laravel Tech Community
Laravel Tech Community
Aug 1, 2022 · Fundamentals

Understanding Inversion of Control (IoC) with PHP Code Examples

This article explains the Inversion of Control (IoC) principle, contrasts a tightly coupled logging implementation with a dependency‑injected version in PHP, and demonstrates how passing a logger via the constructor decouples classes and follows the open‑closed principle.

Design PatternsInversion of ControlIoC
0 likes · 3 min read
Understanding Inversion of Control (IoC) with PHP Code Examples
DaTaobao Tech
DaTaobao Tech
Jul 11, 2022 · Backend Development

Optimizing System Design for a High‑Traffic Gather‑Order Page with Multi‑Level Caching and Chain‑of‑Responsibility

The author refactors a high‑traffic gather‑order page by introducing a reusable multi‑level cache with update‑key validation, Redis distributed locks and asynchronous refresh, and by restructuring the processing flow using a chain‑of‑responsibility/command pattern, while also handling pagination, weighted sorting, and time‑bound marketing keys to improve reliability, extensibility, and performance.

BackendDesign PatternsSystem Design
0 likes · 29 min read
Optimizing System Design for a High‑Traffic Gather‑Order Page with Multi‑Level Caching and Chain‑of‑Responsibility
Baidu Geek Talk
Baidu Geek Talk
Jul 7, 2022 · Fundamentals

Mastering the Observer Pattern: Real‑World Java and PHP Examples

This article explains the Observer design pattern, outlines its advantages and drawbacks, and demonstrates practical implementations through three real‑world scenarios—weather forecasting, payment processing, and data subscription—providing complete Java and PHP code samples that illustrate subjects, observers, and notification mechanisms.

Design PatternsJavaObserver Pattern
0 likes · 12 min read
Mastering the Observer Pattern: Real‑World Java and PHP Examples
NetEase LeiHuo UX Big Data Technology
NetEase LeiHuo UX Big Data Technology
Jul 3, 2022 · Fundamentals

Why Some Design Patterns Should Be Forgotten When Using Python

This article explains why traditional object‑oriented design patterns such as Strategy, Factory Method, Singleton, and Iterator often become unnecessary or overly complex in Python, illustrating with concise code examples how Python’s first‑class functions, dynamic typing, and built‑in constructs can replace them for clearer, more maintainable solutions.

Design PatternsFactory MethodIterator
0 likes · 12 min read
Why Some Design Patterns Should Be Forgotten When Using Python
DaTaobao Tech
DaTaobao Tech
Jun 27, 2022 · Mobile Development

Applying Design Patterns to Optimize the Scan Feature Architecture

The Taobao Scan feature was refactored by applying the Responsibility‑Chain, State, and Proxy design patterns, separating view and logic layers, introducing a fluent pipeline API, modular state handling, and a global proxy, which together dramatically improved code maintainability, extensibility, testability, and reduced development risk.

Design PatternsMobile DevelopmentProxy Pattern
0 likes · 13 min read
Applying Design Patterns to Optimize the Scan Feature Architecture
Alibaba Terminal Technology
Alibaba Terminal Technology
Jun 23, 2022 · Fundamentals

Why MVC Still Matters: Navigating Architecture Choices for Modern Apps

This article explores the practical challenges of using MVC and related architectural patterns, compares implementations from Microsoft, Apple, and industry experts, discusses controller bloat and view‑model relationships, and proposes solutions such as view‑to‑model factories, multi‑controller designs, and MVVM adoption to improve testability and maintainability.

Design PatternsMVCMVVM
0 likes · 24 min read
Why MVC Still Matters: Navigating Architecture Choices for Modern Apps
VMIC UED
VMIC UED
Jun 21, 2022 · Product Management

Mastering Onboarding: 9 Essential New‑User Guide Patterns for Product Success

This article explains what onboarding (new‑user guide) design is, when it should be applied, its business value, and details nine common design patterns—such as splash pages, animated guides, overlay masks, step‑by‑step flows, tutorial, pop‑ups, bubbles, summon guides, and preset tasks—plus practical advice on selecting the right pattern for different user scenarios.

Design PatternsOnboardingProduct Design
0 likes · 12 min read
Mastering Onboarding: 9 Essential New‑User Guide Patterns for Product Success
Architect's Guide
Architect's Guide
Jun 21, 2022 · Fundamentals

5 Best Software Architectural Patterns You Must Know About

This article introduces the concept of software architectural patterns, explains why they are essential, and details five popular patterns—layered, microkernel, event‑driven, microservices, and space‑based—along with guidance on when and where to apply each.

Design PatternsEvent-drivenSoftware Architecture
0 likes · 17 min read
5 Best Software Architectural Patterns You Must Know About
Architect
Architect
Jun 19, 2022 · Fundamentals

Understanding and Refactoring the Chain of Responsibility Design Pattern in Java

This article explains the Chain of Responsibility design pattern, its typical use cases, shows an anti‑example of overly nested conditional code, and demonstrates step‑by‑step refactoring—including an abstract handler, concrete handlers, and a factory‑based configuration—to achieve cleaner, more maintainable Java implementations.

Chain of ResponsibilityDesign PatternsJava
0 likes · 10 min read
Understanding and Refactoring the Chain of Responsibility Design Pattern in Java
Top Architect
Top Architect
Jun 15, 2022 · Fundamentals

Common Software Architecture Patterns and Their Applications

This article introduces ten common software architecture patterns—layered, client‑server, master‑slave, pipe‑filter, proxy, P2P, event‑bus, MVC, blackboard, and interpreter—explaining their structures, typical use cases, and advantages to help developers choose suitable designs for large‑scale systems.

BackendDesign PatternsMVC
0 likes · 11 min read
Common Software Architecture Patterns and Their Applications
IT Architects Alliance
IT Architects Alliance
Jun 14, 2022 · Backend Development

8 Essential Backend Architecture Patterns Every Engineer Should Master

This article explores eight common backend architecture patterns—from simple single‑database setups to microservices, caching, sharding, elastic scaling, and multi‑region deployments—detailing their design principles, typical use cases, advantages, drawbacks, and practical implementation steps.

Backend ArchitectureDesign PatternsMicroservices
0 likes · 23 min read
8 Essential Backend Architecture Patterns Every Engineer Should Master
macrozheng
macrozheng
Jun 14, 2022 · Backend Development

Refactor Java Business Logic with Strategy, Factory, and Template Method Patterns

This article demonstrates step‑by‑step how to improve existing Java code by applying the Strategy, Factory, and Template Method design patterns, reducing duplicated if‑else branches, adhering to the Open‑Closed and Single‑Responsibility principles, and making the logic more extensible and maintainable.

Design PatternsFactory PatternStrategy Pattern
0 likes · 11 min read
Refactor Java Business Logic with Strategy, Factory, and Template Method Patterns
IT Architects Alliance
IT Architects Alliance
Jun 8, 2022 · Backend Development

Mastering Microservice Patterns: From Decomposition to Resilience

This article provides a comprehensive overview of common microservice patterns and design principles, covering goals such as cost reduction, faster releases, resilience, visibility, and detailing decomposition, integration, database, CQRS, observability, health‑check, and deployment strategies for building robust backend systems.

Blue‑Green deploymentCQRSDesign Patterns
0 likes · 20 min read
Mastering Microservice Patterns: From Decomposition to Resilience
IT Architects Alliance
IT Architects Alliance
Jun 6, 2022 · Backend Development

From Monolith to Event‑Driven Microservices: A Step‑by‑Step Architecture Blueprint

This comprehensive guide explains how to transform a small e‑commerce monolith into a highly scalable, low‑latency, fault‑tolerant event‑driven microservice system by applying layered architecture, SOA, design patterns, API‑gateway strategies, CQRS, event sourcing, and appropriate cloud‑native technologies.

CQRSDesign PatternsEvent Sourcing
0 likes · 22 min read
From Monolith to Event‑Driven Microservices: A Step‑by‑Step Architecture Blueprint
Zhuanzhuan Tech
Zhuanzhuan Tech
Jun 1, 2022 · Backend Development

Design and Implementation of a State Machine for E‑commerce After‑sale Services

This article explains how to design and implement a flexible, strategy‑pattern‑based state machine for e‑commerce after‑sale services, covering action abstraction, synchronous vs asynchronous execution, compensation via delayed MQ, and execution delay techniques to improve reliability and performance.

AsynchronousBackendCompensation
0 likes · 8 min read
Design and Implementation of a State Machine for E‑commerce After‑sale Services
IT Architects Alliance
IT Architects Alliance
May 28, 2022 · Backend Development

Eight Common Software Architecture Design Patterns and Their Pros and Cons

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

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

Eight Common Software Architecture Design Patterns and Their Advantages & Disadvantages

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

BackendDesign PatternsMicroservices
0 likes · 21 min read
Eight Common Software Architecture Design Patterns and Their Advantages & Disadvantages
JavaEdge
JavaEdge
May 24, 2022 · Fundamentals

Why Inheritance Fails: Mastering the Decorator Pattern in Java

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

Decorator PatternDesign PatternsInheritance
0 likes · 15 min read
Why Inheritance Fails: Mastering the Decorator Pattern in Java
Su San Talks Tech
Su San Talks Tech
May 23, 2022 · Backend Development

Unveiling Tomcat’s Architecture: Design Principles, Core Components, and Patterns

Explore Tomcat’s mature architecture, from its connector and container components to class loader hierarchy, revealing how design patterns like composite, observer, and template method shape its modular, extensible system and offering practical insights for mastering Java web server internals.

Backend ArchitectureClass LoaderDesign Patterns
0 likes · 42 min read
Unveiling Tomcat’s Architecture: Design Principles, Core Components, and Patterns
58UXD
58UXD
May 20, 2022 · Fundamentals

Why “Intuitive Design” Is a Myth and How Design Patterns Solve It

This article debunks the overused term “intuitive design,” explains what intuition really means, shows how familiarity—not unconscious reasoning—drives perceived intuitiveness, and demonstrates how applying proven design patterns and emerging AI technologies can create clearer, more efficient user experiences.

AIDesign PatternsIntuitive Design
0 likes · 9 min read
Why “Intuitive Design” Is a Myth and How Design Patterns Solve It
Baidu Geek Talk
Baidu Geek Talk
May 19, 2022 · Fundamentals

Singleton Design Pattern: Implementation and Practical Applications

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

Design PatternsGo ProgrammingJavaScript Programming
0 likes · 16 min read
Singleton Design Pattern: Implementation and Practical Applications
Code Ape Tech Column
Code Ape Tech Column
May 6, 2022 · Backend Development

Understanding Java Service Provider Interface (SPI) and Its Applications

This article explains Java's Service Provider Interface (SPI) mechanism, its purpose, advantages, limitations, differences from APIs, and provides detailed code examples and real-world use cases such as JDBC, ShardingSphere, Spring, and SLF4J to illustrate how SPI enables pluggable, decoupled backend development.

BackendDesign PatternsJava
0 likes · 9 min read
Understanding Java Service Provider Interface (SPI) and Its Applications
Architects Research Society
Architects Research Society
May 2, 2022 · Fundamentals

Designing Information‑Intensive Enterprises: Definitions, Best Practices, and MITRE SE Roles

The article defines information‑intensive enterprises, outlines key concepts and MITRE system engineer expectations, provides contextual examples, and presents best‑practice guidelines such as treating information as capital, ensuring data interoperability, adapting to enterprise cycles, and balancing reusable and disposable solutions.

Design PatternsMITREbest practices
0 likes · 9 min read
Designing Information‑Intensive Enterprises: Definitions, Best Practices, and MITRE SE Roles
Code DAO
Code DAO
Apr 30, 2022 · Backend Development

Building an Extensible Node.js CLI Tool Using the Command Pattern

The article walks through creating a lightweight, extensible Node.js command‑line utility without third‑party libraries, covering the command‑pattern design, implementation of split, upper, and word‑count commands, dynamic command loading, and best practices for modular, maintainable CLI development on Linux.

CLICommand PatternCommander
0 likes · 12 min read
Building an Extensible Node.js CLI Tool Using the Command Pattern
Programmer DD
Programmer DD
Apr 29, 2022 · Fundamentals

Master 23 Classic Design Patterns with Real-World Analogies

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

Design PatternsObject-OrientedSoftware Architecture
0 likes · 19 min read
Master 23 Classic Design Patterns with Real-World Analogies
Sohu Tech Products
Sohu Tech Products
Apr 27, 2022 · Backend Development

Design Patterns Used in the Austin Project: Chain of Responsibility, Template Method, Builder, Strategy, Producer‑Consumer, Singleton, and Proxy

This article explains how the Austin Java backend project applies several classic design patterns—including Chain of Responsibility, Template Method, Builder, Strategy, Producer‑Consumer, Singleton, and Proxy—detailing their benefits, drawbacks, and specific code locations for each pattern.

BuilderChain of ResponsibilityDesign Patterns
0 likes · 6 min read
Design Patterns Used in the Austin Project: Chain of Responsibility, Template Method, Builder, Strategy, Producer‑Consumer, Singleton, and Proxy
21CTO
21CTO
Apr 25, 2022 · Fundamentals

Why Design Patterns Still Matter: Overcoming Real‑World Code‑Quality Pain Points

The article reflects on a developer's sharing session about design patterns, examines why they are often ignored in complex business scenarios, discusses performance and class‑explosion concerns, team and agile constraints, and offers practical steps to sustain code standards and pattern usage.

Agile DevelopmentDesign PatternsSoftware Engineering
0 likes · 9 min read
Why Design Patterns Still Matter: Overcoming Real‑World Code‑Quality Pain Points
Java Backend Technology
Java Backend Technology
Apr 24, 2022 · Backend Development

Master Java Refactoring: DTO Conversions, Lombok, and Design Patterns

This article explores practical Java backend techniques, including IDE selection, domain vs entity naming, DTO conversion strategies with BeanUtils and custom interfaces, validation with JSR‑303, Lombok shortcuts, builder patterns, static constructors, and design‑pattern considerations, offering concrete code examples and refactoring tips for seasoned developers.

Design PatternsJavaLombok
0 likes · 27 min read
Master Java Refactoring: DTO Conversions, Lombok, and Design Patterns
MaGe Linux Operations
MaGe Linux Operations
Apr 22, 2022 · Backend Development

Essential Microservice Patterns: Decomposition, Integration & Observability

This article outlines the key microservice design patterns—including decomposition, integration, event‑driven, saga, and observability techniques—while explaining their goals, principles, and practical considerations such as database per service, CQRS, and cross‑cutting concerns like health checks and circuit breakers.

Backend ArchitectureDesign PatternsMicroservices
0 likes · 19 min read
Essential Microservice Patterns: Decomposition, Integration & Observability
IT Architects Alliance
IT Architects Alliance
Apr 19, 2022 · Cloud Computing

Avoid Serverless Pitfalls: 5 Anti‑Patterns and 6 Design Patterns for Scalable Architectures

This article examines common Serverless anti‑patterns such as monolithic Lambdas, Lambda orchestration, Lambda‑to‑Lambda calls, and event loops, then presents six proven Serverless design patterns—including Command, Messaging, Priority Queue, Fan‑out, and Pipeline‑Filter—to help architects build cost‑effective, highly available, and maintainable cloud applications.

AWS LambdaAnti-PatternsDesign Patterns
0 likes · 13 min read
Avoid Serverless Pitfalls: 5 Anti‑Patterns and 6 Design Patterns for Scalable Architectures
IT Architects Alliance
IT Architects Alliance
Apr 19, 2022 · Fundamentals

Why Design Patterns Fail in Real Projects and How to Fix Them

The article reflects on a team sharing session about design patterns, examining why they often aren’t applied in complex business scenarios, discussing performance, class explosion, team skill gaps, project constraints, and offering practical recommendations to balance code standards with real‑world development pressures.

Agile DevelopmentDesign PatternsSoftware Engineering
0 likes · 11 min read
Why Design Patterns Fail in Real Projects and How to Fix Them
Top Architect
Top Architect
Apr 17, 2022 · Backend Development

Using the Strategy Pattern to Simplify Complex if‑else Logic in Order Processing with Java Spring Boot

This article demonstrates how to replace verbose if‑else statements in an order‑processing system with a clean Strategy Pattern implementation, using custom annotations, a handler context, and Spring Boot components, providing complete code examples and a concise summary of the approach.

Backend DevelopmentDesign PatternsJava
0 likes · 10 min read
Using the Strategy Pattern to Simplify Complex if‑else Logic in Order Processing with Java Spring Boot
Architects Research Society
Architects Research Society
Apr 8, 2022 · Backend Development

Top Microservices Design Patterns for Building Applications

This article explains microservices fundamentals, outlines key design principles, and details ten essential design patterns—including Aggregator, API Gateway, Chain of Responsibility, Asynchronous Messaging, Shared Database, Event Sourcing, Branch, CQRS, Circuit Breaker, and Decomposition—to help developers build scalable, resilient applications.

Backend ArchitectureCQRSDesign Patterns
0 likes · 15 min read
Top Microservices Design Patterns for Building Applications
政采云技术
政采云技术
Apr 7, 2022 · Fundamentals

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

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

DDDDesign PatternsSoftware Architecture
0 likes · 15 min read
Applying Architectural Patterns to Monolith Splitting and System Scalability: Lessons from "Software Architecture with Patterns"
IT Architects Alliance
IT Architects Alliance
Mar 30, 2022 · Operations

30 Essential Architecture Patterns for Scalable and Resilient Systems

This article systematically presents thirty architectural patterns—covering management, monitoring, performance, scalability, data handling, design, messaging, resilience, and security—to help engineers design, implement, and operate robust, high‑performance distributed systems.

Design PatternsOperationsScalability
0 likes · 33 min read
30 Essential Architecture Patterns for Scalable and Resilient Systems
Architects Research Society
Architects Research Society
Mar 29, 2022 · Backend Development

Designing Microservice Architecture with Patterns, Principles, and Best Practices

This comprehensive guide teaches how to design scalable, highly available microservice architectures by applying design patterns, principles, and best practices, covering the evolution from monolithic to event‑driven systems, communication strategies, data management techniques, and technology choices such as API gateways, BFF, CQRS, and Kafka.

CQRSDesign PatternsEvent-driven
0 likes · 23 min read
Designing Microservice Architecture with Patterns, Principles, and Best Practices
Top Architect
Top Architect
Mar 26, 2022 · Fundamentals

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

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

Design PatternsObject-OrientedSoftware Architecture
0 likes · 19 min read
A Top Architect’s Humorous Guide to 23 Classic Design Patterns
Yang Money Pot Technology Team
Yang Money Pot Technology Team
Mar 24, 2022 · Backend Development

Design and Implementation of a Flexible Membership Rights System

This article presents a comprehensive design and implementation of a flexible membership rights system, covering business goals, a rights configuration pool, user rights acquisition and execution flows, template‑method pattern, distributed locking, and asynchronous job handling to achieve smooth product upgrades and reliable rights management.

Backend ArchitectureDesign PatternsJava
0 likes · 18 min read
Design and Implementation of a Flexible Membership Rights System
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Mar 22, 2022 · Cloud Computing

Avoid Serverless Pitfalls: Key Anti‑Patterns and Proven Design Patterns

This article examines common serverless anti‑patterns such as monolithic Lambdas, orchestration misuse, Lambda‑to‑Lambda calls, and event loops, and presents practical design patterns—including Command, Messaging, Priority Queue, Fan‑out, and Pipe‑Filter—to help architects build scalable, maintainable, and cost‑effective cloud applications.

AWSAnti-PatternsDesign Patterns
0 likes · 14 min read
Avoid Serverless Pitfalls: Key Anti‑Patterns and Proven Design Patterns
Open Source Linux
Open Source Linux
Mar 22, 2022 · Fundamentals

30 Essential Architecture Principles Every Engineer Should Follow

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

Design PatternsDistributed SystemsSoftware Architecture
0 likes · 11 min read
30 Essential Architecture Principles Every Engineer Should Follow
IT Architects Alliance
IT Architects Alliance
Mar 17, 2022 · Backend Development

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

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

Design PatternsDevOpsDistributed Systems
0 likes · 23 min read
Introduction to Microservice Architecture: Concepts, Evolution, Comparison with Monolithic, Design Patterns, Advantages and Disadvantages
IT Architects Alliance
IT Architects Alliance
Mar 15, 2022 · Backend Development

Designing a Scalable Order State Machine for Complex Transaction Systems

This article presents a comprehensive design of an order state machine for transaction systems, addressing multi‑state, multi‑type, multi‑scenario complexities through vertical business isolation, horizontal logic reuse, state pattern, template methods, validators, plugins, and consistency mechanisms between database updates and messaging.

Design PatternsMessagingorder processing
0 likes · 30 min read
Designing a Scalable Order State Machine for Complex Transaction Systems
Java Captain
Java Captain
Mar 15, 2022 · Backend Development

Why Enterprise Java Projects Turn Into Over‑Engineered Monsters

The article sarcastically critiques the over‑engineered nature of enterprise Java projects, illustrating how simple tasks become tangled in excessive classes, interfaces, factories, dependency‑injection frameworks, XML configurations, massive JARs, and IDE bloat, ultimately leading to deployment failures due to environment mismatches.

Design PatternsJavadependency-injection
0 likes · 5 min read
Why Enterprise Java Projects Turn Into Over‑Engineered Monsters
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Mar 14, 2022 · Backend Development

How to Build a Scalable Multi‑State Order Processing Engine with State‑Machine Patterns

This article explains how to design a robust order‑status flow engine for transaction systems by applying state‑machine and strategy patterns, separating business logic vertically and horizontally, using annotations, context objects, plug‑in extensions, and ensuring scalability, maintainability, and message‑database consistency.

Design Patternsorder processingstate machine
0 likes · 32 min read
How to Build a Scalable Multi‑State Order Processing Engine with State‑Machine Patterns
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Mar 12, 2022 · Backend Development

30 Essential Architecture Patterns for Scalable Backend Systems

This article presents a comprehensive catalog of thirty architectural patterns—including ambassador, anti‑corruption, gateway aggregation, CQRS, event sourcing, sharding, and circuit breaker—that help developers design, manage, and scale modern backend services efficiently and reliably.

Design PatternsMicroservicesScalability
0 likes · 37 min read
30 Essential Architecture Patterns for Scalable Backend Systems
Python Programming Learning Circle
Python Programming Learning Circle
Mar 11, 2022 · Fundamentals

Refactoring a Python Employee Management System to Eliminate Code Smells

This article explains common Python code smells in an employee‑management example, demonstrates why practices such as using raw strings for roles, duplicated search methods, excessive isinstance checks, and vague boolean flags are problematic, and provides a step‑by‑step refactor using Enums, abstract base classes, list comprehensions, custom exceptions, and clearer method separation.

Abstract Base ClassDesign PatternsPython
0 likes · 14 min read
Refactoring a Python Employee Management System to Eliminate Code Smells
Meituan Technology Team
Meituan Technology Team
Mar 10, 2022 · Backend Development

Design Patterns in Practice: Strategy, State, Observer, Builder, and Decorator Patterns

Through a teacher‑student dialogue, the article demonstrates how the Strategy (with Adapter), State, Observer, Builder, and Decorator patterns can be applied to reward distribution, task management, and activity modeling, illustrating how these patterns decouple logic, enhance extensibility, and improve code maintainability.

Builder PatternDecorator PatternDesign Patterns
0 likes · 24 min read
Design Patterns in Practice: Strategy, State, Observer, Builder, and Decorator Patterns
Code Ape Tech Column
Code Ape Tech Column
Mar 9, 2022 · Backend Development

Eliminating Code Duplication in Business Logic with Design Patterns, Annotations, Reflection, and Bean Mapping

This article explains how to reduce repetitive business‑level Java code by applying the Template Method and Factory patterns, leveraging custom annotations with reflection, and using bean‑mapping utilities, thereby improving maintainability, extensibility, and overall code quality.

Code RefactoringDesign PatternsJava
0 likes · 20 min read
Eliminating Code Duplication in Business Logic with Design Patterns, Annotations, Reflection, and Bean Mapping
Java High-Performance Architecture
Java High-Performance Architecture
Mar 1, 2022 · Backend Development

Unlocking Spring: Core Principles, Design Patterns, and IoC Explained

This comprehensive guide walks through Spring's lightweight Java framework, covering its core principles, key features, advantages and drawbacks, the design patterns it employs, core modules, IoC container mechanics, bean scopes, lifecycle, dependency injection techniques, and AOP fundamentals, all illustrated with diagrams and code snippets.

Design PatternsIoCJava
0 likes · 48 min read
Unlocking Spring: Core Principles, Design Patterns, and IoC Explained
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Feb 27, 2022 · Fundamentals

Comprehensive Overview of 23 Java Design Patterns

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

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

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

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

CQRSClean ArchitectureDesign Patterns
0 likes · 22 min read
Why Clean Architecture, DDD, and CQRS Together Create Scalable, Testable Systems
Java Interview Crash Guide
Java Interview Crash Guide
Feb 25, 2022 · Backend Development

How to Refactor Complex if‑else Logic in Java: 5 Practical Techniques

This article explains why deeply nested if‑else statements hurt readability and maintenance, then presents five practical techniques—including method extraction, early returns, enums, functional interfaces, and design patterns—along with complete Java code examples to transform messy business logic into clean, modular code.

Design PatternsJavacode readability
0 likes · 19 min read
How to Refactor Complex if‑else Logic in Java: 5 Practical Techniques
IT Architects Alliance
IT Architects Alliance
Feb 18, 2022 · Fundamentals

Design Patterns as Code Standards: Benefits, Challenges, and Practical Guidance

This article examines design patterns as a form of code standard, discussing their definition, relevance in everyday business development, common pain points such as performance overhead, class explosion, team skill gaps, project constraints, and offers practical recommendations for balancing best practices with real‑world constraints.

Design PatternsSoftware Engineeringcode standards
0 likes · 11 min read
Design Patterns as Code Standards: Benefits, Challenges, and Practical Guidance
NiuNiu MaTe
NiuNiu MaTe
Feb 10, 2022 · Fundamentals

Master the Proxy Pattern with a Fun Story and Go Example

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

Design PatternsGolangProxy Pattern
0 likes · 4 min read
Master the Proxy Pattern with a Fun Story and Go Example
Code Ape Tech Column
Code Ape Tech Column
Feb 8, 2022 · Backend Development

Refactoring Long if...else Chains in Java Using Design Patterns and Spring

This article explains why lengthy if...else statements in Java payment services violate the Open‑Closed and Single‑Responsibility principles and demonstrates several refactoring techniques—including annotations, dynamic bean naming, template methods, strategy‑factory, and chain‑of‑responsibility patterns—using Spring to eliminate the conditional logic.

Design PatternsJavaStrategy Pattern
0 likes · 15 min read
Refactoring Long if...else Chains in Java Using Design Patterns and Spring
Architecture Digest
Architecture Digest
Feb 4, 2022 · Fundamentals

Design Patterns and Code Standards: Benefits, Pain Points, and Practical Guidance

This article examines what design patterns really are, why they are considered a form of intermediate‑level code standards, the performance and class‑explosion concerns in business development, and offers balanced recommendations for maintaining code quality and applying patterns effectively in real‑world projects.

Design PatternsOOPSoftware Engineering
0 likes · 11 min read
Design Patterns and Code Standards: Benefits, Pain Points, and Practical Guidance
Java Captain
Java Captain
Jan 18, 2022 · Backend Development

Best Practices for Java Backend Development: Configuration, Lombok, Modular Code, Exception Handling, and More

This article shares a collection of practical Java backend development habits, covering configuration with @ConfigurationProperties, Lombok's @RequiredArgsConstructor, code modularization, exception throwing, reducing DB queries, avoiding null returns, simplifying if‑else, keeping controllers thin, IDE tips, source code reading, design patterns, and fundamental coding techniques.

BackendConfigurationDesign Patterns
0 likes · 6 min read
Best Practices for Java Backend Development: Configuration, Lombok, Modular Code, Exception Handling, and More
Top Architect
Top Architect
Dec 31, 2021 · Fundamentals

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

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

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

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

This article explains seven widely used software architecture patterns—layered, multi‑layer, pipe‑filter, client‑server, MVC, event‑driven, and microservices—detailing their contexts, problems they solve, core concepts, advantages, drawbacks, and typical use cases for building robust systems.

Design PatternsMVCMicroservices
0 likes · 10 min read
Common Software Architecture Patterns: Layered, Multi‑Layer, Pipe‑Filter, Client‑Server, MVC, Event‑Driven, and Microservices
Alibaba Cloud Developer
Alibaba Cloud Developer
Dec 7, 2021 · Backend Development

How to Standardize Business Architecture: A Layered Design Blueprint

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

Backend DevelopmentDesign PatternsSoftware Architecture
0 likes · 25 min read
How to Standardize Business Architecture: A Layered Design Blueprint
IT Architects Alliance
IT Architects Alliance
Dec 2, 2021 · Fundamentals

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

This article explains seven fundamental software architecture patterns—layered, multi‑layer, pipe‑filter, client‑server, MVC, event‑driven, and microservices—detailing their contexts, problems they solve, typical structures, strengths, weaknesses, and appropriate use cases for developers and architects.

Design PatternsMVCMicroservices
0 likes · 9 min read
Common Software Architecture Patterns: Layered, Multi‑Layer, Pipe‑Filter, Client‑Server, MVC, Event‑Driven, and Microservices
Architects' Tech Alliance
Architects' Tech Alliance
Nov 29, 2021 · Fundamentals

Common Software Architecture Patterns and Their Characteristics

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

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

Understanding Software Architecture: From Basic Concepts to the COLA Framework

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

COLA frameworkCQRSDesign Patterns
0 likes · 12 min read
Understanding Software Architecture: From Basic Concepts to the COLA Framework
IT Architects Alliance
IT Architects Alliance
Nov 24, 2021 · Fundamentals

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

This article explains the definition and purpose of software architecture, outlines various architectural classifications such as business, application, distributed, data, physical, and operational architectures, and introduces typical patterns like layered, CQRS, hexagonal, and onion architectures, culminating in a detailed overview of Alibaba's COLA application architecture and its design principles.

COLACQRSDesign Patterns
0 likes · 12 min read
Understanding Software Architecture: Concepts, Classifications, and the COLA Application Architecture
Selected Java Interview Questions
Selected Java Interview Questions
Nov 21, 2021 · Fundamentals

Understanding Static and Dynamic Proxy Patterns in Java

This article explains the concept of proxy patterns, compares static and dynamic proxies in Java, provides detailed code examples for each, and discusses their advantages, disadvantages, and implementation steps, helping developers choose the appropriate proxy technique for their projects.

Design PatternsDynamic ProxyJava
0 likes · 15 min read
Understanding Static and Dynamic Proxy Patterns in Java
Selected Java Interview Questions
Selected Java Interview Questions
Nov 20, 2021 · Backend Development

Design Pattern Summary in the Spring Framework

This article provides a comprehensive overview of the design patterns used in Spring, including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method, with explanations of their implementation, principles, and practical code examples.

BeanFactoryDesign PatternsFactory Method
0 likes · 13 min read
Design Pattern Summary in the Spring Framework
Code Ape Tech Column
Code Ape Tech Column
Nov 13, 2021 · Backend Development

Spring Framework Interview Questions and Answers Overview

This article compiles a comprehensive set of Spring interview questions covering design patterns, core modules, IoC, DI, AOP, proxy mechanisms, bean lifecycle, circular dependency resolution, transaction isolation and propagation, as well as Spring Boot auto‑configuration principles, providing concise explanations for each topic.

Design PatternsIoCJava
0 likes · 16 min read
Spring Framework Interview Questions and Answers Overview
Code Ape Tech Column
Code Ape Tech Column
Nov 12, 2021 · Fundamentals

Common Design Patterns in Java: Strategy, Chain of Responsibility, Template Method, Observer, Factory, and Singleton

This article introduces several classic Java design patterns—including Strategy, Chain of Responsibility, Template Method, Observer, Factory, and Singleton—explaining their business scenarios, core definitions, and providing complete code examples to demonstrate how each pattern improves code maintainability, extensibility, and adherence to SOLID principles.

Design PatternsFactoryJava
0 likes · 22 min read
Common Design Patterns in Java: Strategy, Chain of Responsibility, Template Method, Observer, Factory, and Singleton
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Nov 7, 2021 · Backend Development

Comprehensive Overview and Source Code Analysis of the MyBatis Persistence Framework

This article provides a detailed introduction to MyBatis, covering its relationship with JDBC, core components, execution flow, configuration, design patterns, caching strategies, plugin mechanisms, logging options, dynamic SQL features, and includes complete Java and XML code examples to illustrate practical usage.

BackendDesign PatternsJava
0 likes · 19 min read
Comprehensive Overview and Source Code Analysis of the MyBatis Persistence Framework
Java High-Performance Architecture
Java High-Performance Architecture
Nov 7, 2021 · Backend Development

Designing a Scalable Shopping Cart Service with Go and Redis: Architecture & Patterns

This article explains how to design a robust e‑commerce shopping‑cart service by separating business, system, and technical architectures, applying DDD, strategy and chain‑of‑responsibility patterns, and choosing Redis data structures for high‑performance storage.

Backend ArchitectureDesign PatternsDomain-Driven Design
0 likes · 20 min read
Designing a Scalable Shopping Cart Service with Go and Redis: Architecture & Patterns
Su San Talks Tech
Su San Talks Tech
Nov 6, 2021 · Fundamentals

Unlock Cleaner Code: Master 6 Essential Design Patterns for Java Projects

This article introduces six classic design patterns—Strategy, Chain of Responsibility, Template Method, Observer, Factory, and Singleton—explaining their real‑world business scenarios, core principles, and providing clean Java implementations to help developers write more maintainable and extensible code.

Chain of ResponsibilityDesign PatternsFactory Pattern
0 likes · 25 min read
Unlock Cleaner Code: Master 6 Essential Design Patterns for Java Projects
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 27, 2021 · Fundamentals

Common Design Patterns in Daily Development: Strategy, Chain of Responsibility, Template Method, Observer, Factory, and Singleton

This article introduces several classic design patterns—Strategy, Chain of Responsibility, Template Method, Observer, Factory, and Singleton—explaining their business scenarios, core definitions, Java implementations, and how to apply them in real-world projects to improve code maintainability and extensibility.

Chain of ResponsibilityDesign PatternsFactory
0 likes · 27 min read
Common Design Patterns in Daily Development: Strategy, Chain of Responsibility, Template Method, Observer, Factory, and Singleton
Selected Java Interview Questions
Selected Java Interview Questions
Oct 25, 2021 · Fundamentals

Understanding Factory and Strategy Design Patterns in Java

This article explains the differences and similarities between the Factory and Strategy design patterns in Java, provides concrete code examples for each, and discusses how the Strategy pattern can offer more flexible behavior composition compared to the traditional Factory approach.

Design PatternsFactory PatternJava
0 likes · 7 min read
Understanding Factory and Strategy Design Patterns in Java
21CTO
21CTO
Oct 12, 2021 · Fundamentals

Good vs Bad Architecture: Principles, Patterns, and Practices for Scalable Systems

This article explains how good software architecture enables easy evolution, fault tolerance, and low maintenance, while bad architecture leads to complexity and brittleness, and it outlines key principles, design styles, and practical techniques such as domain‑centric, microservices, event‑driven, and CQRS to build robust, adaptable systems.

Design PatternsDomain-Driven DesignMicroservices
0 likes · 14 min read
Good vs Bad Architecture: Principles, Patterns, and Practices for Scalable Systems
IT Architects Alliance
IT Architects Alliance
Oct 10, 2021 · Industry Insights

10 Essential Software Architecture Patterns Every Engineer Should Know

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

Architecture PatternsDesign PatternsSoftware Architecture
0 likes · 9 min read
10 Essential Software Architecture Patterns Every Engineer Should Know