BestHub
Sign in
Tagged articles
853 articles
Page 6 of 9
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 DesignSoftware Architecture
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
IT Architects Alliance
IT Architects Alliance
Oct 10, 2021 · Fundamentals

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

This article explains the definition and necessity of software architecture, outlines various architectural categories such as business, application, distributed, data, physical, and operations architectures, describes layered, CQRS, hexagonal and onion models, and introduces the COLA framework with its design principles and extension mechanisms.

COLACQRSDesign Patterns
0 likes · 12 min read
Understanding Software Architecture: Concepts, Classifications, and the COLA Application Architecture
IT Architects Alliance
IT Architects Alliance
Sep 29, 2021 · Industry Insights

Why Design Patterns Often Fail in Real Projects and How to Make Them Work

The article analyzes common obstacles that prevent effective use of design patterns and code standards in everyday software development—such as performance overhead, class explosion, team skill gaps, project constraints, agile timelines, and staff turnover—and offers practical strategies to balance quality with productivity.

Agile DevelopmentBest PracticesDesign Patterns
0 likes · 10 min read
Why Design Patterns Often Fail in Real Projects and How to Make Them Work
Wukong Talks Architecture
Wukong Talks Architecture
Sep 29, 2021 · Fundamentals

Understanding the Observer Pattern through a Talk‑Show Analogy and Java Implementation

This article explains the Observer design pattern by comparing it to a talk‑show scenario, then details its Java implementation—including Observable and Observer classes, notification mechanisms, code examples, common pitfalls, asynchronous extensions, and practical e‑commerce applications—in a clear, step‑by‑step manner.

Design PatternsJavaObserver Pattern
0 likes · 10 min read
Understanding the Observer Pattern through a Talk‑Show Analogy and Java Implementation
Java Architect Essentials
Java Architect Essentials
Sep 28, 2021 · R&D Management

How to Upgrade from Senior Developer to Software Architect: Requirements, Skills, and Daily Work

This article explains the common misconceptions about software architects, outlines the essential technical and soft‑skill requirements for senior developers to become architects, describes practical upgrade paths, and details the typical responsibilities and daily activities of an architect.

Design PatternsDistributed SystemsSoftware Architecture
0 likes · 13 min read
How to Upgrade from Senior Developer to Software Architect: Requirements, Skills, and Daily Work
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 23, 2021 · Fundamentals

Builder Pattern in Java: Implementation, Usage, and Comparison with Simple Factory

This article explains the Builder design pattern in Java with complete code examples—including Product, abstract Builder, ConcreteBuilder, Director, and client code—demonstrates the output, compares it to the simple factory pattern, and briefly shows how ASM bytecode manipulation can generate similar constructs.

Design PatternsJavaSoftware Architecture
0 likes · 6 min read
Builder Pattern in Java: Implementation, Usage, and Comparison with Simple Factory
21CTO
21CTO
Sep 21, 2021 · Fundamentals

7 Proven Ways to Boost Your Code‑Reading Skills

Discover seven practical techniques—from running the code and grasping high‑level architecture to leveraging tools, mastering language conventions, studying design patterns, participating in code reviews, and performing temporary refactoring—that dramatically improve a developer's ability to read and understand source code.

Code ReviewDesign Patternscode reading
0 likes · 7 min read
7 Proven Ways to Boost Your Code‑Reading Skills
Programmer DD
Programmer DD
Sep 16, 2021 · Backend Development

Mastering Cache Strategies: Types, Hit Rates, Eviction & Design Patterns

Explore comprehensive caching concepts—including client, server, and CDN caches—along with hit rate metrics, eviction methods, popular strategies like FIFO, LRU, LFU, and design patterns such as Cache‑Aside, Read/Write‑Through, and Write‑Behind, plus essential testing considerations for robust application performance.

Backend PerformanceCache EvictionCache Hit Rate
0 likes · 8 min read
Mastering Cache Strategies: Types, Hit Rates, Eviction & Design Patterns
macrozheng
macrozheng
Sep 13, 2021 · Fundamentals

Master the 7 Essential SOLID Principles for Clean, Maintainable Code

This article introduces the classic GOF design patterns and then explains seven core software design principles—Single Responsibility, Open/Closed, Liskov Substitution, Dependency Inversion, Interface Segregation, Composition over Inheritance, and the Law of Demeter—showing how they improve code reliability, readability, and extensibility.

Design PatternsObject-OrientedSOLID
0 likes · 11 min read
Master the 7 Essential SOLID Principles for Clean, Maintainable Code
ELab Team
ELab Team
Sep 10, 2021 · Frontend Development

