Skip to content
Tagged articles

Design Patterns

500 articles · Page 2 of 5
LuTiao Programming
LuTiao Programming
Apr 22, 2026 · Fundamentals

Stop Memorizing Design Patterns: Modern Strategy Pattern with Java 21+ Sealed Interfaces and Pattern Matching

The article critiques the classic interface‑plus‑N‑implementations Strategy Pattern for causing class explosion, then demonstrates how Java 17’s sealed interfaces and records together with Java 21’s pattern‑matching switch provide a more concise, type‑safe, and maintainable modern implementation.

Design PatternsJavaJava 21
0 likes · 7 min read
Stop Memorizing Design Patterns: Modern Strategy Pattern with Java 21+ Sealed Interfaces and Pattern Matching
Top Architect
Top Architect
Apr 22, 2026 · Backend Development

Unify Multi-Channel Login with Spring Boot Factory & Strategy Patterns

Learn how to replace tangled if‑else login code with a clean, extensible architecture using Spring Boot, combining the Factory pattern to instantiate strategy beans and the Strategy pattern to encapsulate each login method (password, WeChat, SMS, etc.), enabling easy addition of new authentication types.

AuthenticationDesign PatternsFactory Pattern
0 likes · 14 min read
Unify Multi-Channel Login with Spring Boot Factory & Strategy Patterns
Tech Minimalism
Tech Minimalism
Apr 22, 2026 · Artificial Intelligence

14 Reusable Agent Skill Design Patterns from Anthropic’s Official Best Practices

Anthropic’s official skill authoring guide outlines fourteen reusable design patterns for Agent Skills—grouped into discovery & selection, context economy, instruction calibration, workflow control, and executable code—each with concrete examples, trade‑offs, and practical tips to help developers craft effective, token‑efficient Claude extensions.

AIAnthropicClaude
0 likes · 21 min read
14 Reusable Agent Skill Design Patterns from Anthropic’s Official Best Practices
FunTester
FunTester
Apr 21, 2026 · Fundamentals

What Real-World Code Changes Teach About Low‑Level Design

The author recounts how maintaining and evolving a long‑lived production system exposed hidden costs of poor low‑level design, leading to a shift from pattern‑first thinking to change‑driven analysis, small incremental refactorings, and ultimately a calmer, more maintainable codebase.

Code MaintainabilityDesign Patternslow-level design
0 likes · 16 min read
What Real-World Code Changes Teach About Low‑Level Design
DeepHub IMBA
DeepHub IMBA
Apr 21, 2026 · Artificial Intelligence

Designing Persistent Memory for Production AI Agents: A Five‑Stage Pipeline and Four Design Patterns

Production AI agents require persistent memory to maintain continuity, learn from interactions, and recover from failures, but naïvely stuffing full conversation history into the LLM context incurs prohibitive latency and cost; this article outlines four memory types, a five‑stage pipeline, four design patterns, and practical metrics for building efficient, auditable memory systems.

AI agentsDesign PatternsLLM
0 likes · 27 min read
Designing Persistent Memory for Production AI Agents: A Five‑Stage Pipeline and Four Design Patterns
Data STUDIO
Data STUDIO
Apr 21, 2026 · Backend Development

Build Once, Reuse Anywhere: Generic Repository Pattern in Python

The article demonstrates how to eliminate repetitive CRUD code in FastAPI projects by creating a type‑safe, generic repository using Python generics and SQLAlchemy, showing a concrete abstract base class, concrete implementations, custom filters, error handling, and real‑world metrics that cut repository code from hundreds to a few dozen lines.

CRUDDesign PatternsFastAPI
0 likes · 13 min read
Build Once, Reuse Anywhere: Generic Repository Pattern in Python
Machine Learning Algorithms & Natural Language Processing
Machine Learning Algorithms & Natural Language Processing
Apr 14, 2026 · Artificial Intelligence

Why Harness Is the Strategic Asset for AI Agents in 2026

The article analyzes the 2026 turning point where AI model intelligence plateaued and argues that mastering Harness—an infrastructure that wraps models—has become the decisive factor for building controllable, scalable Agent systems, tracing its necessity through three decades of software engineering evolution.

AI agentsClaude CodeDeepMind
0 likes · 20 min read
Why Harness Is the Strategic Asset for AI Agents in 2026
Code Ape Tech Column
Code Ape Tech Column
Apr 14, 2026 · Artificial Intelligence

6 Essential AI Agent Design Patterns Every Developer Should Master

This article explores six practical AI Agent design patterns—ReAct, Tool Use, Reflection, Planning, Multi‑Agent, and Human‑in‑the‑Loop—detailing their principles, Java Spring AI implementations, advantages, drawbacks, and suitable scenarios, and provides guidance on selecting and combining them for robust AI applications.

AIAgentDesign Patterns
0 likes · 19 min read
6 Essential AI Agent Design Patterns Every Developer Should Master
Top Architect
Top Architect
Apr 10, 2026 · Backend Development

Essential Microservice Design Patterns Every Architect Should Know

This article provides a comprehensive overview of microservice architecture, outlining its core goals, design principles, and a wide range of decomposition, integration, database, event‑driven, observability, and cross‑cutting concern patterns, complete with practical examples and diagrams.

Backend ArchitectureDesign Patternsmicroservices
0 likes · 22 min read
Essential Microservice Design Patterns Every Architect Should Know
Top Architect
Top Architect
Apr 7, 2026 · Backend Development

Why Over‑Design Breaks Your Code and How a Flow Engine Restores Simplicity

The article explains how excessive if‑else branching in backend services leads to fragile code, introduces a workflow engine and plugin extension mechanism to isolate business logic, shows concrete configuration and execution steps using the open‑source MemberClub project, and provides the full Java implementation of the FlowChain executor.

Design Patternsbackend developmentworkflow engine
0 likes · 11 min read
Why Over‑Design Breaks Your Code and How a Flow Engine Restores Simplicity
Top Architect
Top Architect
Apr 5, 2026 · Backend Development

