BestHub
Sign in
Tagged articles
848 articles
Page 7 of 9
Java Captain
Java Captain
Feb 9, 2021 · Fundamentals

Applying the Chain of Responsibility Pattern to King of Glory Lottery System (Java Implementation)

This article explains how the Chain of Responsibility design pattern can be used to model the King of Glory lottery mechanism, describes the pattern's structure, advantages, and use cases, and provides a complete Java implementation with handler interfaces and concrete classes for different draw actions.

Chain of ResponsibilityDesign PatternsGame Development
0 likes · 11 min read
Applying the Chain of Responsibility Pattern to King of Glory Lottery System (Java Implementation)
Programmer DD
Programmer DD
Feb 1, 2021 · Backend Development

Unlock Spring’s Power: 9 Essential Design Patterns Every Backend Engineer Should Master

This article explores nine key Spring framework design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—detailing their implementation, underlying principles, and practical code examples, while highlighting how they enable loose coupling and extensibility in backend development.

Backend DevelopmentDesign PatternsJava
0 likes · 15 min read
Unlock Spring’s Power: 9 Essential Design Patterns Every Backend Engineer Should Master
Architecture Digest
Architecture Digest
Jan 22, 2021 · Backend Development

Microservice Architecture and Its Ten Most Important Design Patterns

This article explains the fundamentals of microservice architecture, outlines its advantages and disadvantages, describes when it should be adopted, and details 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—providing practical guidance and technology examples for modern backend systems.

CQRSDesign PatternsDistributed Systems
0 likes · 21 min read
Microservice Architecture and Its Ten Most Important Design Patterns
Architect's Tech Stack
Architect's Tech Stack
Jan 20, 2021 · Fundamentals

Using a Generic Builder Pattern in Java to Simplify Object Creation

This article demonstrates how a universal Builder utility can replace verbose object construction in Java, allowing developers to instantiate a class and set multiple properties—including complex collections—in a single fluent chain, while also explaining the underlying implementation and usage examples.

Builder PatternDesign PatternsFluent API
0 likes · 7 min read
Using a Generic Builder Pattern in Java to Simplify Object Creation
IT Architects Alliance
IT Architects Alliance
Jan 18, 2021 · Backend Development

10 Essential Microservice Design Patterns Every Architect Should Know

This comprehensive guide explains the evolution, core concepts, advantages, drawbacks, and practical usage scenarios of microservice architecture, then details ten critical design patterns—including database per service, event sourcing, CQRS, Saga, BFF, API gateway, Strangler, circuit breaker, externalized configuration, and consumer‑driven contract testing—providing concrete examples, pros, cons, and technology recommendations.

BackendDesign PatternsDistributed Systems
0 likes · 28 min read
10 Essential Microservice Design Patterns Every Architect Should Know
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jan 18, 2021 · Backend Development

10 Essential Microservice Design Patterns Every Backend Engineer Should Know

This article surveys the evolution of software complexity, defines microservice architecture, outlines its key advantages and drawbacks, and 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—while explaining when each should be applied.

Backend ArchitectureCQRSDesign Patterns
0 likes · 24 min read
10 Essential Microservice Design Patterns Every Backend Engineer Should Know
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jan 14, 2021 · Fundamentals

Understanding the Decorator Pattern in Java: Core Roles and Practical Implementation

This article explains the Decorator design pattern in Java, detailing its four core participants—Component, ConcreteComponent, Decorator, and ConcreteDecorator—through UML diagrams and complete code examples, and also illustrates how Java’s InputStream hierarchy uses FilterInputStream as a real‑world decorator.

Decorator PatternDesign PatternsInputStream
0 likes · 5 min read
Understanding the Decorator Pattern in Java: Core Roles and Practical Implementation
Top Architect
Top Architect
Jan 13, 2021 · Backend Development

Eliminating if‑else Branches with Strategy Pattern, Map, and Chain of Responsibility in Java

This article demonstrates how to replace cumbersome if‑else or switch statements in Java backend receipt processing by applying the Strategy pattern with a Map dictionary, a simple factory, and the Chain of Responsibility pattern, while also showing reflective class loading for extensibility.

BackendChain of ResponsibilityDesign Patterns
0 likes · 13 min read
Eliminating if‑else Branches with Strategy Pattern, Map, and Chain of Responsibility in Java
网易UEDC
网易UEDC
Jan 8, 2021 · Game Development

How the Iceberg Theory Transforms Game UI Design: From Conscious to Unconscious

This article explores Freud's iceberg model of the mind, explains conscious, preconscious and unconscious layers, and demonstrates how game UI designers can apply these concepts to create more intuitive, memory‑evoking, and seamless player experiences across various interface scenarios.

Design PatternsIceberg TheoryPsychology
0 likes · 9 min read
How the Iceberg Theory Transforms Game UI Design: From Conscious to Unconscious
High Availability Architecture
High Availability Architecture
Dec 31, 2020 · Backend Development

Design and Go Implementation of a Service Circuit Breaker

This article explains the design and Go implementation of a microservice circuit breaker, covering fault‑tolerance mechanisms, state transitions, configurable trip strategies, metrics collection, testing, and deployment patterns such as centralized gateways and service mesh.

Design PatternsGolangMicroservices
0 likes · 20 min read
Design and Go Implementation of a Service Circuit Breaker
ITPUB
ITPUB
Dec 30, 2020 · Fundamentals

What Is Software Architecture? Core Concepts, Patterns, and the COLA Framework Explained