Mastering the State Pattern: Light Switch to Finite State Machines in JS

This article explains why using if‑else for state handling violates the Open‑Closed Principle, introduces the State design pattern with a light‑switch example, demonstrates its implementation in JavaScript (including class‑based and functional FSM libraries), and compares it to the Strategy pattern.

Design PatternsFinite State MachineFrontend Development
0 likes · 17 min read
Mastering the State Pattern: Light Switch to Finite State Machines in JS
Taobao Frontend Technology
Taobao Frontend Technology
Sep 10, 2021 · Frontend Development

Mastering Multi‑Platform Front‑End with the Strategy Pattern

This article walks through a real‑world multi‑app scenario, breaks down the core challenges, compares several implementation approaches—including naive if‑else, SDK abstraction, and the Strategy design pattern—and reflects on engineering trade‑offs to help front‑end engineers write cleaner, more maintainable code.

Design PatternsFrontend ArchitectureStrategy Pattern
0 likes · 11 min read
Mastering Multi‑Platform Front‑End with the Strategy Pattern
macrozheng
macrozheng
Aug 31, 2021 · Backend Development

Master Java Class Naming: 10 Common Patterns and Real‑World Examples

This article explores the essential naming conventions used in Java projects, presenting ten common class‑name patterns—such as Manager, Factory, Context, and Builder—illustrated with real open‑source examples and code snippets to help developers write clearer, more maintainable code.

Design PatternsJavaclass naming
0 likes · 21 min read
Master Java Class Naming: 10 Common Patterns and Real‑World Examples
Laravel Tech Community
Laravel Tech Community
Aug 25, 2021 · Backend Development

Implementing Dependency Injection in PHP Using Reflection

This article explains how to build a simple PHP IoC container with reflection to automatically resolve constructor and method dependencies, demonstrates its use with example classes A, B, and C, and shows how to invoke methods with injected parameters.

Backend DevelopmentDesign PatternsPHP
0 likes · 5 min read
Implementing Dependency Injection in PHP Using Reflection
Alibaba Cloud Developer
Alibaba Cloud Developer
Aug 19, 2021 · Fundamentals

Why Bad Code Happens and How to Fix It: From Naming to Design Principles

This article analyzes the root causes of low‑quality code—such as poor naming, tangled structure, and weak scalability—then presents practical ways to improve code quality through domain modeling, SOLID design principles, and design patterns, illustrated with real‑world case studies.

Design PatternsDesign PrinciplesDomain Modeling
0 likes · 16 min read
Why Bad Code Happens and How to Fix It: From Naming to Design Principles
Java Backend Technology
Java Backend Technology
Aug 19, 2021 · Backend Development

Eliminate if‑else with Annotation‑Driven Strategy Pattern in Spring Boot

This article explains how to replace bulky if‑else statements with a clean, annotation‑based Strategy pattern in a Spring Boot application, covering interface definition, custom annotations, dynamic proxy handling, map injection, and the crucial hashCode/equals overrides for reliable handler lookup.

Design PatternsJavaStrategy Pattern
0 likes · 14 min read
Eliminate if‑else with Annotation‑Driven Strategy Pattern in Spring Boot
21CTO
21CTO
Aug 2, 2021 · Fundamentals

Why Most Projects Fail: 4 Code‑Quality Pitfalls and Proven Fixes

The article examines why many software projects become “rotten” by analyzing four common code‑quality problems—over‑large components, low cohesion, tangled high‑level/low‑level logic, and rampant if‑else—then offers concrete refactoring patterns, design‑pattern applications, and practical tooling to restore maintainability and project success.

Design PatternsSoftware Architecturecode quality
0 likes · 38 min read
Why Most Projects Fail: 4 Code‑Quality Pitfalls and Proven Fixes
IT Architects Alliance
IT Architects Alliance
Jul 31, 2021 · Fundamentals

Common Software Architecture Patterns and Their Considerations

This article introduces several fundamental software architecture patterns—including layered, event‑driven (mediator and broker), microkernel, microservices, and space‑based architectures—explaining their structures, key concepts, real‑world examples, and the trade‑offs developers should evaluate when choosing a pattern.

Design PatternsEvent-drivenLayered Architecture
0 likes · 14 min read
Common Software Architecture Patterns and Their Considerations
IT Architects Alliance
IT Architects Alliance
Jul 29, 2021 · Fundamentals

What Are the 7 Core Software Architecture Patterns and When to Use Them?

This article explains seven common software architecture patterns—layered, multi‑layer, pipe‑filter, client‑server, MVC, event‑driven, and microservices—detailing their context, the problems they address, typical solutions, drawbacks, and suitable application scenarios.