Designing a Robust Asynchronous Processing SDK with Spring, Kafka and MySQL

This article explains the design, principles, components, database schema, configuration, and usage of a generic asynchronous processing SDK that leverages Spring AOP, transactional events, Kafka, and a Vue UI to achieve reliable async execution and eventual consistency in Java backend systems.

Design PatternsMySQLSDK
0 likes · 11 min read
Designing a Robust Asynchronous Processing SDK with Spring, Kafka and MySQL
Shuge Unlimited
Shuge Unlimited
Mar 31, 2026 · Artificial Intelligence

5 Agent Design Patterns Uncovered in Claude Code Source Leak

The article dissects the accidental public release of Anthropic's Claude Code TypeScript source, revealing five concrete AI agent design patterns—including prompt‑cache segmentation, a coordinator‑fork architecture, a four‑layer permission model, file‑system memory, and on‑demand tool loading—while also detailing the underlying tech stack, source‑map exposure, and quirky easter eggs.

AI agentClaude CodeCoordinator
0 likes · 17 min read
5 Agent Design Patterns Uncovered in Claude Code Source Leak
Top Architect
Top Architect
Mar 30, 2026 · Databases

How MyBatis Uses Over 10 Design Patterns to Simplify ORM Architecture

The article analyzes MyBatis’s 20,000‑line source code, showing how it applies more than ten classic design patterns—such as Factory, Singleton, Builder, Adapter, Proxy, Composite, Decorator, Template, Strategy, and Iterator—to decouple complex ORM scenarios, improve extensibility, and illustrate practical implementation details.

Design PatternsJavaMyBatis
0 likes · 12 min read
How MyBatis Uses Over 10 Design Patterns to Simplify ORM Architecture
Java One
Java One
Mar 28, 2026 · Artificial Intelligence

Five Core Design Patterns for Building Robust AI Agents with Google ADK

This guide translates Google Cloud Tech's Agent Skills design patterns, detailing five reusable architecture patterns—Tool Wrapper, Generator, Reviewer, Inversion, and Pipeline—that help developers create modular, maintainable, and composable AI agents using the Agent Development Kit (ADK).

AI agentDesign PatternsGoogle ADK
0 likes · 16 min read
Five Core Design Patterns for Building Robust AI Agents with Google ADK
Golang Shines
Golang Shines
Mar 26, 2026 · Artificial Intelligence

Essential AI Agent Design Patterns and Frameworks for Operations: Do You Know Them?

The article explains seven multi‑agent design patterns—workflow, routing, parallel, loop, aggregation, network, and hierarchy—detailing their mechanisms, use‑cases, and trade‑offs, then surveys popular agent frameworks (AutoGPT, Dify, AutoGen, CrewAI, LangGraph) and why they are needed for complex, dynamic decision‑making tasks.

AI agentDesign PatternsParallel
0 likes · 12 min read
Essential AI Agent Design Patterns and Frameworks for Operations: Do You Know Them?
java1234
java1234
Mar 24, 2026 · Backend Development

Key Design Patterns Used in the Spring Framework

This article explains how Spring employs five core design patterns—Factory, Singleton, Proxy, Observer, and Template Method—detailing their roles, code examples, and how they contribute to Spring's modular, extensible architecture.

Design PatternsFactory PatternProxy
0 likes · 8 min read
Key Design Patterns Used in the Spring Framework
IT Services Circle
IT Services Circle
Mar 22, 2026 · Fundamentals

Bridging Incompatible C++ Logging Interfaces with the Adapter Pattern

This article explains how to use class and object adapters in C++ to reconcile mismatched logging interfaces, allowing seamless integration of third‑party loggers without modifying existing system code, and demonstrates the transition from inheritance‑based adapters to composition‑based adapters for greater flexibility.

Adapter PatternC++Class Adapter
0 likes · 8 min read
Bridging Incompatible C++ Logging Interfaces with the Adapter Pattern
Java Tech Enthusiast
Java Tech Enthusiast
Mar 22, 2026 · Backend Development

How to Bridge Incompatible C++ Logging Interfaces with Adapter Patterns

A C++ developer faces a mismatched logging API between an internal ILogger interface and a third‑party FastLogger library, and the article walks through class‑adapter inheritance, its limitations, and a more flexible object‑adapter composition solution that enables runtime switching across multiple logger implementations.

Adapter PatternC++Composition
0 likes · 9 min read
How to Bridge Incompatible C++ Logging Interfaces with Adapter Patterns
ShiZhen AI
ShiZhen AI
Mar 22, 2026 · Artificial Intelligence

5 Google-Defined Agent Skill Design Patterns: From Tool Wrapper to Pipeline

Google's ADK team outlines five recurring Agent Skill design patterns—Tool Wrapper, Generator, Reviewer, Inversion, and Pipeline—each solving a concrete pain point, with advantages, suitable scenarios, and ready‑to‑use YAML prompt examples for building more effective AI agents.

AI agentAgent SkillDesign Patterns
0 likes · 17 min read
5 Google-Defined Agent Skill Design Patterns: From Tool Wrapper to Pipeline
SuanNi
SuanNi
Mar 19, 2026 · Artificial Intelligence

5 Proven Design Patterns for Building Smarter Google AI Agents

Google's engineers distilled five recurring design patterns for Agent Skills—Tool Wrapper, Generator, Reviewer, Inversion, and Pipeline—providing concrete guidance, example implementations, and visual decision trees to help developers craft more reliable and context‑aware AI agents.

AI agentsAgent Development KitDesign Patterns
0 likes · 9 min read
5 Proven Design Patterns for Building Smarter Google AI Agents
Wuming AI
Wuming AI
Mar 18, 2026 · Artificial Intelligence

5 Proven Design Patterns to Supercharge Your AI Agent Skills

This article dissects five practical design patterns—Tool Wrapper, Generator, Reviewer, Inversion, and Pipeline—explaining when each solves a specific problem, showing concrete SKILL.md examples, step‑by‑step instructions, and a GitHub optimizer tool that automatically refines your agent skills.