This article defines software architecture, explains why it is essential, outlines the architect's responsibilities, categorizes various architecture types, and details common patterns such as layered, CQRS, hexagonal, onion, and the open‑source COLA framework with its design and extension principles.

COLA frameworkCQRSDesign Patterns
0 likes · 15 min read
What Is Software Architecture? Core Concepts, Patterns, and the COLA Framework Explained
FunTester
FunTester
Dec 29, 2020 · Fundamentals

Understanding Java Proxy Pattern: Static, JDK Dynamic, and CGLIB Proxies

This article explains the proxy design pattern in Java, demonstrates how to create static proxies, uses JDK dynamic proxies with InvocationHandler, and shows how CGLIB can generate class‑based proxies, highlighting their implementations, usage examples, and limitations.

Design PatternsDynamic ProxyJDK Proxy
0 likes · 8 min read
Understanding Java Proxy Pattern: Static, JDK Dynamic, and CGLIB Proxies
Architects' Tech Alliance
Architects' Tech Alliance
Dec 22, 2020 · Fundamentals

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

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

COLADesign PatternsDomain-Driven Design
0 likes · 13 min read
Understanding Software Architecture: Concepts, Classifications, and the COLA Application Architecture
Selected Java Interview Questions
Selected Java Interview Questions
Dec 22, 2020 · Backend Development

Handling Null Values and Optional in Java Backend Development

This article discusses common null‑value pitfalls in Java services, compares returning null collections versus empty collections, introduces the Null‑Object pattern and JDK 8/Guava Optional, and provides practical guidelines using JSR‑303/JSR‑305 annotations to make APIs safer and more expressive.

BackendDesign PatternsJava
0 likes · 15 min read
Handling Null Values and Optional in Java Backend Development
Code Ape Tech Column
Code Ape Tech Column
Dec 13, 2020 · Fundamentals

Common Software Architecture Patterns and Their Characteristics

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

Design PatternsEvent-drivenMVC
0 likes · 10 min read
Common Software Architecture Patterns and Their Characteristics
Top Architect
Top Architect
Dec 11, 2020 · Fundamentals

Effective Java: 51 Essential Practices for Writing Clean, Efficient Java Code

This article distills key recommendations from Effective Java, covering static factory methods, builder patterns, singleton safety, utility class design, object creation, memory management, garbage‑collection, equals/hashCode contracts, immutability, generics, enums, collections, exception handling, and performance‑aware coding practices for robust Java development.

Design PatternsEffective JavaJava
0 likes · 22 min read
Effective Java: 51 Essential Practices for Writing Clean, Efficient Java Code
Code Ape Tech Column
Code Ape Tech Column
Dec 7, 2020 · Backend Development

Unlock Spring’s Power: 9 Design Patterns Every Java Developer Should Master

This article explores nine core design patterns implemented in Spring—simple factory, factory method, singleton, adapter, decorator, proxy, observer, strategy, and template method—detailing their implementation mechanisms, underlying principles, code examples, and practical significance for building loosely coupled, extensible Java applications.

Backend DevelopmentDesign PatternsJava
0 likes · 16 min read
Unlock Spring’s Power: 9 Design Patterns Every Java Developer Should Master
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Dec 6, 2020 · Fundamentals

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

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

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

Mastering GOF Design Patterns: One‑Sentence Overview of All 23 Patterns

This article provides a comprehensive overview of the 23 GoF design patterns, categorizing them into creational, structural, and behavioral groups, explaining each pattern’s purpose and core essence in a concise one‑sentence description, and includes visual diagrams to aid understanding.

Behavioral PatternsCreational PatternsDesign Patterns
0 likes · 9 min read
Mastering GOF Design Patterns: One‑Sentence Overview of All 23 Patterns
Selected Java Interview Questions
Selected Java Interview Questions
Dec 3, 2020 · Backend Development

Comprehensive Guide to Java Design Patterns, Distributed Systems, and Core Algorithms

This article provides an extensive overview of common Java design patterns—including Singleton, Factory, Proxy, Observer, and Decorator—along with detailed code examples, followed by discussions of distributed system concepts, CAP theorem, BASE theory, and fundamental algorithms such as sorting and binary search.

AlgorithmsDesign PatternsDistributed Systems
0 likes · 41 min read
Comprehensive Guide to Java Design Patterns, Distributed Systems, and Core Algorithms
Top Architect
Top Architect
Dec 2, 2020 · Backend Development

Understanding MyBatis Plugins: Mechanisms, Use Cases, and Design Patterns

This article provides a comprehensive overview of MyBatis plugins, explaining their interception capabilities, typical use cases such as pagination, common field assignment, and performance monitoring, while detailing the underlying dynamic‑proxy implementation, configuration loading, and relevant design patterns for backend Java development.

Design PatternsInterceptorJava
0 likes · 9 min read
Understanding MyBatis Plugins: Mechanisms, Use Cases, and Design Patterns
Java Captain
Java Captain
Nov 29, 2020 · Backend Development

Simple Food Delivery Ordering System (No Database) – Java Console Implementation

This article presents a complete, step‑by‑step Java console application that implements a rudimentary food‑delivery ordering system without a database, covering entity classes, a generic DAO interface, in‑memory management classes for admins, dishes, users and orders, a menu‑driven UI, and a test driver.

Backend DevelopmentCRUDConsole Application
0 likes · 21 min read
Simple Food Delivery Ordering System (No Database) – Java Console Implementation
ITPUB
ITPUB
Nov 27, 2020 · Fundamentals

Understanding 7 Core Software Architecture Patterns and Their Trade‑offs