Design PatternsEvent-drivenLayered Architecture
0 likes · 13 min read
What Are the 7 Core Software Architecture Patterns and When to Use Them?
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 28, 2021 · Fundamentals

What Are the 7 Core Software Architecture Patterns and When to Use Them?

This article explains software architecture patterns as reusable solutions to common design problems, introduces the seven major patterns—layered, multi‑layer, pipe‑filter, client‑server, MVC, event‑driven, and microservices—detailing their context, challenges, solutions, drawbacks, and typical use cases.

Design PatternsLayered ArchitectureMVC
0 likes · 11 min read
What Are the 7 Core Software Architecture Patterns and When to Use Them?
Senior Brother's Insights
Senior Brother's Insights
Jul 27, 2021 · Fundamentals

Mastering the Proxy Pattern: A Hands‑On Guide with Nacos Client

This article explains the proxy design pattern, demonstrates its static implementation with Java code, and shows how Nacos Client leverages a custom proxy delegate to switch between HTTP and gRPC protocols, highlighting structural roles, practical usage, and differences from the decorator pattern.

Backend DevelopmentDesign PatternsJava
0 likes · 12 min read
Mastering the Proxy Pattern: A Hands‑On Guide with Nacos Client
IT Architects Alliance
IT Architects Alliance
Jul 24, 2021 · Fundamentals

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

This article explains what software architecture is, why it is needed, the responsibilities of architects, various classification types such as business, application, distributed, data, physical and operations, and introduces typical architectural styles like layered, CQRS, hexagonal, onion, and the open‑source COLA framework.

COLACQRSDesign Patterns
0 likes · 13 min read
Understanding Software Architecture: Concepts, Classifications, and the COLA Framework
Top Architect
Top Architect
Jul 23, 2021 · Backend Development

Design Patterns in the Spring Framework: A Comprehensive Overview

This article provides a detailed overview of how the Spring framework implements classic design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—illustrated with code snippets and explanations of their roles in Spring's dependency injection and bean lifecycle management.

Design PatternsJavaSingleton
0 likes · 14 min read
Design Patterns in the Spring Framework: A Comprehensive Overview
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 23, 2021 · Fundamentals

Why Architecture Matters: From Basics to the COLA Framework

This article explains what software architecture is, why it is essential, the responsibilities of architects, various architecture classifications, common patterns such as layered, CQRS, hexagonal and onion designs, and introduces the open‑source COLA framework with its layered structure, extension mechanisms, and normative guidelines.

COLA frameworkDesign PatternsHexagonal Architecture
0 likes · 13 min read
Why Architecture Matters: From Basics to the COLA Framework
Java Backend Technology
Java Backend Technology
Jul 22, 2021 · Fundamentals

Master Java Enums: From Basics to Advanced Design Patterns

This article explains Java enums, their advantages over constants, demonstrates custom methods, comparisons, switch usage, advanced features like EnumSet, EnumMap, JSON serialization, and shows how enums can implement design patterns such as Singleton and Strategy with complete code examples.

Design PatternsEnumEnumMap
0 likes · 14 min read
Master Java Enums: From Basics to Advanced Design Patterns
Senior Brother's Insights
Senior Brother's Insights
Jul 18, 2021 · Backend Development

How Nacos Client Implements the Simple Factory Pattern

This article explains the simple factory pattern, compares its standard definition with Nacos's implementation, and walks through concrete Java examples showing how NacosFactory, NamingFactory, and related services create instances in the Nacos client.

Design PatternsFactory MethodJava
0 likes · 9 min read
How Nacos Client Implements the Simple Factory Pattern
21CTO
21CTO
Jul 9, 2021 · Backend Development

Top Microservice Design Patterns: Database per Service, Event Sourcing, CQRS, Saga

This article reviews essential microservice design patterns—including Database per Service, Event Sourcing, CQRS, Saga, Backend‑for‑Frontend, API Gateway, Strangler, Circuit Breaker, Externalized Configuration, and Consumer‑Driven Contract Testing—explaining their advantages, drawbacks, when to apply them, and common technology implementations.

CQRSDesign PatternsEvent Sourcing
0 likes · 28 min read
Top Microservice Design Patterns: Database per Service, Event Sourcing, CQRS, Saga
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 8, 2021 · Backend Development

Mastering Microservice Architecture: 10 Essential Design Patterns Explained

This comprehensive guide explores microservice architecture—from its historical roots and core characteristics to ten vital design patterns such as database per service, event sourcing, CQRS, Saga, BFF, API gateway, Strangler, circuit breaker, externalized configuration, and consumer‑driven contract testing—detailing their advantages, drawbacks, and practical usage scenarios.