AI agentsDesign PatternsSkill Development
0 likes · 13 min read
5 Proven Design Patterns to Supercharge Your AI Agent Skills
AI Engineering
AI Engineering
Mar 18, 2026 · Artificial Intelligence

5 Proven Agent Skill Design Patterns Google Shares After Anthropic

Google Cloud’s new guide outlines five validated Agent Skill design patterns—Tool Wrapper, Generator, Reviewer, Inversion, and Pipeline—explaining their structures, use‑cases, and how combining them can produce reliable, token‑efficient workflows for AI agents.

AIDesign PatternsGoogle Cloud
0 likes · 7 min read
5 Proven Agent Skill Design Patterns Google Shares After Anthropic
Cloud Architecture
Cloud Architecture
Mar 18, 2026 · Backend Development

10 Classic Spring Boot Design Patterns to Refactor Your Business Code

This article walks through ten classic design patterns—Factory, Proxy, Template Method, Strategy, Observer, Chain of Responsibility, Singleton, Builder, Adapter, and Decorator—showing how they are realized in Spring Boot 3.x with concrete e‑commerce, payment, and user‑system examples, and explains their benefits, trade‑offs, and best‑practice usage.

BuilderDesign PatternsFactory Pattern
0 likes · 39 min read
10 Classic Spring Boot Design Patterns to Refactor Your Business Code
LuTiao Programming
LuTiao Programming
Mar 13, 2026 · Backend Development

Why Your Spring Boot Code Is Hard to Maintain—and How the Builder Pattern Solves It

The article explains how the Builder pattern in Spring Boot eliminates the telescoping‑constructor and unsafe‑setter problems of complex objects, improves readability, immutability and maintainability, shows hand‑written and Lombok implementations, provides usage examples for DTOs, API responses and queries, and offers best‑practice guidelines.

Builder PatternDesign PatternsImmutable
0 likes · 10 min read
Why Your Spring Boot Code Is Hard to Maintain—and How the Builder Pattern Solves It
Top Architect
Top Architect
Mar 11, 2026 · Backend Development

Why Over‑Engineered Architecture Fails: Real‑World Lessons from a Code Review

A senior architect recounts a code review where a colleague wrapped a simple two‑payment‑method order system in strategy, factory, and abstract‑factory patterns, then explains why such over‑design hurts maintainability, when to apply complex patterns, and practical guidelines for clean backend architecture.

Design Patternssoftware architecture
0 likes · 13 min read
Why Over‑Engineered Architecture Fails: Real‑World Lessons from a Code Review
SuanNi
SuanNi
Mar 4, 2026 · Artificial Intelligence

How Skills Empower Autonomous Agents: Architecture, Design Patterns, and Security Risks

The article provides an in‑depth analysis of the Skills mechanism that gives large language model agents reusable procedural memory, detailing its core components, seven design patterns, real‑world security threats, evaluation benchmarks, and the challenges of safely scaling autonomous AI systems.

AI agentsDesign Patternsautonomous systems
0 likes · 14 min read
How Skills Empower Autonomous Agents: Architecture, Design Patterns, and Security Risks
IT Services Circle
IT Services Circle
Feb 26, 2026 · Interview Experience

Master C++ friend: 5 Levels of Usage Every Interview Candidate Should Know

This article walks through the five practical levels of using C++ friend— from a quick syntax recap to operator overloads, factory functions, iterator access, swap idiom, and the Passkey pattern—explaining when and why each scenario warrants a friend declaration and how it impacts encapsulation and interview performance.

C++Design Patternsaccess control
0 likes · 14 min read
Master C++ friend: 5 Levels of Usage Every Interview Candidate Should Know
Data STUDIO
Data STUDIO
Feb 26, 2026 · Fundamentals

Stop Using a Monolithic utils.py: 3 Design Patterns to Make Your Python Code Cleaner

The article explains why a sprawling utils.py becomes a maintenance nightmare in Python projects, outlines three concrete patterns—module‑level placement, class‑based methods, and small dedicated modules—to restructure code, and provides decision criteria for when a function truly belongs in a utility module.

Design Patternscode organizationmodularization
0 likes · 11 min read
Stop Using a Monolithic utils.py: 3 Design Patterns to Make Your Python Code Cleaner
Architect's Guide
Architect's Guide
Feb 26, 2026 · Backend Development

8 Essential Software Architecture Patterns and When to Use Them

This article explains eight common software architecture patterns—from single‑database apps to microservices, caching, sharding, elastic scaling and multi‑datacenter deployment—detailing their designs, typical use cases, advantages, drawbacks, and practical implementation steps.

Design PatternsElastic Scalingbackend scaling
0 likes · 23 min read
8 Essential Software Architecture Patterns and When to Use Them
java1234
java1234
Feb 24, 2026 · Backend Development

Why Most Backend Architecture Patterns Are Over‑Engineered

A code‑review anecdote shows that developers often apply heavyweight patterns like Abstract Factory, Event Sourcing, CQRS, and DDD to simple payment processing, leading to unnecessary complexity; the article explains why this happens, which patterns truly belong in micro‑service backends, and offers practical, lightweight alternatives together with concrete code examples and review guidelines.

BackendDesign Patternsarchitecture
0 likes · 13 min read
Why Most Backend Architecture Patterns Are Over‑Engineered
Java Companion
Java Companion
Feb 22, 2026 · Backend Development

Why Most Backend Architecture Patterns Are Over‑engineered

A recent code review reveals a colleague using strategy, factory, and abstract‑factory patterns to build a payment system that only needs two methods, exposing how 90 % of classic backend architecture patterns become unnecessary over‑design in modern microservice and cloud‑native environments, and offering practical guidelines for when such complexity truly adds value.

BackendDesign PatternsSpring Boot
0 likes · 13 min read
Why Most Backend Architecture Patterns Are Over‑engineered
DeepNoMind
DeepNoMind
Feb 18, 2026 · Artificial Intelligence

Decentralized Blackboard Collaboration: A High‑Reliability Design Pattern for Agentic AI

