BestHub
Sign in
Tagged articles

Design Patterns

967 articles · Page 8 of 10
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 PatternsMVCMicroservices
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.

Design PatternsMemory ManagementPerformance
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 PatternsPythonclean code
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.

BackendDependency InjectionDesign Patterns
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.

Design PatternsFacadeProxy
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.

CSSCSS-in-JSDesign Patterns
0 likes · 19 min read
Why CSS-in-JS Is Revolutionizing Frontend Development: History, Patterns, and Future
Top Architect
Top Architect
Feb 22, 2021 · Backend Development

Lazy Initialization and Lazy Loading in Java: Using Supplier, Streams, and Virtual Proxy Patterns

This article explains the concepts of eager versus lazy evaluation in Java, presents common scenarios for lazy initialization, demonstrates how to implement lazy loading with Supplier, virtual proxy, and delegate patterns, and shows practical Stream examples including infinite prime number generation.

Design PatternsLazy InitializationStream
0 likes · 11 min read
Lazy Initialization and Lazy Loading in Java: Using Supplier, Streams, and Virtual Proxy Patterns
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
Architect's Tech Stack
Architect's Tech Stack
Feb 18, 2021 · Backend Development

Summary of Design Patterns Used in the Spring Framework

This article provides a comprehensive overview of how Spring implements classic design patterns such as Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, and Template Method, explaining their implementation details, underlying principles, and practical code examples within the Spring container.

Dependency InjectionDesign PatternsSpring
0 likes · 15 min read
Summary of Design Patterns Used in the Spring Framework
21CTO
21CTO
Feb 15, 2021 · Backend Development

From Java Developer to Architect: Lessons on Building High‑Concurrency Systems

The author reflects on their path from a senior Java developer to a software architect, describing early misconceptions, the pitfalls of over‑focusing on code, the importance of mastering existing components, and how design patterns and maintainability become essential when assembling high‑concurrency, distributed architectures.

Design Patternscomponent integrationdistributed systems
0 likes · 8 min read
From Java Developer to Architect: Lessons on Building High‑Concurrency Systems
Java Captain
Java Captain
Feb 13, 2021 · Backend Development

How Spring Solves Circular Dependencies and the Underlying Essence

This article explains how Spring resolves circular dependencies in singleton beans using a three‑level cache, contrasts it with prototype beans, provides a minimal reflective implementation, and draws an analogy to the classic two‑sum algorithm to illustrate the core principle.

BackendDependency InjectionDesign Patterns
0 likes · 9 min read
How Spring Solves Circular Dependencies and the Underlying Essence
ITPUB
ITPUB
Feb 10, 2021 · Backend Development

From Java Developer to Architect: Lessons on High‑Concurrency Systems and Component‑Based Design

The author shares a personal journey from senior Java developer to aspiring architect, reflecting on interview mishaps, the pitfalls of over‑focusing on code, the importance of leveraging existing components, integrating them effectively, and applying design patterns for reusable, maintainable high‑concurrency systems.

Backend DevelopmentDesign Patternscomponent integration
0 likes · 10 min read
From Java Developer to Architect: Lessons on High‑Concurrency Systems and Component‑Based Design
Alibaba Cloud Developer
Alibaba Cloud Developer
Feb 10, 2021 · Frontend Development

Why CSS-in-JS Is Revolutionizing Modern Frontend Development

This article traces the evolution of CSS from its early specifications through modular standards, design patterns, and preprocessors, then dives deep into CSS‑in‑JS, Houdini, popular libraries, their advantages and drawbacks, industry adoption, and future directions for web styling.

CSSCSS-in-JSDesign Patterns
0 likes · 19 min read
Why CSS-in-JS Is Revolutionizing Modern Frontend Development
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 DevelopmentDependency InjectionDesign Patterns
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.

ArchitectureBackendDesign Patterns
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.

API GatewayCQRSCircuit Breaker
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
Nullbody Notes
Nullbody Notes
Jan 12, 2021 · Fundamentals

How to Dynamically Add Features in Go Using the Decorator Pattern

The article explains the Decorator pattern in Go, defining it as a way to add behavior to objects without altering their structure, illustrates the concept with everyday analogies and provides complete Go code examples—including a basic Showable interface, a plain Girl struct, and makeup decorators that wrap the original object—to demonstrate how layered decorations work transparently at runtime.

Decorator PatternDesign PatternsGo
0 likes · 4 min read
How to Dynamically Add Features in Go Using the Decorator Pattern
Nullbody Notes
Nullbody Notes
Jan 11, 2021 · Fundamentals

Understanding Go's Composite Pattern: Building Hierarchical Structures