Backend ArchitectureCQRSDesign Patterns
0 likes · 28 min read
Mastering Microservice Architecture: 10 Essential Design Patterns Explained
JavaEdge
JavaEdge
Jul 6, 2021 · Fundamentals

Mastering the Decorator Pattern in Java: Dynamic Object Extension Explained

Learn how the Decorator pattern lets you dynamically add responsibilities to objects in Java without subclass explosion, covering its definition, core components, concrete examples with scroll‑bar decorators, advantages over inheritance, drawbacks, suitable scenarios, and best‑practice guidelines for flexible, maintainable code.

Code ExampleDecorator PatternDesign Patterns
0 likes · 7 min read
Mastering the Decorator Pattern in Java: Dynamic Object Extension Explained
Architecture Digest
Architecture Digest
Jun 29, 2021 · Backend Development

Microservice Architecture Design Patterns

This article introduces key microservice architecture design patterns—including Database per Service, Event Sourcing, CQRS, Saga, BFF, API Gateway, Strangler, Circuit Breaker, Externalized Configuration, and Consumer‑Driven Contract Testing—explaining their advantages, drawbacks, appropriate usage scenarios, and example technologies to guide scalable, resilient system design.

Backend ArchitectureDesign PatternsDistributed Systems
0 likes · 27 min read
Microservice Architecture Design Patterns
IT Architects Alliance
IT Architects Alliance
Jun 23, 2021 · Fundamentals

10 Essential Software Architecture Patterns Every Enterprise Engineer Should Know

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

Architecture PatternsDesign PatternsSoftware Architecture
0 likes · 10 min read
10 Essential Software Architecture Patterns Every Enterprise Engineer Should Know
IT Architects Alliance
IT Architects Alliance
Jun 16, 2021 · Backend Development

Why Microservices Matter: From Basics to Real‑World Implementation

This article provides a comprehensive overview of microservice architecture, covering its definition, history, comparison with monolithic and SOA approaches, core characteristics, practical implementation steps, common design patterns, advantages, challenges, and the mindset shift required for successful adoption.

Design PatternsDevOpsapi-gateway
0 likes · 21 min read
Why Microservices Matter: From Basics to Real‑World Implementation
Top Architect
Top Architect
Jun 13, 2021 · Backend Development

Implementing AOP in a Custom Spring‑like Framework

This article explains the principles and step‑by‑step implementation of Aspect‑Oriented Programming (AOP) in a lightweight Spring‑style container, covering core concepts, advice and pointcut design, weaving mechanisms, proxy creation, observer integration, and practical code examples.

AOPAspect Oriented ProgrammingDesign Patterns
0 likes · 16 min read
Implementing AOP in a Custom Spring‑like Framework
Programmer DD
Programmer DD
Jun 11, 2021 · Fundamentals

Why Learning Swing Still Boosts Your Programming Fundamentals

The author reflects on how studying the legacy Java Swing library and related university courses, despite being outdated, reinforced core programming thinking, design‑pattern knowledge, and problem‑solving skills that remain valuable throughout a software engineering career.

Design PatternsJavaSwing
0 likes · 9 min read
Why Learning Swing Still Boosts Your Programming Fundamentals
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 9, 2021 · Fundamentals

Why Boilerplate Code Still Matters: Tips for Faster, Cleaner Java Development

This article explores the concept of boilerplate code, its historical analogy to movable‑type printing, the benefits of reusing standard code snippets, practical ways to write, reduce, and optimise boilerplate in Java—including utility classes, enums, model definitions, collection constants, array constants, and complex condition handling.

Best PracticesBoilerplate CodeCode Optimization
0 likes · 27 min read
Why Boilerplate Code Still Matters: Tips for Faster, Cleaner Java Development
IT Architects Alliance
IT Architects Alliance
Jun 8, 2021 · Fundamentals

23 Design Patterns Explained with Humorous Real‑World Analogies

This article classifies 23 classic design patterns into creational, structural, and behavioral groups, then details each pattern—such as Factory Method, Builder, Adapter, Observer, and Strategy—using playful dating scenarios to illustrate their intent, structure, and typical usage.

BehavioralCreationalDesign Patterns
0 likes · 19 min read
23 Design Patterns Explained with Humorous Real‑World Analogies
Java Backend Technology
Java Backend Technology
Jun 8, 2021 · Backend Development

Designing a Flexible Java Rule Engine: From Concept to Code

This article walks through a real‑world Java rule‑engine implementation, covering the business requirements, abstract rule design, executor construction, sample code, and a balanced discussion of its advantages and drawbacks for backend developers.