This article introduces the decentralized blackboard collaboration pattern for building reliable agentic AI systems, explains its shared data space and specialist agents, demonstrates a customer‑support ticket workflow with analyzer, retriever, and draftsman agents, and highlights benefits such as error reduction, deeper specialization, and auditability.

Agentic AIDecentralized BlackboardDesign Patterns
0 likes · 12 min read
Decentralized Blackboard Collaboration: A High‑Reliability Design Pattern for Agentic AI
LuTiao Programming
LuTiao Programming
Feb 9, 2026 · Backend Development

Stop Memorizing Design Patterns—Use This Engineering Decision Tree to Solve Spring Boot Complexity

The article explains why design patterns often feel useless in Spring Boot projects, introduces a three‑branch decision tree that maps common sources of complexity to suitable patterns, and demonstrates a concrete refactor of an if‑else payment service into a clean, Spring‑managed strategy‑based solution.

Backend ArchitectureDependency InjectionDesign Patterns
0 likes · 9 min read
Stop Memorizing Design Patterns—Use This Engineering Decision Tree to Solve Spring Boot Complexity
Data STUDIO
Data STUDIO
Jan 29, 2026 · Fundamentals

10 Python Design Patterns to Eliminate Spaghetti Code and Build Maintainable Projects

The article explains why architecture matters, introduces ten essential Python design patterns—such as Dependency Injection, Strategy, Builder, Event‑Driven, Repository, Mapper, Pipeline, Command, Specification, and Plugin Registry—with concrete code examples and practical advice to transform messy scripts into clean, scalable applications.

Builder PatternDependency InjectionDesign Patterns
0 likes · 44 min read
10 Python Design Patterns to Eliminate Spaghetti Code and Build Maintainable Projects
DevOps Coach
DevOps Coach
Jan 27, 2026 · Backend Development

7 Essential Kafka Design Patterns Every Engineer Should Master

This guide presents seven practical Kafka design patterns—single‑key single‑write, log compaction, multi‑consumer‑group fan‑out, retry and dead‑letter topics, exactly‑once processing with Streams, schema evolution with Avro, and choreography vs orchestration—detailing when to use each, core principles, code examples, tips, common pitfalls, and final recommendations for building reliable, observable, and maintainable event‑driven systems.

Design PatternsKafkaevent streaming
0 likes · 9 min read
7 Essential Kafka Design Patterns Every Engineer Should Master
Tech Freedom Circle
Tech Freedom Circle
Jan 27, 2026 · Interview Experience

Netease Interview: Write a BlockingQueue in 5 Minutes and Explain Design Patterns & Principles

The article breaks down a common Netease interview task—hand‑coding a BlockingQueue in five minutes—by explaining the underlying lock‑and‑condition mechanism, the relevant design patterns and principles, common pitfalls such as spurious wakeups, and provides a concise, 50‑line Java implementation with step‑by‑step commentary.

BlockingQueueDesign PatternsJava Concurrency
0 likes · 20 min read
Netease Interview: Write a BlockingQueue in 5 Minutes and Explain Design Patterns & Principles
Thought Artisan
Thought Artisan
Jan 16, 2026 · Fundamentals

Building Mental Representations for Software Engineers: From Architecture to Patterns

The article explores how software engineers can develop effective mental representations—covering architecture, concepts, temporal flow, spatial structure, decision knowledge, historical evolution, concerns, features, and patterns—through deliberate practice, abstract thinking, visualization, and inductive/deductive reasoning to enhance code understanding and expertise.

Design Patternscode comprehensioncognitive psychology
0 likes · 4 min read
Building Mental Representations for Software Engineers: From Architecture to Patterns
Tech Freedom Circle
Tech Freedom Circle
Jan 16, 2026 · Interview Experience

Crack JD Interview: Master Singleton, Factory, Strategy, Template & Observer Patterns in 20 Minutes

This article offers a systematic, high‑concurrency‑focused walkthrough of core Java design patterns—including Singleton, Factory, Strategy, Template Method, and Observer—complete with code examples, pros and cons, selection guidelines, and interview‑ready explanations to help candidates impress interviewers and secure offers.

Design PatternsJavaTemplate Method
0 likes · 36 min read
Crack JD Interview: Master Singleton, Factory, Strategy, Template & Observer Patterns in 20 Minutes
Top Architect
Top Architect
Jan 12, 2026 · Backend Development

How to Build a Robust Asynchronous Processing SDK with Spring, Kafka, and XXL‑Job

This article explains the design and implementation of a generic asynchronous processing SDK for Java, covering its purpose, advantages, core principles, component choices, design patterns, configuration via Apollo, usage steps, safety considerations, and provides complete SQL and Spring configuration examples along with a GitHub repository link.

Design PatternsJavaKafka
0 likes · 11 min read
How to Build a Robust Asynchronous Processing SDK with Spring, Kafka, and XXL‑Job
Software Engineering 3.0 Era
Software Engineering 3.0 Era
Jan 11, 2026 · Operations

Using Claude 4.5 + Nano Banana Pro to Reverse‑Engineer Apache JMeter’s Architecture

The article demonstrates how Claude 4.5 combined with Nano Banana Pro can automatically generate detailed design diagrams and analysis of Apache JMeter’s layered architecture, design patterns, extensibility mechanisms, and distributed execution model, showcasing the power of large‑model‑driven architecture inspection.

Apache JMeterClaude 4.5Design Patterns
0 likes · 13 min read
Using Claude 4.5 + Nano Banana Pro to Reverse‑Engineer Apache JMeter’s Architecture
LuTiao Programming
LuTiao Programming
Jan 9, 2026 · Backend Development

Tame Messy Login Logic: 3‑Step Spring Boot Factory & Strategy Pattern for Multi‑Channel Auth

The article shows how tangled if‑else login code caused by adding password, SMS, WeChat, and Alipay authentication can be refactored using the Strategy and Factory patterns in Spring Boot, resulting in a clean, extensible, plug‑in‑style login module that requires no changes to existing code when new methods are added.