This article explains seven fundamental software architecture patterns—layered, multilayer, pipe‑filter, client‑server, MVC, event‑driven, and microservices—detailing their contexts, problems they solve, typical solutions, weaknesses, and appropriate usage scenarios for developers and designers.

Design PatternsEvent-drivenMVC
0 likes · 13 min read
Understanding 7 Core Software Architecture Patterns and Their Trade‑offs
Architect
Architect
Nov 21, 2020 · Fundamentals

Common Software Architecture Patterns and Their Advantages and Disadvantages

This article introduces ten widely used software architecture patterns—including layered, client‑server, master‑slave, pipe‑and‑filter, broker, P2P, event‑bus, MVC, blackboard, and interpreter—explaining their structures, typical applications, and the main pros and cons of each.

Design PatternsMVCclient-server
0 likes · 8 min read
Common Software Architecture Patterns and Their Advantages and Disadvantages
php Courses
php Courses
Nov 20, 2020 · Databases

Technical Interview Q&A: MySQL, Indexing, Design Patterns, Algorithms, Networking, and Concurrency

This article compiles a series of technical interview questions and answers covering MySQL query best practices, index optimization, B+‑tree storage, binlog recovery, master‑slave replication, design pattern usage in Laravel, a PHP binary‑search insertion algorithm, transport‑layer protocols, TCP three‑handshake, and concurrency control strategies.

Design PatternsNetworkingdatabase
0 likes · 9 min read
Technical Interview Q&A: MySQL, Indexing, Design Patterns, Algorithms, Networking, and Concurrency
Huawei Cloud Developer Alliance
Huawei Cloud Developer Alliance
Nov 17, 2020 · Backend Development

How to Become a Software Coach: A Step‑by‑Step Learning Roadmap

This guide outlines a multi‑stage roadmap for developers to grow into software coaches, covering essential Java fundamentals, agile practices, algorithms, testing, design patterns, JVM internals, distributed middleware, big‑data ecosystems, architecture design, performance tuning, and emerging fields like AI and IoT.

Career DevelopmentDesign PatternsDistributed Systems
0 likes · 11 min read
How to Become a Software Coach: A Step‑by‑Step Learning Roadmap
Programmer DD
Programmer DD
Nov 17, 2020 · Fundamentals

Top 25 Must‑Read Programming Books Every Developer Should Own

After the Double‑11 shopping frenzy, many developers grabbed new programming books, and this article curates the 25 most acclaimed titles—covering classic fundamentals, design patterns, algorithms, software craftsmanship, and career development—to help readers choose the most valuable resources for their growth.

AlgorithmsCareer DevelopmentDesign Patterns
0 likes · 28 min read
Top 25 Must‑Read Programming Books Every Developer Should Own
Beike Product & Technology
Beike Product & Technology
Nov 13, 2020 · Mobile Development

Designing a Network Framework from Scratch and Analyzing OkHttp & Retrofit Implementations

This article explains how to design a network framework from the ground up, explores the three‑layer understanding of frameworks, details the core components, thread scheduling, request/response processing chains, and then deep‑dives into OkHttp and Retrofit implementations, their limitations, and extensibility techniques.

Design PatternsInterceptorNetwork Framework
0 likes · 15 min read
Designing a Network Framework from Scratch and Analyzing OkHttp & Retrofit Implementations
IT Architects Alliance
IT Architects Alliance
Nov 12, 2020 · Backend Development

Mastering CQRS: Choose the Right Architecture – Single, Dual, or Event‑Sourced

This article explains the Command‑Query Separation principle, introduces the CQRS architectural pattern, and compares three implementations—single‑database, dual‑database, and event‑sourced—detailing their workflows, benefits, and trade‑offs for optimizing read and write operations in backend systems.

Backend ArchitectureCQRSCQS
0 likes · 6 min read
Mastering CQRS: Choose the Right Architecture – Single, Dual, or Event‑Sourced
JavaEdge
JavaEdge
Nov 4, 2020 · Fundamentals

Mastering the Strategy Pattern: When and How to Replace Complex if/else

This article explains the Strategy (Policy) pattern, detailing its definition, class diagram, typical use cases, advantages and drawbacks, compares it with Factory and State patterns, and provides a practical Java implementation with sample code and analysis of related JDK components.

Design PatternsJavaOOP
0 likes · 6 min read
Mastering the Strategy Pattern: When and How to Replace Complex if/else
ITPUB
ITPUB
Nov 4, 2020 · 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, problems they solve, typical solutions, drawbacks, and ideal usage scenarios for developers.

Design PatternsEvent-drivenarchitecture
0 likes · 14 min read
What Are the 7 Core Software Architecture Patterns and When to Use Them?
Selected Java Interview Questions
Selected Java Interview Questions
Nov 3, 2020 · Backend Development

Java Interview Questions and Sample Solutions (Sorting Units, Coding Challenges, and Common Topics)

This article presents a Java interview preparation guide featuring a unit‑conversion sorting problem with complete code, two additional coding challenges, and a collection of typical interview questions on design patterns, GC troubleshooting, MySQL optimization, and Zookeeper election, plus links to extensive interview question archives.

BackendDesign PatternsJava
0 likes · 5 min read
Java Interview Questions and Sample Solutions (Sorting Units, Coding Challenges, and Common Topics)
21CTO
21CTO
Oct 30, 2020 · 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 contexts, problems they solve, typical structures, strengths, weaknesses, and suitable application scenarios to help developers choose the right architecture for their projects.