Code RefactoringDesign PatternsJava
0 likes · 8 min read
Designing a Flexible Java Rule Engine: From Concept to Code
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 7, 2021 · Fundamentals

How to Master Boilerplate Code in Java for Faster, Cleaner Development

This article explains what boilerplate code is, why it speeds up development, and provides practical Java examples and techniques—including annotations, design patterns, and immutable collections—to write, reuse, and reduce repetitive code while maintaining quality and readability.

Best PracticesBoilerplate CodeCode Refactoring
0 likes · 23 min read
How to Master Boilerplate Code in Java for Faster, Cleaner Development
Java High-Performance Architecture
Java High-Performance Architecture
Jun 7, 2021 · Fundamentals

23 Essential Design Patterns Explained with Fun Real‑World Analogies

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

AdapterBuilderDesign Patterns
0 likes · 18 min read
23 Essential Design Patterns Explained with Fun Real‑World Analogies
IT Architects Alliance
IT Architects Alliance
May 29, 2021 · Industry Insights

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

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

Design PatternsLayered ArchitectureScalability
0 likes · 9 min read
Mastering System Scalability: How to Predict and Handle Change in Architecture
Aikesheng Open Source Community
Aikesheng Open Source Community
May 27, 2021 · Databases

Essential Skills for Middleware Development and Database Middleware

This article outlines the fundamental and specialized technical skills required for developing middleware in general and database middleware in particular, covering multithreading, network programming, design patterns, asynchronous programming, algorithms, testing, performance tuning, as well as SQL, transaction handling, protocol implementation, and replication.

Design Patternsmiddlewaremultithreading
0 likes · 9 min read
Essential Skills for Middleware Development and Database Middleware
Sohu Tech Products
Sohu Tech Products
May 26, 2021 · Mobile Development

Understanding MVC and MVVM Patterns in iOS Development

This article provides a comprehensive guide to the MVC and MVVM architectural patterns for iOS, explaining their components, interactions, KVO usage, and includes complete Objective‑C code examples that demonstrate how to implement both patterns in a real‑world news‑list app.

Design PatternsKVOMVC
0 likes · 37 min read
Understanding MVC and MVVM Patterns in iOS Development
Alibaba Cloud Developer
Alibaba Cloud Developer
May 17, 2021 · Fundamentals

Why OOP Struggles with Complex Game Logic and How DDD/ECS Help

This article examines the limitations of classic object‑oriented programming for intricate game rules, demonstrates a dragon‑and‑magic example, compares OOP, Entity‑Component‑System and Domain‑Driven Design approaches, and provides practical guidelines, code snippets, and design patterns to achieve extensible, maintainable architecture.

DDDDesign PatternsECS
0 likes · 39 min read
Why OOP Struggles with Complex Game Logic and How DDD/ECS Help
Programmer DD
Programmer DD
May 15, 2021 · Backend Development

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

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

Backend DevelopmentCode ExampleDesign Patterns
0 likes · 8 min read
How to Build a Flexible Rule Engine with Java: Design, Implementation, and Tips
Amap Tech
Amap Tech
May 11, 2021 · Backend Development

Design and Implementation of a Scalable Order State Machine for Complex Multi‑Dimensional Order Processing

The article presents a scalable, two‑dimensional order state machine architecture that separates vertical business isolation via annotated StateProcessor classes from horizontal logic reuse through modular checkers and plugins, employing distributed locks, optimistic DB locking, and a registry to ensure extensible, consistent multi‑dimensional order processing.

ConcurrencyDesign PatternsState Machine
0 likes · 30 min read
Design and Implementation of a Scalable Order State Machine for Complex Multi‑Dimensional Order Processing
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 11, 2021 · Backend Development

Understanding Java Dynamic Proxy: Static vs Dynamic Proxy and Implementations with JDK, CGLIB, Javassist, and ASM

This article explains Java's proxy pattern, compares static and dynamic proxies, and provides detailed examples of JDK dynamic proxy, CGLIB, Javassist, and ASM implementations, highlighting their mechanisms, code samples, and practical considerations for backend development.

ASMDesign PatternsDynamic Proxy
0 likes · 21 min read
Understanding Java Dynamic Proxy: Static vs Dynamic Proxy and Implementations with JDK, CGLIB, Javassist, and ASM
Intelligent Backend & Architecture
Intelligent Backend & Architecture
May 8, 2021 · Fundamentals

Mastering Behavioral Design Patterns: When and How to Use Them

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