This article explains the Composite (part‑whole) design pattern in Go, illustrates its concept with natural and file‑system analogies, and provides complete Go code demonstrating how files and folders can be treated uniformly as tree nodes.

Composite PatternDesign PatternsFile System
0 likes · 6 min read
Understanding Go's Composite Pattern: Building Hierarchical Structures
网易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 Theorygame UI
0 likes · 9 min read
How the Iceberg Theory Transforms Game UI Design: From Conscious to Unconscious
Nullbody Notes
Nullbody Notes
Jan 7, 2021 · Fundamentals

Understanding the Bridge Pattern in Go: Decoupling Shapes and Pens

This article explains the Bridge design pattern in Go by defining its purpose, illustrating how Shape and Pen interfaces can be combined through a Bridge struct, and providing a complete Go code example that demonstrates interchangeable colors and shapes.

Bridge PatternDesign PatternsGo
0 likes · 3 min read
Understanding the Bridge Pattern in Go: Decoupling Shapes and Pens
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.

Circuit BreakerDesign PatternsMicroservices
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.

CGLIBDesign PatternsJDK 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
Nullbody Notes
Nullbody Notes
Dec 16, 2020 · Fundamentals

Understanding the Adapter Pattern in Go

The article explains the Adapter pattern by defining its purpose, illustrating the concept with mobile charging ports, and providing a complete Go code example that shows how to wrap incompatible interfaces so they can work together through adapters.

Adapter PatternCode ExampleDesign Patterns
0 likes · 3 min read
Understanding the Adapter Pattern in Go
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 PatternsMVCMicroservices
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 Javabest practices
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.

AOPBackend DevelopmentDependency Injection
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.

AOPDesign PatternsInterceptor
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 PatternsMVCevent-driven
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 PatternsEvent BusMVC
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 Patternsdatabaseindexing
0 likes · 9 min read
Technical Interview Q&A: MySQL, Indexing, Design Patterns, Algorithms, Networking, and Concurrency
Nullbody Notes
Nullbody Notes
Nov 18, 2020 · Fundamentals

Understanding the Prototype Pattern in Go: Clone Objects Efficiently

This article explains the Prototype design pattern in Go, shows how to clone objects with various implementations, compares their effects on object independence, and clarifies Go's value‑semantic parameter passing using concrete code examples and detailed analysis.

CloneDesign PatternsPrototype Pattern
0 likes · 8 min read
Understanding the Prototype Pattern in Go: Clone Objects Efficiently
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.

Design Patternscareer developmentdistributed 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.

AlgorithmsDesign Patternscareer development
0 likes · 28 min read
Top 25 Must‑Read Programming Books Every Developer Should Own
Nullbody Notes
Nullbody Notes
Nov 15, 2020 · Fundamentals

Factory Method Pattern in Go: A Foodie's Take on Object Creation

This article walks through implementing Simple Factory and Factory Method patterns in Go, showing how to encapsulate object creation with a Food interface, concrete types, and factory structs, and explains the pointer vs value implementation rules and design‑principle benefits.

Design PatternsGoSimple Factory
0 likes · 7 min read
Factory Method Pattern in Go: A Foodie's Take on Object Creation
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 PatternsInterceptorRetrofit
0 likes · 15 min read
Designing a Network Framework from Scratch and Analyzing OkHttp & Retrofit Implementations
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 PatternsOOPStrategy Pattern
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.

ArchitectureDesign Patternsevent-driven
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 Patternscoding test
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 PatternsMVCevent-driven
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.

Design PatternsR&D managementcareer development
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 PatternReflection
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 PatternsGRASPResponsibility-Driven Design
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 PatternsThreadBasegenerics
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.

Design PatternsState Patternbehavioral
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 FactoryDependency InjectionDesign Patterns
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.

Data PipelineDesign PatternsFlink
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 ContainerDependency InjectionDesign Patterns
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 PatternsRecallRecruitment
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 PatternsOOP
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 PatternsPHP
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 PrincipleStrategy Pattern
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.

Dependency InjectionDesign PatternsIOC
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 PatternsOOPOpen-Closed Principle
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.

Deep CopyDesign PatternsPrototype 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.

ArchitectureDesign PatternsResource 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.

BackendDependency InjectionDesign Patterns
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.

AOPCGLIBDesign Patterns
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.

API DesignDesign PatternsStatic 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.

ArchitectureCOLADesign Patterns
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 PatternsEnum
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.

BackendCallbackDesign 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 PatternsMicroservicesarchitecture styles
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 PatternsSOLIDobject-oriented
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 Patternscode qualityif-else
0 likes · 19 min read
Eliminating Overused if…else Statements: Refactoring Techniques and Design Patterns