Design PatternsEvent-drivenMVC
0 likes · 12 min read
What Are the 7 Core Software Architecture Patterns and When to Use Them?
IT Architects Alliance
IT Architects Alliance
Oct 28, 2020 · Fundamentals

Why Architecture Matters: From Basics to the COLA Open‑Source Framework

This article explains what software architecture is, why it is essential, the responsibilities of architects, various classification types, common patterns such as layered, CQRS, hexagonal and onion architectures, and introduces the open‑source COLA framework with its layered design, extension mechanisms, and specification rules.

COLACQRSDesign Patterns
0 likes · 14 min read
Why Architecture Matters: From Basics to the COLA Open‑Source Framework
Selected Java Interview Questions
Selected Java Interview Questions
Oct 28, 2020 · Fundamentals

Decorator Pattern in Java: Theory, Code Examples, and Practical Usage

This article explains the Decorator design pattern, compares a naïve inheritance approach with a proper decorator implementation in Java, provides complete code examples, class diagram, usage scenarios, advantages, and disadvantages, demonstrating how to dynamically extend object behavior without modifying existing code.

Decorator PatternDesign PatternsJava
0 likes · 10 min read
Decorator Pattern in Java: Theory, Code Examples, and Practical Usage
IT Architects Alliance
IT Architects Alliance
Oct 25, 2020 · R&D Management

From Senior Engineer to Software Architect: A Practical Roadmap

This article outlines a step‑by‑step career roadmap for developers who aspire to become software architects, covering role definitions, required technical and managerial skills, learning pathways such as OOP, design patterns and refactoring, and practical advice for continuous self‑improvement.

Career DevelopmentDesign PatternsR&D management
0 likes · 24 min read
From Senior Engineer to Software Architect: A Practical Roadmap
JavaEdge
JavaEdge
Oct 25, 2020 · Backend Development

How to Eliminate Duplicate Code with Factory & Template Method Patterns in Java

This article explains why duplicate code harms maintainability, then demonstrates step‑by‑step refactoring techniques—using factory and template method patterns, custom annotations with reflection, and BeanUtils—to consolidate business logic for different cart types and API calls while preserving extensibility.

Design PatternsFactory PatternJava
0 likes · 15 min read
How to Eliminate Duplicate Code with Factory & Template Method Patterns in Java
Alibaba Cloud Developer
Alibaba Cloud Developer
Oct 21, 2020 · Fundamentals

Mastering Responsibility-Driven Design: How GRASP Shapes Low Coupling & High Cohesion

This article explains why responsibility‑driven design (RDD) is essential for managing software complexity, introduces the GRASP responsibility‑assignment patterns, details each principle such as preventing variation, low coupling, high cohesion, and demonstrates their practical application with real‑world case studies and code examples.

Design PatternsGRASPHigh Cohesion
0 likes · 19 min read
Mastering Responsibility-Driven Design: How GRASP Shapes Low Coupling & High Cohesion
FunTester
FunTester
Oct 21, 2020 · Backend Development

Using Java Generics to Simplify Multithreaded Task Design

This article explores how to apply Java generics in a multithreaded task framework, demonstrates refactoring a ThreadBase class, provides concrete code examples with RequestThreadTimes, and discusses the challenges and solutions for generic type constraints in inheritance hierarchies.

Design PatternsGenericsJava
0 likes · 6 min read
Using Java Generics to Simplify Multithreaded Task Design
JavaEdge
JavaEdge
Oct 4, 2020 · Fundamentals

When Objects Change Behavior: Mastering the State Design Pattern

The State pattern lets an object alter its behavior when its internal state changes, by encapsulating state-specific logic in separate classes and delegating behavior through a context, improving maintainability and flexibility in object-oriented systems.

BehavioralDesign PatternsJava
0 likes · 10 min read
When Objects Change Behavior: Mastering the State Design Pattern
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 26, 2020 · Fundamentals

Understanding Factory Patterns: Simple Factory, Factory Method, and Abstract Factory with Spring Dependency Injection

This article explains the three common factory design patterns—simple factory, factory method, and abstract factory—illustrates their Java implementations with product and factory classes, demonstrates client usage, and shows how Spring's dependency injection can replace manual factory instantiation, providing a comprehensive guide for developers.

Abstract FactoryDesign PatternsFactory Pattern
0 likes · 7 min read
Understanding Factory Patterns: Simple Factory, Factory Method, and Abstract Factory with Spring Dependency Injection
Java Architect Essentials
Java Architect Essentials
Sep 20, 2020 · Backend Development

Eight Common Software Architecture Design Patterns and Their Advantages and Disadvantages

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

Design PatternsMicroservicesScalability
0 likes · 22 min read
Eight Common Software Architecture Design Patterns and Their Advantages and Disadvantages
ITPUB
ITPUB
Sep 14, 2020 · Big Data

How Alibaba’s DChain Data Converger Auto‑Generates Real‑Time Wide Tables with SQL Pipelines

This article explains how the ADC (Alibaba DChain Data Converger) project automatically creates large real‑time tables by letting users configure metrics on the front‑end, then generating and publishing SQL through a pipeline that leverages design patterns, priority queues, and tree‑based data structures for efficient cross‑database processing.

Design PatternsFlinkReal-time analytics
0 likes · 15 min read
How Alibaba’s DChain Data Converger Auto‑Generates Real‑Time Wide Tables with SQL Pipelines
Programmer DD
Programmer DD
Sep 13, 2020 · Mobile Development

How iOS Implements Undo/Redo with Command & Observer Patterns