Behavioral PatternsDesign PatternsDesign Principles
0 likes · 20 min read
Mastering Behavioral Design Patterns: When and How to Use Them
Java Interview Crash Guide
Java Interview Crash Guide
May 8, 2021 · Fundamentals

Why Refactoring Matters: Transform Bad Code into Clean, Maintainable Software

This article explains why continuous refactoring is essential for evolving projects, defines refactoring and its scales, lists common code smells and their impact, and presents practical techniques—including SOLID principles, design patterns, naming conventions, layering, and test‑driven development—to turn messy code into high‑quality, maintainable software.

Design PatternsSOLIDTDD
0 likes · 36 min read
Why Refactoring Matters: Transform Bad Code into Clean, Maintainable Software
Intelligent Backend & Architecture
Intelligent Backend & Architecture
May 7, 2021 · Fundamentals

Unlocking Behavioral Design Patterns: When and How to Use Them

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

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

Understanding 23 Classic Design Patterns Through Everyday Analogies

This article explains twenty‑three classic software design patterns—including Factory Method, Builder, Abstract Factory, Prototype, Singleton, Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy, Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, and Visitor—using humorous real‑world scenarios to illustrate their intent and structure.

Design PatternsObject-OrientedSoftware Architecture
0 likes · 17 min read
Understanding 23 Classic Design Patterns Through Everyday Analogies
Sohu Tech Products
Sohu Tech Products
May 5, 2021 · Fundamentals

Common Design Patterns in Kotlin: Singleton, Factory, Builder, Prototype, Decorator, Strategy, Template Method, and Observer

This article introduces several classic design patterns—Singleton, Factory, Builder, Prototype, Decorator, Strategy, Template Method, and Observer—showing how they can be implemented concisely in Kotlin with code examples, while also explaining the underlying language features such as object declarations, companion objects, delegation, lazy initialization, and higher‑order functions.

BuilderDesign PatternsFactory
0 likes · 23 min read
Common Design Patterns in Kotlin: Singleton, Factory, Builder, Prototype, Decorator, Strategy, Template Method, and Observer
IT Architects Alliance
IT Architects Alliance
May 1, 2021 · Cloud Native

An Introduction to Microservice Architecture: Concepts, Evolution, Differences, Practices, and Design Patterns

This article provides a comprehensive overview of microservice architecture, covering its definition, history, contrast with monolithic development, core characteristics, distinctions from SOA, practical implementation steps, common design patterns, advantages, challenges, and recommended reading resources.

Design Patternsapi-gatewayarchitecture
0 likes · 22 min read
An Introduction to Microservice Architecture: Concepts, Evolution, Differences, Practices, and Design Patterns
Intelligent Backend & Architecture
Intelligent Backend & Architecture
Apr 30, 2021 · Fundamentals

Mastering Java Design Patterns and SOLID Principles: A Practical Guide

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

Design PatternsJavaObject-Oriented
0 likes · 34 min read
Mastering Java Design Patterns and SOLID Principles: A Practical Guide
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Apr 29, 2021 · Fundamentals

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

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

AndroidDesign PatternsJava
0 likes · 15 min read
Understanding the Singleton Pattern: Definition, Nine Implementations, Pros & Cons, and Android Applications
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Apr 29, 2021 · Fundamentals

Understanding the Strategy Design Pattern in Java

This article introduces the Strategy design pattern, explains its definition, class diagram, Java implementation examples, advantages and disadvantages, and demonstrates its use in JDK components such as Comparator and ThreadPoolExecutor, helping developers replace complex if‑else logic with interchangeable algorithm objects.

Design PatternsJavaStrategy Pattern
0 likes · 10 min read
Understanding the Strategy Design Pattern in Java
IT Architects Alliance
IT Architects Alliance
Apr 28, 2021 · Fundamentals

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

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

COLACQRSDesign Patterns
0 likes · 12 min read
Understanding Software Architecture: Concepts, Classifications, and the COLA Application Architecture
Liangxu Linux
Liangxu Linux
Apr 21, 2021 · Fundamentals

What Do Design Patterns Really Mean? A Playful Guide to 23 Patterns

The article humorously explains 23 classic software design patterns—ranging from creational to behavioral—using everyday dating scenarios to illustrate each pattern's intent, structure, and typical usage, making the concepts easy to grasp for developers.

BehavioralCreationalDesign Patterns
0 likes · 23 min read
What Do Design Patterns Really Mean? A Playful Guide to 23 Patterns
WeDoctor Frontend Technology
WeDoctor Frontend Technology
Apr 20, 2021 · Fundamentals

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

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