AuthenticationDesign PatternsFactory Pattern
0 likes · 10 min read
Tame Messy Login Logic: 3‑Step Spring Boot Factory & Strategy Pattern for Multi‑Channel Auth
Alibaba Cloud Developer
Alibaba Cloud Developer
Jan 8, 2026 · Artificial Intelligence

How to Build Human‑In‑The‑Loop (HITL) Capabilities into ReactAgent

This article explains how to integrate a Human‑In‑The‑Loop (HITL) mechanism into ReactAgent, detailing the motivation, design of interaction, tool description, XML‑based UI rendering, Redis‑driven waiting loop, and the broader architectural parallels with design patterns and other agent frameworks.

AgentDesign PatternsHITL
0 likes · 14 min read
How to Build Human‑In‑The‑Loop (HITL) Capabilities into ReactAgent
dbaplus Community
dbaplus Community
Jan 7, 2026 · Backend Development

Why Our Custom Snowflake ID Collided and How to Build a Reliable Generator

A recent production incident caused duplicate order IDs due to a flawed custom Snowflake implementation, prompting a deep dive into the standard algorithm, analysis of the mistakes, and a set of best‑practice recommendations for designing robust distributed ID generators.

Design PatternsDistributed SystemsJava
0 likes · 7 min read
Why Our Custom Snowflake ID Collided and How to Build a Reliable Generator
Woodpecker Software Testing
Woodpecker Software Testing
Dec 28, 2025 · Backend Development

Deep Dive into JUnit: Core Concepts, Components, and Design Pattern Integration

This comprehensive tutorial explains JUnit's definition, core components, annotations, assertion methods, test suite creation, custom test rules, and how common design patterns such as Factory, Decorator, Strategy, and Template Method can be applied to write flexible, maintainable Java unit tests, plus installation steps and advanced usage tips.

Design PatternsJUnitJava
0 likes · 25 min read
Deep Dive into JUnit: Core Concepts, Components, and Design Pattern Integration
php Courses
php Courses
Dec 4, 2025 · Backend Development

From Procedural PHP to Modern Practices: Transform Your Development Mindset

This article examines how early PHP developers often wrote tangled, procedural code that mixes business logic with presentation, and outlines concrete steps—adopting OOP, design patterns, domain‑driven design, test‑driven development, and modern tooling—to shift toward a cleaner, more maintainable backend development approach.

Design PatternsOOPPHP
0 likes · 7 min read
From Procedural PHP to Modern Practices: Transform Your Development Mindset
IT Services Circle
IT Services Circle
Nov 25, 2025 · Backend Development

ByteDance Backend Interview Secrets: Salary, Design Patterns, HashMap Issues & More

The article shares eye‑opening ByteDance campus salary data, breaks down salary tiers, and then provides detailed interview preparation covering design patterns, HashMap concurrency pitfalls, MySQL indexing rules, query optimization, handling large JSON fields, stock‑decrement bottlenecks, RabbitMQ vs RocketMQ differences, and distributed‑transaction strategies.

BackendDesign PatternsInterview
0 likes · 25 min read
ByteDance Backend Interview Secrets: Salary, Design Patterns, HashMap Issues & More
Liangxu Linux
Liangxu Linux
Nov 22, 2025 · Fundamentals

How to Build a Scalable Embedded Power‑Management Framework with Observer and Responsibility Chains

This article explains how AIoT‑era embedded devices evolve from simple C/assembly code to reusable, portable frameworks by applying design patterns such as the Observer pattern and a custom responsibility‑chain model for low‑power management, complete with code examples, memory‑pool handling, and test cases.

AIoTDesign PatternsEmbedded
0 likes · 16 min read
How to Build a Scalable Embedded Power‑Management Framework with Observer and Responsibility Chains
Tech Freedom Circle
Tech Freedom Circle
Nov 17, 2025 · Backend Development

Spring Design Patterns Interview: The One Question That Can Make or Break Your Offer

This article breaks down Spring’s layered architecture and walks through ten core design patterns—factory, singleton, proxy, template method, observer, adapter, decorator, strategy, chain of responsibility, facade, and delegate—showing how they appear in real interview scenarios and how mastering them can turn a tough interview question into a winning advantage.

Design PatternsInterviewJava
0 likes · 50 min read
Spring Design Patterns Interview: The One Question That Can Make or Break Your Offer
Su San Talks Tech
Su San Talks Tech
Nov 17, 2025 · Backend Development

Unlock Tomcat’s Secrets: Deep Dive into Its Architecture, Design Patterns, and Class Loading

This article provides a comprehensive technical walkthrough of Tomcat, covering its connector and container architecture, lifecycle management, key design patterns such as Composite and Template Method, custom class‑loading mechanisms, hot‑reload process, and includes essential code snippets and diagrams for developers.

Class LoaderDesign PatternsJava
0 likes · 43 min read
Unlock Tomcat’s Secrets: Deep Dive into Its Architecture, Design Patterns, and Class Loading
Architect
Architect
Nov 16, 2025 · Backend Development

Unlocking MyBatis: 10 Design Patterns Powering Its Architecture

The article examines how MyBatis leverages around ten classic design patterns—grouped into Creational, Structural, and Behavioral categories—to decouple complex ORM logic, describing each pattern’s role, typical usage scenarios, and related components within the framework.

Design PatternsJavaMyBatis
0 likes · 12 min read
Unlocking MyBatis: 10 Design Patterns Powering Its Architecture
Code Wrench
Code Wrench
Nov 13, 2025 · Backend Development

Unlock Go’s Structural & Architectural Patterns with Real-World Code

This guide explores key Go structural and architectural design patterns—Adapter, Decorator, Proxy, Bridge, Composite, Flyweight, Facade, Pipeline & Filter, Event Bus, Microkernel, and Dependency Injection—providing definitions, core ideas, Go implementations, and practical use cases to build scalable, maintainable systems.

Design PatternsGoStructural Patterns
0 likes · 13 min read
Unlock Go’s Structural & Architectural Patterns with Real-World Code
Java Architect Essentials
Java Architect Essentials
Oct 30, 2025 · Backend Development