This article explains how iOS keyboards achieve undo and redo functionality by combining the Command and Observer design patterns, illustrates their class structures, and shows how the NSUndoManager leverages these patterns to manage undo and redo stacks in Cocoa Touch applications.

Command PatternDesign PatternsMobile Development
0 likes · 5 min read
How iOS Implements Undo/Redo with Command & Observer Patterns
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Sep 11, 2020 · Backend Development

Master Dependency Injection in TypeScript: Build Maintainable Code with IoC

This tutorial explains what dependencies are, why Dependency Injection (DI) and Inversion of Control (IoC) improve code maintainability, shows how to set up TypeScript with reflect‑metadata, and provides a full DI container implementation with Service and Inject decorators, complete usage examples and best‑practice notes.

DI ContainerDesign PatternsIoC
0 likes · 10 min read
Master Dependency Injection in TypeScript: Build Maintainable Code with IoC
58UXD
58UXD
Sep 10, 2020 · Product Management

How a Fruit Store Story Reveals the Secrets of Search Recall and Precision

Using a fruit shop analogy, the article explains recall and precision metrics, illustrates their impact on recruitment search, and presents a matrix of design patterns—including cross‑database search, preset search sets, and matching labels—to boost both recall and accuracy while maintaining user experience.

Design PatternsUser experienceprecision
0 likes · 14 min read
How a Fruit Store Story Reveals the Secrets of Search Recall and Precision
Alibaba Cloud Developer
Alibaba Cloud Developer
Sep 3, 2020 · Fundamentals

Mastering In‑Out Parameters in Java: 5 Refactoring Techniques Explained

This article explores why Java lacks native input‑output parameters, examines common pitfalls when extracting methods, and presents five practical refactoring solutions—including parameter objects, single‑value arrays, tuple classes, holder objects, and return‑value strategies—complete with code samples and usage guidelines.

Design PatternsInOut ParametersJava
0 likes · 25 min read
Mastering In‑Out Parameters in Java: 5 Refactoring Techniques Explained
Programmer DD
Programmer DD
Sep 2, 2020 · Fundamentals

When to Use Java Interfaces Instead of Abstract Classes? A Complete Guide

This article explores three common doubts about Java interfaces, demonstrates how interface references can point to implementing objects, compares abstract classes and interfaces for achieving polymorphism, and provides detailed animal‑hierarchy examples with code, generics, and best‑practice recommendations.

Abstract ClassDesign PatternsGenerics
0 likes · 19 min read
When to Use Java Interfaces Instead of Abstract Classes? A Complete Guide
Laravel Tech Community
Laravel Tech Community
Sep 1, 2020 · Fundamentals

PHP Design Patterns: Singleton, Factory, Registry, Adapter, and Observer

This article introduces common PHP design patterns—including Singleton, Factory, Registry, Adapter, and Observer—explaining their purpose, structure, typical use cases, and providing complete code examples for each pattern to illustrate how they can be implemented in object‑oriented applications.

AdapterDesign PatternsFactory
0 likes · 7 min read
PHP Design Patterns: Singleton, Factory, Registry, Adapter, and Observer
Youzan Coder
Youzan Coder
Aug 19, 2020 · Fundamentals

Understanding Design Patterns: Origins, Misconceptions, and Effective Learning

The article traces design patterns from Alexander’s 1977 architectural ideas through the GoF’s 1994 catalog, debunks myths that they’re obsolete for simple CRUD, shows their essential role in extensible frameworks and complex SaaS systems, and advises learning them by matching each pattern to the specific problem it solves while grounding them in core OOP concepts and the seven SOLID‑type design principles.

Design PatternsGoFOOP principles
0 likes · 12 min read
Understanding Design Patterns: Origins, Misconceptions, and Effective Learning
Programmer DD
Programmer DD
Aug 15, 2020 · Fundamentals

Mastering the Strategy Pattern in Java: Real‑World Pricing and Payment Examples

This article explains the Strategy pattern with Java, showing how to refactor a naïve pricing module into a flexible, open‑closed design, and then extends the concept to payment processing and thread‑pool rejection handling, complete with code samples and UML diagrams.

Design PatternsOpen/Closed PrincipleSoftware Architecture
0 likes · 28 min read
Mastering the Strategy Pattern in Java: Real‑World Pricing and Payment Examples
Laravel Tech Community
Laravel Tech Community
Aug 11, 2020 · Backend Development

Understanding IoC, Simple Factory, and Dependency Injection in PHP

This article explains the Inversion of Control (IoC) pattern, demonstrates a simple factory for creating traffic‑tool objects, and shows how to apply Dependency Injection (DI) in PHP to decouple a Student class from concrete transportation implementations, culminating in a lightweight IoC container example.

Design PatternsIoCPHP
0 likes · 7 min read
Understanding IoC, Simple Factory, and Dependency Injection in PHP
Java Captain
Java Captain
Aug 10, 2020 · Fundamentals

Understanding the Strategy Pattern with Java Examples

This article explains the Strategy design pattern, demonstrates its use through a quote‑management example and various Java implementations, discusses the open‑closed principle, shows how to apply the pattern to different scenarios such as payment processing and thread‑pool rejection handling, and outlines its advantages and drawbacks.

Design PatternsJavaOOP
0 likes · 26 min read
Understanding the Strategy Pattern with Java Examples
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Aug 4, 2020 · Fundamentals

Understanding the Prototype Design Pattern in Java

The article explains the Prototype design pattern in Java, covering its definition, class diagram, implementation with Cloneable, shallow vs deep copying, advantages, use cases, Spring prototype scope, and provides complete code examples illustrating cloning of Sheep, Goat, and Lamb objects.