Design PatternsSOLID principlesSoftware Architecture
0 likes · 28 min read
Master Design Patterns: Boost Code Reusability, Readability, and Maintainability
phodal
phodal
Apr 19, 2021 · Fundamentals

Unlocking Pattern Languages: From Design Patterns to Architecture

This article explores the concept of patterns and pattern languages across software design, architecture, and domain-driven design, detailing their definitions, classifications, practical usage, and examples such as POSA, microservice patterns, and elemental design patterns to help engineers systematically solve recurring problems.

DDDDesign PatternsPOSA
0 likes · 13 min read
Unlocking Pattern Languages: From Design Patterns to Architecture
IT Architects Alliance
IT Architects Alliance
Apr 18, 2021 · Backend Development

Microservice Architecture and Its 10 Most Important Design Patterns

This article explains microservice architecture, its key characteristics, advantages and disadvantages, and presents ten essential design patterns—including database per service, event sourcing, CQRS, Saga, BFF, API gateway, Strangler, circuit breaker, externalized configuration, and consumer‑driven contract testing—while offering guidance on when to apply each pattern.

Backend ArchitectureDesign PatternsDistributed Systems
0 likes · 26 min read
Microservice Architecture and Its 10 Most Important Design Patterns
Programmer DD
Programmer DD
Apr 16, 2021 · Backend Development

Demystifying Spring IoC and Dependency Injection: A Clear Guide for Beginners

This article explains the core concepts of Spring's Inversion of Control (IoC) and Dependency Injection (DI), illustrating how a container takes over object creation and wiring, why this reversal improves modularity and testability, and how the two ideas are essentially two views of the same design principle.

Design PatternsIoCJava
0 likes · 10 min read
Demystifying Spring IoC and Dependency Injection: A Clear Guide for Beginners
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Apr 16, 2021 · Backend Development

10 Essential Microservice Design Patterns Every Backend Engineer Should Know

This comprehensive guide explains microservice architecture, its key characteristics, advantages, disadvantages, and when to adopt it, then details ten crucial design patterns—including database per service, event sourcing, CQRS, Saga, BFF, API gateway, Strangler, circuit breaker, externalized configuration, and consumer‑driven contract testing—complete with pros, cons, use‑cases, and technology examples.

Backend ArchitectureDesign PatternsDistributed Systems
0 likes · 36 min read
10 Essential Microservice Design Patterns Every Backend Engineer Should Know
macrozheng
macrozheng
Apr 13, 2021 · Fundamentals

Master the Observer Pattern in Java: Theory, Code, and Real‑World Example

This article explains the Observer pattern, compares it with the Publish‑Subscribe model, showcases Java's built‑in Observable and Observer classes, provides complete code examples, and discusses practical considerations such as memory leaks and performance optimizations.

Design PatternsEvent-drivenJDK
0 likes · 10 min read
Master the Observer Pattern in Java: Theory, Code, and Real‑World Example
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Apr 10, 2021 · Backend Development

Why Microservices Matter: From Basics to Design Patterns

This article explains what microservice architecture is, its history, how it differs from monolithic and SOA approaches, outlines its key characteristics, practical implementation steps, common design patterns, advantages and disadvantages, and the mindset shift required for successful adoption.

Design Patternsapi-gatewayarchitecture
0 likes · 19 min read
Why Microservices Matter: From Basics to Design Patterns
Youku Technology
Youku Technology
Apr 7, 2021 · Mobile Development

Rethinking iOS Architecture: From MVC to a Refined MVVM Approach

This article analyzes the limitations of classic iOS MVC, explores MVVM's benefits and drawbacks, and proposes a new service‑oriented architecture with a simple DSL to define and compose atomic business functions, aiming for cleaner, more maintainable mobile code.

Design PatternsMVCMVVM
0 likes · 10 min read
Rethinking iOS Architecture: From MVC to a Refined MVVM Approach
Architecture Digest
Architecture Digest
Apr 4, 2021 · Fundamentals

Common Software Architectural Patterns and Their Comparison

This article introduces ten widely used software architectural patterns, explains their structure, typical usage scenarios, and lists their advantages and disadvantages, concluding with a comparative table that helps developers choose the most suitable architecture for their systems.

Design PatternsSystem Designarchitectural patterns
0 likes · 12 min read
Common Software Architectural Patterns and Their Comparison
Selected Java Interview Questions
Selected Java Interview Questions
Apr 2, 2021 · Backend Development

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

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

Backend DevelopmentDesign PatternsJava
0 likes · 20 min read
Design Patterns in MyBatis: Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, and Iterator
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Mar 26, 2021 · Fundamentals

Design Patterns and SOLID Principles for Building a Message Sending Service

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