How Enums Can Eliminate Messy if‑else Chains in Java Payment Logic

This article explains why traditional if‑else payment routing is hard to maintain, demonstrates how Java enums combined with functional interfaces and the strategy pattern can centralize behavior, improve extensibility, and integrate cleanly with Spring, providing a robust, testable solution for payment channel selection.

Design PatternsEnumJava
0 likes · 10 min read
How Enums Can Eliminate Messy if‑else Chains in Java Payment Logic
360 Zhihui Cloud Developer
360 Zhihui Cloud Developer
Oct 24, 2025 · Artificial Intelligence

7 Essential Agent Design Patterns for Building Autonomous AI Systems

This article explains the fundamental differences between workflows and agents, introduces seven core design patterns—including three workflow patterns and four agent patterns—provides Python examples using Ollama, and shows how to combine these patterns to create robust, autonomous AI applications.

AI agentsDesign PatternsLLM
0 likes · 30 min read
7 Essential Agent Design Patterns for Building Autonomous AI Systems
JavaGuide
JavaGuide
Oct 21, 2025 · Backend Development

Xiaohongshu’s Explosive Salaries and a Complete Backend Interview Guide

The article reveals Xiaohongshu’s unusually high 2023 campus recruitment packages—over 51 w annual total—while also providing an extensive backend interview preparation guide covering TCP vs UDP differences, design patterns, workflow versus rule engines, message‑queue selection, and Redis data structures and eviction policies.

Design PatternsMessage QueueRedis
0 likes · 32 min read
Xiaohongshu’s Explosive Salaries and a Complete Backend Interview Guide
Ray's Galactic Tech
Ray's Galactic Tech
Oct 19, 2025 · Fundamentals

Master Java Design Patterns: From GoF Classics to Modern Architecture

This comprehensive guide explains why design patterns matter, links them to SOLID principles, enumerates the 23 classic GoF patterns with Java examples, compares commonly confused patterns, introduces modern architectural patterns, shows how they integrate with Spring, and offers a practical learning roadmap for developers.

Design PatternsJavaSOLID
0 likes · 8 min read
Master Java Design Patterns: From GoF Classics to Modern Architecture
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Oct 19, 2025 · Backend Development

16+ Proven Techniques to Refactor Java If‑Else into Clean, Maintainable Code

This article presents over sixteen practical refactoring methods for Java, demonstrating how to replace tangled if‑else statements with clearer constructs such as early returns, ternary operators, switch‑case, guard clauses, optional handling, enums, reflection, strategy, and table‑driven approaches, each illustrated with concise code examples.

Design PatternsJavaSpring Boot
0 likes · 16 min read
16+ Proven Techniques to Refactor Java If‑Else into Clean, Maintainable Code
Ubiquitous Tech
Ubiquitous Tech
Oct 17, 2025 · Artificial Intelligence

6 Essential AI Agent Design Patterns for Efficient Workflows

This article presents six practical AI Agent design patterns—chain, parallel, routing, coordinator‑executor, generator‑evaluator (reflection), and tool‑use—explaining their concepts, typical use cases, and workflow diagrams, and shows how they improve reliability, maintainability, and performance of LLM‑driven applications.

AI agentDesign PatternsLLM
0 likes · 20 min read
6 Essential AI Agent Design Patterns for Efficient Workflows
JavaScript
JavaScript
Oct 16, 2025 · Frontend Development

10 Cleaner Alternatives to if‑else in JavaScript

This guide shows how to replace verbose if‑else chains in JavaScript with cleaner techniques such as object mapping, Array.includes, ternary operators, logical shortcuts, switch statements, Proxy interception, functional patterns, state machines, and decorators, providing concise code examples for each method.

Conditional LogicDesign PatternsJavaScript
0 likes · 3 min read
10 Cleaner Alternatives to if‑else in JavaScript
Architect's Guide
Architect's Guide
Sep 28, 2025 · Backend Development

Mastering Microservice Design Patterns: When, Why, and How to Apply Them

An in‑depth guide to microservice architecture explores its evolution, core characteristics, advantages and drawbacks, and walks through essential design patterns—Database per Service, Event Sourcing, CQRS, Saga, BFF, API Gateway, Strangler, Circuit Breaker, Externalized Configuration, and Consumer‑Driven Contract Testing—detailing when and why to use each.

Backend ArchitectureDesign Patterns
0 likes · 28 min read
Mastering Microservice Design Patterns: When, Why, and How to Apply Them
php Courses
php Courses
Sep 26, 2025 · Backend Development

Master PHP OOP: 5 Best Practices to Write Clean, Maintainable Code

Learn essential PHP object‑oriented programming techniques, including grouping data and behavior into classes, using access modifiers, initializing objects with constructors, chaining methods, and applying the strategy pattern, to boost code readability, maintainability, and flexibility.

Design PatternsOOPPHP
0 likes · 4 min read
Master PHP OOP: 5 Best Practices to Write Clean, Maintainable Code
Liangxu Linux
Liangxu Linux
Sep 25, 2025 · Fundamentals

Decoupling Embedded Systems: Layers, Event‑Driven Design, and Dependency Injection

This guide explains how to achieve clean decoupling in embedded software by employing a systematic layered architecture, leveraging event‑driven and pipeline‑filter patterns for data flow, and applying dependency injection, complete with practical C code examples and best‑practice recommendations for resource‑constrained devices.

Dependency InjectionDesign Patternsc-programming
0 likes · 17 min read
Decoupling Embedded Systems: Layers, Event‑Driven Design, and Dependency Injection
Zhixing ZXD Design Center
Zhixing ZXD Design Center
Sep 23, 2025 · Product Management

How Uber, Maoyan, Gaode, Ant Fortune & Taobao Turn Waiting into Play: 5 Design Cases

This article showcases five recent UI/UX case studies—from Uber's waiting‑time game to Taobao's flash‑sale draw—illustrating how interactive design, gamification, data‑backed rankings, AI assistance, and clever reward mechanics can boost user engagement, reduce friction, and drive conversion across mobile products.