Design PatternsJavaPrototype Pattern
0 likes · 12 min read
Understanding the Prototype Design Pattern in Java
Amap Tech
Amap Tech
Jul 23, 2020 · Mobile Development

Cross‑Platform Audio Player Framework for Smart Scenic Spot Guides

The Gaode Smart Scenic Spot Pocket‑Player framework provides a cross‑platform, hybrid audio solution that delivers location‑based MP3 guides, isolates business logic via an observer‑based service, manages audio focus and interruptions efficiently, supports cross‑page and offline playback, and enables rapid, low‑resource development for immersive tourist experiences.

Design PatternsMobileResource Optimization
0 likes · 11 min read
Cross‑Platform Audio Player Framework for Smart Scenic Spot Guides
Selected Java Interview Questions
Selected Java Interview Questions
Jul 18, 2020 · Backend Development

Deep Dive into Spring IOC Container Initialization Process

This article provides a comprehensive, step‑by‑step analysis of how Spring's IoC container is initialized, covering resource loading, BeanDefinition creation, BeanFactory setup, template‑method refresh logic, and practical debugging tips, all illustrated with UML diagrams and code snippets.

BackendDesign PatternsIoC
0 likes · 20 min read
Deep Dive into Spring IOC Container Initialization Process
Xianyu Technology
Xianyu Technology
Jul 14, 2020 · Backend Development

Applying the Responsibility Tree Pattern for Versioned API Refactoring

To refactor a versioned API plagued by nested guards, the article proposes the Responsibility Tree pattern—a hybrid of Chain of Responsibility and Strategy—that routes requests through hierarchical handlers based on parameters, yielding cleaner code, easier debugging, and scalable extension for future versions.

API VersioningChain of ResponsibilityDesign Patterns
0 likes · 12 min read
Applying the Responsibility Tree Pattern for Versioned API Refactoring
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jul 13, 2020 · Fundamentals

Understanding the Proxy Design Pattern in Java: Static, Dynamic, and CGLIB Implementations

This article explains the Proxy design pattern, covering its purpose, static, dynamic (JDK), and CGLIB implementations in Java, provides complete code examples, discusses advantages and disadvantages, and outlines typical use cases such as lazy initialization, access control, remote services, logging, and caching.

Design PatternsDynamic ProxyJava
0 likes · 14 min read
Understanding the Proxy Design Pattern in Java: Static, Dynamic, and CGLIB Implementations
JavaEdge
JavaEdge
Jul 10, 2020 · Fundamentals

Why Static Factory Methods Outshine Constructors in Java

This article explains how static factory methods improve readability, performance, and flexibility compared to public constructors, covering benefits such as named creation, instance reuse, subtype returns, service‑provider frameworks, as well as drawbacks like limited inheritance and discoverability, and offers naming conventions and real‑world Java examples.

Design PatternsJavaStatic Factory
0 likes · 10 min read
Why Static Factory Methods Outshine Constructors in Java
Alibaba Cloud Native
Alibaba Cloud Native
Jul 8, 2020 · Backend Development

Why COLA 3.0 Strips Away Complexity: An Ockham’s Razor‑Driven Refactor

This article examines the COLA application‑architecture framework, explains how the author applied Ockham’s razor to prune unnecessary concepts such as Command, Interceptor, and Convertor/Validator/Assembler, and shows concrete code before and after the simplification, culminating in a leaner, more maintainable backend design.

COLADesign PatternsJava
0 likes · 11 min read
Why COLA 3.0 Strips Away Complexity: An Ockham’s Razor‑Driven Refactor
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jul 2, 2020 · Fundamentals

Understanding Java Enums: Seven Practical Usage Patterns and Best Practices

This article introduces Java's enum type introduced in JDK 1.5, explains seven practical usage patterns—including constants, switch statements, adding methods, overriding methods, implementing interfaces, organizing enums in interfaces, and using EnumSet/EnumMap—while providing code examples, best‑practice guidelines, and comparisons with legacy int or String constants.

BackendDesign PatternsJava
0 likes · 14 min read
Understanding Java Enums: Seven Practical Usage Patterns and Best Practices
Programmer DD
Programmer DD
Jun 20, 2020 · Backend Development

Understanding Synchronous, Asynchronous Calls and Callbacks in Java

This article explains the differences between synchronous and asynchronous method calls, introduces callback mechanisms, and provides complete Java code examples for both sync and async callbacks, helping developers grasp how to design and implement these patterns in backend applications.

AsynchronousBackendDesign Patterns
0 likes · 14 min read
Understanding Synchronous, Asynchronous Calls and Callbacks in Java
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 10, 2020 · Fundamentals

Adapter Design Pattern: Concepts, Structure, Code Samples, and Spring MVC Application

This article explains the Adapter design pattern, illustrates its real‑world analogies, describes object and class adapter variants, provides complete Java code examples, demonstrates a voltage‑conversion demo, and shows how Spring MVC employs adapters to decouple controllers from request handling.

Adapter PatternClass AdapterDesign Patterns
0 likes · 15 min read
Adapter Design Pattern: Concepts, Structure, Code Samples, and Spring MVC Application
Architects Research Society
Architects Research Society
Jun 4, 2020 · Fundamentals

Overview of Software Architecture Patterns and Styles

This article introduces software architecture patterns as reusable solutions to common design problems and catalogs various architecture styles—including layered, microservices, event‑driven, and distributed systems—providing a concise reference for architects and developers.

Design PatternsMicroservicesSoftware Architecture
0 likes · 3 min read
Overview of Software Architecture Patterns and Styles
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 25, 2020 · Fundamentals