Design PatternsPHPSOLID
0 likes · 17 min read
Design Patterns and SOLID Principles for Building a Message Sending Service
Architecture Digest
Architecture Digest
Mar 20, 2021 · Fundamentals

A Humorous Overview of 23 Classic Software Design Patterns

This article presents a playful yet informative walkthrough of twenty‑three classic software design patterns—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 analogies to illustrate their intent and structure.

AdapterBuilderDesign Patterns
0 likes · 18 min read
A Humorous Overview of 23 Classic Software Design Patterns
Java Captain
Java Captain
Mar 19, 2021 · Fundamentals

A Humorous Guide to 23 Software Design Patterns Using Dating Analogies

This article humorously explains 23 classic software design patterns—such as Factory Method, Builder, Abstract Factory, Prototype, Singleton, Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy, Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, and Visitor—by comparing each pattern to everyday dating scenarios.

AdapterBuilderDesign Patterns
0 likes · 18 min read
A Humorous Guide to 23 Software Design Patterns Using Dating Analogies
Programmer DD
Programmer DD
Mar 19, 2021 · Backend Development

Simplify Multi-Payment Integration in Java with the Strategy Pattern

This article explains how to replace cumbersome if/else payment handling code with a clean Strategy pattern implementation in Java, showing both the problem scenario and a complete example including enums, interfaces, and concrete payment classes for Alipay and WeChat Pay.

Design PatternsJavaPayment Integration
0 likes · 7 min read
Simplify Multi-Payment Integration in Java with the Strategy Pattern
IT Architects Alliance
IT Architects Alliance
Mar 14, 2021 · Fundamentals

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

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

Design PatternsEvent-drivenLayered Architecture
0 likes · 10 min read
Common Software Architecture Patterns: Layered, Multi‑Layer, Pipe‑Filter, Client‑Server, MVC, Event‑Driven, and Microservices
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Mar 13, 2021 · Fundamentals

Effective Java Practices: Builder Pattern, Object Creation, and Performance Optimizations

This article presents a collection of Java best‑practice guidelines—including using the Builder pattern for many constructor arguments, privatizing utility class constructors, minimizing object creation, avoiding finalizers, applying the Law of Demeter, preferring enums, and careful use of var‑args—to improve code readability, memory usage, and runtime performance.

Best PracticesConcurrencyDesign Patterns
0 likes · 15 min read
Effective Java Practices: Builder Pattern, Object Creation, and Performance Optimizations
Huawei Cloud Developer Alliance
Huawei Cloud Developer Alliance
Mar 10, 2021 · Fundamentals

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

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

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

How Spring Solves Circular Dependencies and the Underlying Essence

This article explains Spring's approach to resolving circular dependencies in singleton beans using a three‑level cache, contrasts it with prototype bean limitations, provides a simplified implementation example, and draws an analogy to the classic two‑sum algorithm to illustrate the core concept.

Design PatternsJavaSingleton
0 likes · 9 min read
How Spring Solves Circular Dependencies and the Underlying Essence
Sohu Tech Products
Sohu Tech Products
Feb 24, 2021 · Frontend Development

Understanding Common JavaScript Design Patterns: Constructor, Facade, Proxy, Strategy, Bridge, and State

This article explains six fundamental JavaScript design patterns—Constructor, Facade, Proxy, Strategy, Bridge, and State—illustrating their concepts, advantages, drawbacks, and providing clear code examples that demonstrate how each pattern can improve code organization, reuse, and maintainability in front‑end development.

ConstructorDesign PatternsFacade
0 likes · 23 min read
Understanding Common JavaScript Design Patterns: Constructor, Facade, Proxy, Strategy, Bridge, and State
Alibaba Terminal Technology
Alibaba Terminal Technology
Feb 24, 2021 · Frontend Development

Why CSS-in-JS Is Revolutionizing Frontend Development: History, Patterns, and Future

This article traces the evolution of CSS from its early specifications to modern CSS‑in‑JS approaches, examines CSS design patterns and Houdini APIs, compares preprocessors with CSS‑in‑JS, outlines popular libraries, discusses advantages and drawbacks, and looks ahead to cross‑platform and automated design integration.

CSS-in-JSDesign PatternsHoudini
0 likes · 19 min read
Why CSS-in-JS Is Revolutionizing Frontend Development: History, Patterns, and Future
Java Captain
Java Captain
Feb 20, 2021 · Backend Development

Spring Framework Design Patterns: Summary and Implementation Details

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

AdapterBeanFactoryDecorator
0 likes · 15 min read
Spring Framework Design Patterns: Summary and Implementation Details