Design PatternsUI innovationUX Design
0 likes · 7 min read
How Uber, Maoyan, Gaode, Ant Fortune & Taobao Turn Waiting into Play: 5 Design Cases
JD Tech Talk
JD Tech Talk
Sep 18, 2025 · Fundamentals

Mastering the Strategy Pattern in Java: Real-World Spring Implementation

This article explains the Strategy (Policy) Pattern, illustrates its structure, and demonstrates a practical Spring-based implementation where different message types are processed by distinct strategy services, using an enum to map types to beans for flexible, interchangeable algorithms.

Dependency InjectionDesign PatternsSpring
0 likes · 4 min read
Mastering the Strategy Pattern in Java: Real-World Spring Implementation
JD Cloud Developers
JD Cloud Developers
Sep 18, 2025 · Fundamentals

Mastering the Strategy Pattern in Spring: Dynamic Message Processing Explained

This article introduces the Strategy design pattern, explains its core concept of interchangeable algorithms, and demonstrates a practical Spring-based implementation that routes various message types to specific services using an enum‑driven bean lookup, enabling flexible updates to Elasticsearch for merchant search and analytics.

Dependency InjectionDesign PatternsSpring
0 likes · 3 min read
Mastering the Strategy Pattern in Spring: Dynamic Message Processing Explained
Architect's Guide
Architect's Guide
Sep 16, 2025 · Backend Development

How to Replace Clunky if‑else Chains with Elegant Java Patterns

This article shares practical techniques for reducing verbose if‑else statements in Java, covering strategy‑enum patterns, ternary operators, Stream API methods, Map lookups, enums, and Optional, each illustrated with concise code examples to make conditional logic clearer and more maintainable.

Design PatternsJavaStream API
0 likes · 9 min read
How to Replace Clunky if‑else Chains with Elegant Java Patterns
IT Services Circle
IT Services Circle
Sep 13, 2025 · Fundamentals

When to Replace if‑else with Strategy Pattern in Embedded Systems

This article compares traditional if‑else/switch‑case branching with the Strategy design pattern in embedded development, illustrating their differences through analogies and code examples, and explains when to adopt Strategy for better extensibility, lower coupling, and maintainability while noting scenarios where simple branching remains preferable.

Design Patternsembedded systemsif-else
0 likes · 12 min read
When to Replace if‑else with Strategy Pattern in Embedded Systems
Deepin Linux
Deepin Linux
Sep 10, 2025 · Fundamentals

Unlocking C++ Polymorphism: How Virtual Tables Enable Runtime Flexibility

This article explains how C++ implements polymorphism through virtual functions and vtables, covering static and dynamic polymorphism, memory layout, multiple inheritance, practical code examples, design‑pattern applications, and the importance of virtual destructors for safe resource cleanup.

C++Design PatternsOOP
0 likes · 35 min read
Unlocking C++ Polymorphism: How Virtual Tables Enable Runtime Flexibility
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 10, 2025 · Fundamentals

How to Effectively Read Open‑Source Code: A Practical Guide

This article outlines a step‑by‑step approach to mastering source‑code reading—starting from using the software, understanding its principles and architecture, learning its workflows, and finally dissecting implementations—to help developers answer interview questions and deepen their technical expertise.

Design PatternsSource Code Readinglearning strategy
0 likes · 3 min read
How to Effectively Read Open‑Source Code: A Practical Guide
Su San Talks Tech
Su San Talks Tech
Sep 10, 2025 · Fundamentals

15 Proven Code Refactoring Techniques to Supercharge Your Java Projects

Learn 15 practical code refactoring techniques—from extracting methods and introducing explanatory variables to applying design patterns like Strategy and Builder—that transform tangled Java code into clean, modular, and maintainable solutions, boosting readability and simplifying future enhancements.

Clean CodeDesign PatternsJava
0 likes · 30 min read
15 Proven Code Refactoring Techniques to Supercharge Your Java Projects
php Courses
php Courses
Sep 4, 2025 · Backend Development

Avoid Common Dependency Injection Pitfalls in PHP and Master Best Practices

This article explains why many PHP developers misuse Dependency Injection, outlines typical misconceptions such as equating DI with container usage, over‑reliance on constructors, and ignoring abstractions, and then provides concrete, testable solutions and best‑practice guidelines.

Dependency InjectionDesign PatternsPHP
0 likes · 6 min read
Avoid Common Dependency Injection Pitfalls in PHP and Master Best Practices
Architect
Architect
Sep 1, 2025 · Fundamentals

Master the State Pattern: Java Basics to Spring StateMachine Order Flow

This article explains the State design pattern, illustrates its advantages over traditional conditional logic, provides a complete Java implementation with abstract state, concrete states, and context classes, demonstrates a real‑world order processing scenario using Spring StateMachine, and discusses related patterns, benefits, and drawbacks.

Design PatternsJavaOrder Processing
0 likes · 19 min read
Master the State Pattern: Java Basics to Spring StateMachine Order Flow
Programmer XiaoFu
Programmer XiaoFu
Sep 1, 2025 · Fundamentals

Advanced Chain of Responsibility: Multi‑Level Validation and Workflow for Elegant Code

This article explains the Chain of Responsibility pattern, shows how to use it for multi‑stage validation and workflow scenarios, walks through a product‑creation example with concrete handlers, configuration via JSON, Spring bean injection, recursive chain assembly, and a reimbursement‑approval workflow, complete with runnable test cases.

BackendChain of ResponsibilityDesign Patterns
0 likes · 20 min read
Advanced Chain of Responsibility: Multi‑Level Validation and Workflow for Elegant Code
Sohu Tech Products
Sohu Tech Products
Aug 28, 2025 · Backend Development

Unlocking Tomcat’s Secrets: Deep Dive into Architecture, Design Patterns, and Class Loading