Understanding the Six SOLID Principles of Design Patterns

This article explains the six core SOLID principles—Single Responsibility, Interface Segregation, Dependency Inversion, Liskov Substitution, Law of Demeter, and Open/Closed—detailing their definitions, benefits, practical examples, and how they improve code reusability, readability, maintainability, and system extensibility.

Design PatternsObject-OrientedSOLID
0 likes · 8 min read
Understanding the Six SOLID Principles of Design Patterns
Top Architect
Top Architect
May 20, 2020 · Fundamentals

Eliminating Overused if…else Statements: Refactoring Techniques and Design Patterns

This article examines why excessive if…else statements harm code readability and maintainability, and presents a range of refactoring approaches—including table‑driven mapping, chain‑of‑responsibility, annotation‑driven, event‑driven, state machines, Optional, Assert, and polymorphism—to replace or simplify them, while also addressing deep nesting and complex conditional expressions.

Design PatternsSoftware Engineeringcode quality
0 likes · 19 min read
Eliminating Overused if…else Statements: Refactoring Techniques and Design Patterns
Selected Java Interview Questions
Selected Java Interview Questions
May 17, 2020 · Backend Development

Applying Strategy, Factory Method, and Builder Patterns in Spring for Reward Distribution

This article explains how to implement the Strategy, Factory Method, and Builder design patterns within a Spring application to decouple reward‑distribution logic, showing interface definitions, concrete implementations, a factory for dynamic bean selection, and a prototype‑scoped builder for request construction.

BuilderDesign PatternsFactory Method
0 likes · 12 min read
Applying Strategy, Factory Method, and Builder Patterns in Spring for Reward Distribution
Architects Research Society
Architects Research Society
May 11, 2020 · Fundamentals

10 Common Software Architectural Patterns and Their Uses

This article introduces ten widely used software architectural patterns—including layered, client‑server, master‑slave, pipe‑filter, broker, peer‑to‑peer, event‑bus, MVC, blackboard, and interpreter—explaining their structures, typical applications, advantages, and disadvantages, and provides a comparative overview.

Design PatternsMVCSoftware Architecture
0 likes · 8 min read
10 Common Software Architectural Patterns and Their Uses
High Availability Architecture
High Availability Architecture
May 11, 2020 · Backend Development

Understanding CQRS Complexity: Goals, Common Pitfalls, and Practical Solutions

This article examines the CQRS (Command Query Responsibility Segregation) pattern, outlining its objectives, three major complexity traps—over‑isolated commands, event sourcing coupling, and excessive tooling—and offers practical mitigation strategies, including relaxed isolation, alternative projection techniques, and careful service decomposition.

BackendCQRSDesign Patterns
0 likes · 10 min read
Understanding CQRS Complexity: Goals, Common Pitfalls, and Practical Solutions
Architect's Tech Stack
Architect's Tech Stack
May 9, 2020 · Backend Development

Unified Exception Handling and Assertion Techniques in Java Backend Development

This article explains how to replace repetitive try‑catch blocks in Java backend services with a unified exception handling framework using Spring's @ControllerAdvice, custom @ExceptionHandler methods, enum‑based error codes, and assertion utilities, improving code readability, maintainability, and error response consistency.

Design Patternsspring
0 likes · 21 min read
Unified Exception Handling and Assertion Techniques in Java Backend Development
Architecture Digest
Architecture Digest
May 7, 2020 · Fundamentals

Eliminating Excessive if…else: Patterns and Refactoring Techniques

This article examines the problems caused by overusing if…else statements in code—such as poor readability, maintainability, and violation of design principles—and presents a collection of refactoring patterns, including table‑driven design, chain of responsibility, annotation‑driven, event‑driven, state machines, Optional, guard clauses, and polymorphism, with concrete Java examples.

Design PatternsSoftware Engineeringcode quality
0 likes · 19 min read
Eliminating Excessive if…else: Patterns and Refactoring Techniques
Java Backend Technology
Java Backend Technology
May 7, 2020 · Backend Development

Eliminate Excessive Null Checks: Cleaner Java Code Without try‑catch

This article explains why overusing null‑check statements and try‑catch blocks makes Java code messy, distinguishes valid and invalid null returns, and offers practical techniques such as assertions, exceptions, empty collections, and the Null Object pattern to write safer, more concise code.

Design PatternsJavaNull Object
0 likes · 6 min read
Eliminate Excessive Null Checks: Cleaner Java Code Without try‑catch
dbaplus Community
dbaplus Community
May 4, 2020 · Fundamentals

Why Design Patterns May Harm Your Projects More Than Help

The article argues that, despite the popularity of design patterns, blindly applying the 23 classic patterns rarely improves software quality and often leads to over‑engineered or fragile code, urging developers to critically assess their context, language features, and multi‑paradigm alternatives before using them.

Design PatternsSoftware ArchitectureSoftware Engineering
0 likes · 16 min read
Why Design Patterns May Harm Your Projects More Than Help
Top Architect
Top Architect
Apr 29, 2020 · Fundamentals

Eliminating Excessive if...else Statements: Problems, Solutions, and Refactoring Techniques

The article examines the drawbacks of overusing if...else constructs in software, explains why they harm readability and maintainability, and presents ten practical refactoring methods—including table‑driven, chain‑of‑responsibility, annotation‑driven, event‑driven, state machine, Optional, Assert, guard clauses, and method extraction—to simplify or replace complex conditional logic.

Design PatternsSoftware Engineeringcode quality
0 likes · 16 min read
Eliminating Excessive if...else Statements: Problems, Solutions, and Refactoring Techniques
Bitu Technology
Bitu Technology
Apr 27, 2020 · Fundamentals

Recap of the 2020 Online Scala Meetup: Design Patterns, ZIO STM, Scala‑Java Integration, and Shapeless

On April 18, the inaugural 2020 Online Scala Meetup organized by Tubi featured four speakers who explored Scala design patterns, demonstrated ZIO STM usage, shared best practices for integrating Scala into Java codebases, and introduced Shapeless’s type-level programming, offering valuable insights for developers.

Design PatternsScalaShapeless
0 likes · 6 min read
Recap of the 2020 Online Scala Meetup: Design Patterns, ZIO STM, Scala‑Java Integration, and Shapeless
vivo Internet Technology
vivo Internet Technology
Apr 22, 2020 · Fundamentals

Understanding ReactiveX and RxJava: Core Concepts, Design Patterns, and Observable Mechanics

RxJava implements ReactiveX’s observer‑based, pull‑model paradigm by using Observable as a factory and template class whose static creators and chainable operators (e.g., flatMap) apply factory, template, observer and decorator patterns, enabling Java 8‑style asynchronous pipelines that developers can reason about, debug, and optimize.

Design PatternsJavaRxJava
0 likes · 9 min read
Understanding ReactiveX and RxJava: Core Concepts, Design Patterns, and Observable Mechanics
Top Architect
Top Architect
Apr 21, 2020 · Mobile Development

Designing a Cross‑Platform Architecture for WeChat Pay: From Problems to Solutions

The article analyzes the inconsistencies and maintenance challenges of separate iOS and Android implementations of WeChat Pay, then presents a C++‑based cross‑platform framework with UseCase‑driven business flow, routing, unified network handling and strict data passing, showing how these changes cut code size, keep crash rates stable and dramatically improve development productivity.

C++Design PatternsMobile Development
0 likes · 14 min read
Designing a Cross‑Platform Architecture for WeChat Pay: From Problems to Solutions
21CTO
21CTO
Apr 17, 2020 · Fundamentals

10 Proven Techniques to Eliminate Excessive if…else in Your Code

This article explains why overusing if…else harms code readability and maintainability, outlines ten practical methods—including table‑driven, chain of responsibility, annotation‑driven, event‑driven, state machines, Optional, Assert, and polymorphism—to refactor or replace complex conditional logic, and provides Java code examples for each approach.

Design PatternsSoftware Engineeringcode quality
0 likes · 16 min read
10 Proven Techniques to Eliminate Excessive if…else in Your Code
dbaplus Community
dbaplus Community
Apr 16, 2020 · Fundamentals

Why Code Quality Fails Projects and 4 Proven Ways to Fix It

The article examines why many software projects deteriorate due to poor code quality, outlines four common pitfalls such as oversized components, low cohesion, tangled logic, and rampant if‑else statements, and presents concrete refactoring strategies—including inverted‑pyramid design, lib/framework separation, Template Method pattern, and rich enums—to dramatically improve maintainability and project success.

Design PatternsSoftware Engineeringcode quality
0 likes · 37 min read
Why Code Quality Fails Projects and 4 Proven Ways to Fix It
macrozheng
macrozheng
Apr 14, 2020 · Fundamentals

Why Code Quality Matters: 4 Common Pitfalls and Proven Solutions for Developers

This article examines why high‑quality, maintainable code is essential for software projects, outlines four recurring code‑quality problems—including oversized components, low cohesion, tangled logic, and excessive if‑else—and presents concrete refactoring patterns such as inverted‑pyramid design, proper lib/framework reuse, Template Method separation, and rich enum types, while also introducing a CODEX indexing technique for large codebases.

Design PatternsSoftware Architecturebest practices
0 likes · 38 min read
Why Code Quality Matters: 4 Common Pitfalls and Proven Solutions for Developers
Alibaba Cloud Developer
Alibaba Cloud Developer
Apr 1, 2020 · Fundamentals

How to Rapidly Boost Your Software Design Skills: Practical Steps for Developers

This article shares practical advice on improving a programmer's design ability, covering coding practice, theory study, hands‑on implementation, revisiting concepts, summarizing lessons, sharing knowledge, and additional tips such as designing before coding and avoiding blind reliance on patterns.

Design PatternsSoftware Architecturecoding practice
0 likes · 9 min read
How to Rapidly Boost Your Software Design Skills: Practical Steps for Developers
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Mar 23, 2020 · Fundamentals

Mastering Software Architecture Patterns: From Layered to Cloud‑Native

This article explains the classic definition of patterns, introduces architecture patterns, and reviews five common software architecture styles—layered, microservices, microkernel, event‑driven, and cloud‑native—detailing their principles, advantages, drawbacks, and typical use cases, helping developers choose the right structure for complex systems.

Cloud NativeDesign PatternsMicroservices
0 likes · 14 min read
Mastering Software Architecture Patterns: From Layered to Cloud‑Native
Senior Brother's Insights
Senior Brother's Insights
Mar 21, 2020 · Backend Development

Master Java Proxy: From Static to JDK Dynamic Proxy with Real Code

This article explains the proxy design pattern, shows how to implement static proxies in Java with concrete code examples, discusses their limitations, and then demonstrates JDK dynamic proxies using InvocationHandler and Proxy classes, including generated proxy class details.

Design PatternsDynamic ProxyJDK
0 likes · 13 min read
Master Java Proxy: From Static to JDK Dynamic Proxy with Real Code