This comprehensive guide explores Tomcat’s mature architecture, detailing its connector and container components, the underlying design patterns such as composite, observer, and template method, and the custom class‑loading mechanisms that enable modularity, hot‑reloading, and isolation for Java web applications.

Class LoadingDesign PatternsJava
0 likes · 43 min read
Unlocking Tomcat’s Secrets: Deep Dive into Architecture, Design Patterns, and Class Loading
DeWu Technology
DeWu Technology
Aug 27, 2025 · Backend Development

How to Build Scalable Go Systems: Principles, Patterns, and Code Practices

This article explains why scalable systems are essential, outlines core design principles such as the open‑closed and modular approaches, demonstrates Go implementations of strategy, middleware, plugin, and configuration‑driven architectures, and provides validation metrics and an evolution roadmap for building extensible backend services.

Design PatternsGoarchitecture
0 likes · 20 min read
How to Build Scalable Go Systems: Principles, Patterns, and Code Practices
Lin is Dream
Lin is Dream
Aug 25, 2025 · Backend Development

How to Build a Mini‑Netty Pipeline that Decouples Decoding from Business Logic

This article explains how to redesign a Java NIO server by introducing a Netty‑style pipeline that separates decoding, logging, authentication, and business handling into independent handlers, improving extensibility, maintainability, and performance while providing complete sample code and initialization steps.

Design PatternsJavaNetty
0 likes · 15 min read
How to Build a Mini‑Netty Pipeline that Decouples Decoding from Business Logic
Java Tech Enthusiast
Java Tech Enthusiast
Aug 24, 2025 · Backend Development

Master Java Interview Essentials: OOP, Spring Beans, Redis, DB Indexes & More

This article compiles a comprehensive Java interview guide covering object‑oriented fundamentals, method overloading vs overriding, core collection implementations, Spring bean lifecycle, composite index usage, process/thread/coroutine distinctions, Linux IPC methods, design‑pattern principles, Redis roles and data types, relational vs NoSQL trade‑offs, QR‑code login design, and a classic 15‑minute brain teaser.

ConcurrencyDesign PatternsInterview
0 likes · 17 min read
Master Java Interview Essentials: OOP, Spring Beans, Redis, DB Indexes & More
Architect's Guide
Architect's Guide
Aug 23, 2025 · Backend Development

Eliminate Repetitive Java Code: Design Patterns, Annotations & Mapping Tricks

This article explains why duplicate code harms maintainability and demonstrates three practical techniques—factory/template method patterns, annotation‑driven reflection, and bean‑mapping utilities—to refactor Java backend services and dramatically reduce redundant implementations.

AnnotationsDesign PatternsJava
0 likes · 23 min read
Eliminate Repetitive Java Code: Design Patterns, Annotations & Mapping Tricks
Deepin Linux
Deepin Linux
Aug 17, 2025 · Fundamentals

Mastering C++ Singleton: 5 Implementations, Pitfalls & Performance Tips

This article explains why the singleton pattern is essential for global resources in C++, walks through five concrete implementations—from basic lazy and eager versions to thread‑safe double‑checked locking and C++11 static locals—analyzes their performance and resource trade‑offs, and provides a complete printer‑singleton case study with build and run instructions.

C++C++11Design Patterns
0 likes · 26 min read
Mastering C++ Singleton: 5 Implementations, Pitfalls & Performance Tips
Code Ape Tech Column
Code Ape Tech Column
Jul 18, 2025 · Backend Development

Building a Flexible Java Rule Engine: Design, Code, and Tips

This article walks through the design and implementation of a Java rule engine, illustrating how to abstract rules, create a reusable executor with AND/OR logic, and demonstrates the full code, while discussing its advantages, drawbacks, and practical usage in real‑world applications.

Design PatternsJavabackend development
0 likes · 7 min read
Building a Flexible Java Rule Engine: Design, Code, and Tips
dbaplus Community
dbaplus Community
Jul 15, 2025 · Backend Development

When to Choose RPC vs MQ: Decoupling Strategies for Reliable Services

This article explains why RPC should be used when callers need immediate results, why forcing MQ for request‑response adds complexity and risk, and how combining RPC for result‑sensitive flows with MQ for fire‑and‑forget events achieves clean architectural decoupling.

Backend ArchitectureDecouplingDesign Patterns
0 likes · 6 min read
When to Choose RPC vs MQ: Decoupling Strategies for Reliable Services
Architecture Digest
Architecture Digest
Jul 14, 2025 · Fundamentals

How to Eliminate Excessive if…else: 8 Proven Refactoring Techniques

This article examines the problems caused by overusing if…else statements—such as reduced readability, maintainability, and extensibility—and presents eight practical solutions including table‑driven design, chain‑of‑responsibility, annotation‑driven, event‑driven, state machines, Optional, Assert, and polymorphism, plus additional tactics like method extraction and guard clauses.

Design Patternscode qualityif-else
0 likes · 16 min read
How to Eliminate Excessive if…else: 8 Proven Refactoring Techniques
FunTester
FunTester
Jul 10, 2025 · Fundamentals

Mastering Scalable Test Automation: Design Patterns Every Engineer Should Know

This article explores how to build highly extensible test automation frameworks by applying proven design patterns such as modular architecture, Page Object Model, data-driven testing, BDD, keyword-driven testing, parallel execution, abstraction layers, and plug-in components, while addressing current challenges and future AI-driven evolution.

BDDCI/CDData‑Driven Testing
0 likes · 11 min read
Mastering Scalable Test Automation: Design Patterns Every Engineer Should Know
Big Data Technology Tribe
Big Data Technology Tribe
Jul 9, 2025 · Backend Development

Mastering Idempotency: Design Patterns & Best Practices for Reliable Distributed Systems

This comprehensive guide explains the concept of idempotency, why it is essential in distributed and micro‑service architectures, and provides practical patterns, code examples, and best‑practice recommendations for HTTP, databases, messaging, caching, and service‑mesh implementations.

BackendDesign PatternsDistributed Systems
0 likes · 21 min read
Mastering Idempotency: Design Patterns & Best Practices for Reliable Distributed Systems