BestHub
Sign in
Tagged articles
848 articles
Page 8 of 9
Meituan Technology Team
Meituan Technology Team
Mar 19, 2020 · Backend Development

Applying Design Patterns and Domain‑Driven Design in Meituan Takeaway Marketing System

The Meituan Takeaway Marketing team shows how combining domain‑driven design with classic patterns such as Factory Method, Strategy, State and Responsibility Chain creates an extensible, maintainable reward system that adapts to rapidly changing business rules while keeping the domain model clean and SOLID‑compliant.

Design PatternsDomain-Driven DesignFactory Method
0 likes · 25 min read
Applying Design Patterns and Domain‑Driven Design in Meituan Takeaway Marketing System
Suning Design
Suning Design
Mar 9, 2020 · Product Management

Master Onboarding: 7 Design Principles & 6 Patterns to Boost User Retention

This article explains what onboarding (new‑user guidance) is, why it matters for reducing friction, outlines seven core design principles, presents six reusable design patterns, and shows how advanced applications like Taobao’s Gold Coin feature apply these concepts to improve retention.

Design PatternsOnboardingProduct Design
0 likes · 12 min read
Master Onboarding: 7 Design Principles & 6 Patterns to Boost User Retention
Java Captain
Java Captain
Mar 1, 2020 · Backend Development

Summary of Design Patterns Used in the Spring Framework

This article explains how the Spring framework implements various classic design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—detailing their implementation mechanisms, underlying principles, and practical significance within Spring's bean lifecycle and extension points.

BeanFactoryDesign PatternsObserver
0 likes · 14 min read
Summary of Design Patterns Used in the Spring Framework
21CTO
21CTO
Feb 6, 2020 · Fundamentals

Mastering the Role of a Software Architect: Skills, Levels, and Daily Practices

This article explores what a software architect does, defines the role, outlines three architectural levels, details daily responsibilities, and breaks down ten essential skills—including design, decision‑making, simplification, programming, and documentation—to help engineers become better architects.

Design PatternsSystem Designarchitect skills
0 likes · 14 min read
Mastering the Role of a Software Architect: Skills, Levels, and Daily Practices
Architecture Digest
Architecture Digest
Feb 6, 2020 · Backend Development

Refactoring a 3000‑Line C# System to 15 Lines: Lessons and Practices

An experienced developer recounts how he transformed a cumbersome three‑tier C# data‑center management system from thousands of lines to a concise, maintainable codebase using reflection, generics, and thoughtful refactoring, while sharing practical advice on avoiding code generators, reducing duplication, and embracing unit testing.

Backend DevelopmentCDesign Patterns
0 likes · 18 min read
Refactoring a 3000‑Line C# System to 15 Lines: Lessons and Practices
Programmer DD
Programmer DD
Jan 11, 2020 · Fundamentals

Mastering the Strategy Pattern: When and How to Use It in Java

This article explains the Strategy design pattern, its definition, roles, UML diagram, Java code examples, real‑world applications such as payment integration and compression, and provides guidance on when to use it, its advantages, drawbacks, and how to simplify it with Java 8 lambdas.

Design PatternsJavaLambda
0 likes · 16 min read
Mastering the Strategy Pattern: When and How to Use It in Java
Programmer DD
Programmer DD
Jan 10, 2020 · Backend Development

How MyBatis Leverages 9 Classic Design Patterns

This article explores how MyBatis implements nine fundamental design patterns—Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, and Iterator—by examining its source code, illustrating each pattern with explanations, diagrams, and code snippets to deepen developers' understanding of practical pattern usage.

Backend DevelopmentDesign PatternsJava
0 likes · 23 min read
How MyBatis Leverages 9 Classic Design Patterns
Java Captain
Java Captain
Dec 25, 2019 · Backend Development

Handling Null Values and Optional in Java: Best Practices and Design Patterns

This article discusses common null‑value pitfalls in Java services, explains why returning null collections is dangerous, and presents robust solutions such as returning empty lists, using Optional, applying JSR‑303/JSR‑305 annotations, and employing the Null Object pattern to improve code safety and readability.

Design PatternsJSR-303JSR-305
0 likes · 13 min read
Handling Null Values and Optional in Java: Best Practices and Design Patterns
58 Tech
58 Tech
Dec 13, 2019 · Mobile Development

Refactoring the IM Module: Layered Architecture, Parallel Development and Business‑Line Splitting

This article describes the redesign of a large‑scale Android instant‑messaging (IM) module, detailing the shortcomings of the original architecture, the new three‑layer framework, the split‑converter for parallel business‑line development, component‑based UI design, and the design‑pattern techniques used to achieve a maintainable, extensible solution.

AndroidComponentizationDesign Patterns
0 likes · 16 min read
Refactoring the IM Module: Layered Architecture, Parallel Development and Business‑Line Splitting
Architect's Tech Stack
Architect's Tech Stack
Dec 13, 2019 · Backend Development

Comprehensive Java Interview Guide and Preparation Checklist

This article provides a detailed Java interview preparation guide, covering personal experience, overall interview process, essential knowledge areas such as core Java, data structures, algorithms, JVM, multithreading, databases, networking, design patterns, distributed systems, caching, frameworks, emerging technologies, and practical tips for success.

Design PatternsJVMinterview
0 likes · 9 min read
Comprehensive Java Interview Guide and Preparation Checklist
Architecture Digest
Architecture Digest
Nov 1, 2019 · Fundamentals

Reflections on Transaction System Design: Principles, Patterns, and Evolution

This article reflects on the redesign of a large‑scale transaction system, describing a decision‑making routine that starts from purpose and goals, discusses programming paradigms, SOLID principles, domain‑driven design, bounded contexts, component splitting, layering, and the trade‑offs of patterns such as State and CQRS to achieve a flexible, maintainable backend architecture.

Design PatternsDomain-Driven DesignSOLID
0 likes · 21 min read
Reflections on Transaction System Design: Principles, Patterns, and Evolution
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Oct 30, 2019 · Backend Development

Eliminating Complex if‑else Logic with Strategy and Factory Patterns in a Spring‑Based Java Application

This article explains how excessive if‑else statements in business code hurt readability and maintainability, and demonstrates how to replace them with the Strategy and Factory design patterns integrated with Spring, using a food‑delivery discount example and complete Java code snippets.

BackendDesign PatternsFactory Pattern
0 likes · 12 min read
Eliminating Complex if‑else Logic with Strategy and Factory Patterns in a Spring‑Based Java Application
21CTO
21CTO
Oct 9, 2019 · Fundamentals

Mastering OOP in C: Implement the State Pattern with Real Code

This article walks you through applying object‑oriented concepts in C by implementing the State design pattern, covering class simulation with structs, inheritance via macros, lifecycle management, polymorphism, and a complete client example that demonstrates state transitions for a water model.

CDesign PatternsMemory Management
0 likes · 13 min read
Mastering OOP in C: Implement the State Pattern with Real Code
Python Programming Learning Circle
Python Programming Learning Circle
Sep 25, 2019 · Fundamentals

Why My Student Project’s Code Is a Nightmare—and How to Fix It

A graduate student recounts the chaotic state of his research team's C# data‑mining project, highlighting poor naming conventions, oversized classes, overuse of singletons, redundant code, lack of proper inheritance, and other anti‑patterns, while offering concrete suggestions such as using meaningful identifiers, applying the single‑responsibility principle, leveraging LINQ, and adopting MVVM for cleaner, more maintainable code.

CDesign PatternsSoftware Engineering
0 likes · 8 min read
Why My Student Project’s Code Is a Nightmare—and How to Fix It
Programmer DD
Programmer DD
Sep 23, 2019 · Fundamentals

Mastering SOLID: Real‑World Java Examples for Clean Code

This article explains the nine essential SOLID design principles—why design patterns matter, and how the Open/Closed, Dependency Inversion, Single Responsibility, Law of Demeter, Interface Segregation, Liskov Substitution, and Composition principles can be applied in Java with clear code examples.

Design PatternsJavaOOP principles
0 likes · 10 min read
Mastering SOLID: Real‑World Java Examples for Clean Code
Architect's Tech Stack
Architect's Tech Stack
Sep 20, 2019 · Backend Development

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

This article examines how MyBatis applies classic design patterns—including Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, and Iterator—by analysing source code snippets and explaining each pattern's role in the framework's configuration, execution, caching, and dynamic SQL generation.

Backend DevelopmentDesign PatternsMyBatis
0 likes · 18 min read
Design Patterns in MyBatis: Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, Iterator
Architecture Digest
Architecture Digest
Sep 19, 2019 · Fundamentals

Design and Implementation of a Multi‑Layered Basic Framework Architecture

The article outlines the background, design principles, layered implementation details, and optimization considerations of a reusable, extensible basic framework architecture that separates business, functional, UI, and support layers to reduce coupling and accelerate app development.

Design PatternsFrameworkSoftware Engineering
0 likes · 7 min read
Design and Implementation of a Multi‑Layered Basic Framework Architecture
360 Tech Engineering
360 Tech Engineering
Sep 17, 2019 · Mobile Development

Design and Implementation of a Modular Mobile Application Framework

This article describes the background, design principles, layered architecture, and implementation details of a modular mobile framework that separates business, functional, UI, and support layers to enable rapid app development, easy extension, and reduced coupling.

AndroidDesign PatternsLayered Design
0 likes · 9 min read
Design and Implementation of a Modular Mobile Application Framework
Python Programming Learning Circle
Python Programming Learning Circle
Sep 17, 2019 · Backend Development

How to Future‑Proof Your Java Career: Skills Every Backend Engineer Must Master

A 25‑year‑old Beijing Java developer reflects on stagnation and offers a detailed learning roadmap—including source‑code reading, distributed and microservice architectures, concurrency, performance tuning, and design patterns—to avoid being eliminated and secure a lasting technical career.

BackendCareer DevelopmentDesign Patterns
0 likes · 7 min read
How to Future‑Proof Your Java Career: Skills Every Backend Engineer Must Master
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 14, 2019 · Fundamentals

Unlocking Software Design Patterns: Complete Series Outline & Roadmap

This announcement outlines a new series on software design patterns, detailing its origin, purpose, structured article format, and a comprehensive roadmap covering object‑oriented fundamentals, design principles, and individual patterns such as Singleton, Factory, Adapter, and many more, with Java examples.

Design PatternsJavaSoftware Architecture
0 likes · 5 min read
Unlocking Software Design Patterns: Complete Series Outline & Roadmap
Big Data Technology & Architecture
Big Data Technology & Architecture
Sep 13, 2019 · Backend Development

Comprehensive Java Interview Topics: Language Basics, Collections, Concurrency, JVM, Design Patterns, MySQL, and Netty

This article compiles essential Java interview questions covering language fundamentals, core APIs, collections, concurrency mechanisms, JVM internals, design patterns, database concepts, and Netty networking, providing a thorough reference for candidates preparing for backend development positions.

Backend DevelopmentDesign PatternsInterview Preparation
0 likes · 12 min read
Comprehensive Java Interview Topics: Language Basics, Collections, Concurrency, JVM, Design Patterns, MySQL, and Netty
Qunar Tech Salon
Qunar Tech Salon
Aug 8, 2019 · Frontend Development

Understanding Design Patterns in JavaScript

This article explains why and how to use various JavaScript design patterns—such as module, revealing module, ES6 modules, singleton, factory, and decorator—by describing their purpose, benefits, and providing clear code examples while warning against over‑use.

DecoratorDesign PatternsFactory
0 likes · 14 min read
Understanding Design Patterns in JavaScript
Programmer DD
Programmer DD
Jul 24, 2019 · Backend Development

Unlock the Power of Spring: 30 Core Concepts Every Java Developer Must Master

This comprehensive guide explores the fundamentals of the Spring framework—including its core modules, dependency injection, IoC, bean scopes, configuration styles, annotation-driven setup, event handling, and common design patterns—providing Java developers with practical examples and code snippets to master Spring's capabilities.

ConfigurationDesign PatternsIoC
0 likes · 25 min read
Unlock the Power of Spring: 30 Core Concepts Every Java Developer Must Master
Java Captain
Java Captain
May 29, 2019 · Backend Development

Common Design Patterns Used in the Spring Framework

This article reviews the most frequently applied design patterns in Spring—including IoC/DI, Factory, Singleton, Proxy (AOP), Template Method, Observer, Adapter, and Decorator—explaining their purpose, how Spring implements them, and providing concise code examples for each.

Design PatternsFactoryIoC
0 likes · 17 min read
Common Design Patterns Used in the Spring Framework
Programmer DD
Programmer DD
May 28, 2019 · Backend Development

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

This article explains how to apply the Strategy pattern within a Spring project, covering background, learning objectives, step‑by‑step code examples for query services A, B, and C, the three‑part invocation process, and both list‑based and map‑based configurations.

Backend DevelopmentDesign PatternsJava
0 likes · 3 min read
Mastering the Strategy Pattern in Spring: Real-World Java Examples
Architecture Digest
Architecture Digest
May 8, 2019 · Fundamentals

10 Common Software Architectural Patterns and Their Applications

This article introduces ten widely used software architectural patterns, explains their structure and key characteristics, and lists typical application scenarios for each, helping developers choose appropriate architectures for large‑scale enterprise systems.

Design PatternsMVCSoftware Architecture
0 likes · 9 min read
10 Common Software Architectural Patterns and Their Applications
Node Underground
Node Underground
Apr 25, 2019 · Frontend Development

How Inversion of Control Boosts Front‑End Development Efficiency

This article explains the Inversion of Control (IoC) pattern and its Dependency Injection implementation, showing how a simple container can decouple modules, improve modularity, speed up development, and make unit testing easier for front‑end JavaScript/TypeScript projects.

Design PatternsInversion of Controldependency-injection
0 likes · 11 min read
How Inversion of Control Boosts Front‑End Development Efficiency
Senior Brother's Insights
Senior Brother's Insights
Apr 15, 2019 · Backend Development

How MyBatis Implements 9 Classic Design Patterns – A Deep Dive

This article explores how MyBatis applies nine fundamental design patterns—including Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, and Iterator—by examining its source code, illustrating each pattern with explanations and concrete code snippets to deepen developers' understanding of real‑world pattern usage.

Backend DevelopmentBuilderDesign Patterns
0 likes · 19 min read
How MyBatis Implements 9 Classic Design Patterns – A Deep Dive
Alibaba Cloud Developer
Alibaba Cloud Developer
Apr 1, 2019 · Fundamentals

Must-Read Technical Books Recommended by Alibaba Experts

Alibaba’s senior engineers share their curated list of essential technical books—from software testing and design patterns to AI, machine learning, reinforcement learning, Rust programming, and database architecture—explaining why each title is valuable for developers seeking deeper knowledge and practical insights.

AIDesign PatternsRust
0 likes · 9 min read
Must-Read Technical Books Recommended by Alibaba Experts
21CTO
21CTO
Mar 21, 2019 · Fundamentals

Why Spending 80% of Your Time on Fundamentals Beats Chasing New Frameworks

The article argues that programmers should devote the majority of their limited time to mastering transferable fundamentals and design principles rather than constantly chasing the latest frameworks, using the Lindy effect and personal experience to illustrate this sustainable learning strategy.

Design PatternsLindy effectfundamentals
0 likes · 8 min read
Why Spending 80% of Your Time on Fundamentals Beats Chasing New Frameworks
Java Captain
Java Captain
Feb 26, 2019 · Backend Development

How to Write Better Java Code: Refactoring, DTO Conversion, Lombok, and Design Practices

This article discusses practical Java programming techniques, including proper DTO conversion, use of BeanUtils, Lombok annotations, builder patterns, static constructors, validation with JSR‑303, and design considerations such as refactoring, strategy versus state patterns, to help developers write cleaner, more maintainable backend code.

Design PatternsJavaLombok
0 likes · 27 min read
How to Write Better Java Code: Refactoring, DTO Conversion, Lombok, and Design Practices
Java Captain
Java Captain
Feb 20, 2019 · Backend Development

Java Interview Preparation Roadmap: JVM, Algorithms, Concurrency, Databases, Frameworks, Distributed Systems, and Design Patterns

This article outlines a comprehensive Java interview study plan, covering JVM fundamentals, sorting algorithms and collections, multithreading, key storage technologies like Redis, MySQL, and Elasticsearch, Spring framework deep dive, Dubbo-based distributed architecture, and essential design patterns to master for backend development roles.

Backend DevelopmentDesign PatternsInterview Preparation
0 likes · 11 min read
Java Interview Preparation Roadmap: JVM, Algorithms, Concurrency, Databases, Frameworks, Distributed Systems, and Design Patterns
Java Backend Technology
Java Backend Technology
Feb 17, 2019 · Backend Development

9 Essential Spring Design Patterns Every Java Developer Should Master

This article explores nine commonly used Spring design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Wrapper, Proxy, Observer, Strategy, and Template Method—explaining their concepts, showing XML or Java code examples, and illustrating how Spring implements each pattern in real applications.

Backend DevelopmentDesign PatternsJava
0 likes · 9 min read
9 Essential Spring Design Patterns Every Java Developer Should Master
Programmer DD
Programmer DD
Feb 13, 2019 · Backend Development

When Should You Use Abstract Classes in Java? Avoid the Swiss‑Army‑Knife Controller Anti‑Pattern

This article explains the purpose and proper use of abstract classes in Java, illustrates common misuse such as the Swiss‑Army‑Knife controller anti‑pattern, and demonstrates how the Template Method pattern can provide a cleaner design with concrete examples and code snippets.

Abstract ClassesBackend DevelopmentDesign Patterns
0 likes · 11 min read
When Should You Use Abstract Classes in Java? Avoid the Swiss‑Army‑Knife Controller Anti‑Pattern
Java Captain
Java Captain
Feb 10, 2019 · Backend Development

Common Spring Design Patterns: Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method

This article explains how Spring implements nine classic design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—through configuration examples and Java code, illustrating their roles in building flexible, maintainable backend applications.

AdapterBackend DevelopmentDesign Patterns
0 likes · 9 min read
Common Spring Design Patterns: Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method
360 Tech Engineering
360 Tech Engineering
Jan 22, 2019 · Cloud Native

Microservice Design Patterns: Database, Observability, and Cross‑Cutting Concerns

This article introduces a series of microservice design patterns—including database isolation, observability, and cross‑cutting concerns—explaining the underlying problems each pattern solves and providing concrete solutions such as CQRS, Saga, log aggregation, health checks, and blue‑green deployments.

Backend ArchitectureCloud NativeDesign Patterns
0 likes · 13 min read
Microservice Design Patterns: Database, Observability, and Cross‑Cutting Concerns
360 Tech Engineering
360 Tech Engineering
Jan 22, 2019 · Backend Development

Microservice Architecture Design Patterns: Decomposition and Integration Patterns (Part 1)

This article introduces microservice architecture design patterns, covering core architectural principles, decomposition approaches such as business‑capability, sub‑domain, and strangler patterns, and integration solutions like API‑gateway, aggregator, and client‑side UI composition, while highlighting common challenges and their remedies.

Backend ArchitectureDesign PatternsIntegration
0 likes · 7 min read
Microservice Architecture Design Patterns: Decomposition and Integration Patterns (Part 1)
360 Tech Engineering
360 Tech Engineering
Jan 17, 2019 · Backend Development

Microservice Architecture Design Patterns – Decomposition and Integration Patterns (Part 1)

This article introduces key microservice design patterns, covering decomposition approaches such as business‑capability and sub‑domain splits, the Strangler pattern, and integration solutions like API‑gateway, aggregator, and client‑UI composition, while outlining core microservice principles and challenges.

Backend ArchitectureDesign PatternsIntegration
0 likes · 8 min read
Microservice Architecture Design Patterns – Decomposition and Integration Patterns (Part 1)
Architect's Tech Stack
Architect's Tech Stack
Jan 17, 2019 · Backend Development

Comprehensive Java Interview Questions and Topics

This article compiles an extensive list of Java interview questions covering fundamentals, concurrency, collections, JVM internals, I/O, design patterns, testing, and best practices, providing candidates with a comprehensive study guide for modern backend development roles.

BackendDesign PatternsJVM
0 likes · 12 min read
Comprehensive Java Interview Questions and Topics
Senior Brother's Insights
Senior Brother's Insights
Jan 2, 2019 · Backend Development

9 Essential Spring Design Patterns Explained with Code Samples

This article walks through nine commonly used design patterns in Spring, such as Simple Factory, Factory Method, Singleton, Adapter, Wrapper, Proxy, Observer, Strategy, and Template Method, providing clear explanations, XML configurations, and Java code examples to illustrate each pattern in practice.

AdapterDesign PatternsFactory
0 likes · 9 min read
9 Essential Spring Design Patterns Explained with Code Samples
21CTO
21CTO
Dec 22, 2018 · Fundamentals

Why Spending 80% of Your Time on Fundamentals Beats Chasing Every New Framework

The article argues that developers should devote the majority of their learning time to timeless fundamentals—design patterns, clean code, and architecture—rather than constantly chasing the latest frameworks and tools, using personal anecdotes and a mentor dialogue to illustrate the point.

Continuous DeliveryDesign Patternsfundamentals
0 likes · 8 min read
Why Spending 80% of Your Time on Fundamentals Beats Chasing Every New Framework
Programmer DD
Programmer DD
Dec 11, 2018 · Backend Development

Top 20 Java Interview Questions for Investment Banking (Answers Included)

This article compiles 20 common Java interview questions asked by investment banks, covering topics such as multithreaded HashMap usage, hashCode/equals contracts, String substring memory issues, singleton patterns, design patterns, deadlock avoidance, and performance considerations, each accompanied by concise answers and code examples.

BackendCollectionsDesign Patterns
0 likes · 18 min read
Top 20 Java Interview Questions for Investment Banking (Answers Included)
Programmer DD
Programmer DD
Nov 24, 2018 · Fundamentals

Why OOP Still Rules: Composition, SOLID, and Refactoring Insights

The author reflects on a recent project refactor, emphasizing why object‑oriented programming remains dominant, exploring concepts like control inversion, dependency injection, SOLID principles, composition over inheritance, design patterns, layered architecture, and the balanced relationship between OOP and functional programming.

Design PatternsOOPSOLID
0 likes · 7 min read
Why OOP Still Rules: Composition, SOLID, and Refactoring Insights
360 Zhihui Cloud Developer
360 Zhihui Cloud Developer
Nov 6, 2018 · Backend Development

Mastering Microservice Design Patterns: Decomposition & Integration Strategies

This article introduces microservice architecture design patterns, covering decomposition and integration patterns, their associated challenges, and practical solutions such as business‑capability decomposition, domain‑driven design, API‑gateway and aggregator patterns, helping developers tackle scalability, resilience, and maintainability in modern backend systems.

Backend ArchitectureDesign PatternsIntegration
0 likes · 9 min read
Mastering Microservice Design Patterns: Decomposition & Integration Strategies
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Aug 29, 2018 · Frontend Development

How to Use React Context API to Build Flexible, Reusable Components

This tutorial demonstrates how to replace fragile prop‑drilling in a multi‑step React component by leveraging the React Context API, showing step‑by‑step creation of a context, provider, and consumer, refactoring the Stepper component for greater flexibility and reusability across the UI.

Component ReusabilityContext APIDesign Patterns
0 likes · 9 min read
How to Use React Context API to Build Flexible, Reusable Components
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Aug 28, 2018 · Frontend Development

Master Flexible React Components with Compound Component Patterns

This article demonstrates how to transform a basic Stepper component into a highly reusable and configurable React component using the compound component pattern, static properties, and React's Children utilities, while addressing common customization challenges and preparing for context API integration.

Compound ComponentsContext APIDesign Patterns
0 likes · 11 min read
Master Flexible React Components with Compound Component Patterns
Java Captain
Java Captain
Aug 28, 2018 · Databases

Design and Implementation of a Mini Database Connection Pool

This article explains the concept, design considerations, and step‑by‑step implementation of a lightweight database connection pool in Java, covering its core components, thread‑safe management, configuration handling, and a test demonstration of its functionality.

Connection PoolDesign PatternsJava
0 likes · 5 min read
Design and Implementation of a Mini Database Connection Pool
Senior Brother's Insights
Senior Brother's Insights
Aug 23, 2018 · Fundamentals

Mastering the Singleton Pattern in Java: Eager, Lazy, Double‑Check, and More

Explore the GOF 23 design patterns with a deep dive into the Singleton pattern, covering its purpose, characteristics, comparison to static classes, and multiple Java implementations—including eager, lazy, double‑checked locking, volatile, static inner class, and enum approaches—plus Spring’s real‑world usage.

Design PatternsJavaSingleton
0 likes · 12 min read
Mastering the Singleton Pattern in Java: Eager, Lazy, Double‑Check, and More
21CTO
21CTO
Aug 20, 2018 · Fundamentals

Microservices vs SOA: What’s the Real Difference and When to Use Each?

This article clarifies the core distinctions between Service‑Oriented Architecture (SOA) and microservices, covering their origins, communication models, bounded contexts, scalability, and suitable use‑cases, helping developers decide which architectural style best fits their application’s size, complexity, and deployment needs.

Design PatternsSOASoftware Architecture
0 likes · 9 min read
Microservices vs SOA: What’s the Real Difference and When to Use Each?
Senior Brother's Insights
Senior Brother's Insights
Aug 19, 2018 · Backend Development

Spring’s 9 Core Design Patterns Explained with Code Examples

This article walks through nine common design patterns used in the Spring framework—Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—showing their concepts, Spring-specific implementations, and practical code snippets.

BackendDesign PatternsJava
0 likes · 9 min read
Spring’s 9 Core Design Patterns Explained with Code Examples
转转QA
转转QA
Aug 15, 2018 · Backend Development

Designing a Dynamic‑Proxy‑Based Interface Testing Framework for Transaction Order and Payment Systems

The article explains how to design a maintainable interface testing framework using Java dynamic proxies, illustrating the approach with a transaction order system and a payment account system, and discusses its advantages, drawbacks, and practical application in a backend testing environment.

Backend testingDesign Patternsinterface testing
0 likes · 9 min read
Designing a Dynamic‑Proxy‑Based Interface Testing Framework for Transaction Order and Payment Systems
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Aug 9, 2018 · Backend Development

Essential Backend Architecture Knowledge Map for High‑Concurrency Systems

This article presents a curated knowledge map covering backend architecture, Java best practices, microservice design, distributed consistency, high‑traffic handling, Alibaba frameworks, and design patterns, offering internet high‑concurrency architects a comprehensive reference of essential concepts and skills.

BackendDesign PatternsDistributed Systems
0 likes · 2 min read
Essential Backend Architecture Knowledge Map for High‑Concurrency Systems
Big Data and Microservices
Big Data and Microservices
Jul 30, 2018 · Backend Development

Six Essential Microservice Design Patterns and When to Apply Them

This article outlines six fundamental microservice design patterns—Aggregator, Proxy, Chain, Branch, Data‑Sharing, and Asynchronous Messaging—explaining their structures, use‑cases, scalability characteristics, and potential pitfalls to help architects choose the right approach for their systems.

Backend ArchitectureDesign PatternsMicroservices
0 likes · 5 min read
Six Essential Microservice Design Patterns and When to Apply Them
Java Backend Technology
Java Backend Technology
Jul 27, 2018 · Backend Development

From Junior to Java Architect: Key Lessons on High‑Concurrency System Design

The article shares a developer's journey toward becoming a Java architect, highlighting common pitfalls such as over‑focusing on code, getting lost in component details, and neglecting reusability, while offering practical advice on mastering high‑concurrency architectures, component integration, and design patterns.

Backend DevelopmentDesign PatternsJava
0 likes · 11 min read
From Junior to Java Architect: Key Lessons on High‑Concurrency System Design
JD Tech
JD Tech
Jun 26, 2018 · Backend Development

Design and Development of an IntelliJ Plugin for Smart Code Completion and Formatting

This article describes the motivation, design, implementation, and deployment of an IntelliJ IDEA plugin that automatically inserts semicolons and braces, formats code, and uses a chain‑of‑responsibility pattern to decouple business logic, providing developers with a smoother coding experience.

Design PatternsIDEIntelliJ
0 likes · 18 min read
Design and Development of an IntelliJ Plugin for Smart Code Completion and Formatting
Java Captain
Java Captain
Jun 19, 2018 · Fundamentals

Understanding the Proxy Pattern: Static vs Dynamic Proxy and AOP in Java

This article explains the proxy design pattern, compares static and dynamic proxy implementations in Java, demonstrates how to use Java reflection and InvocationHandler for dynamic proxies, and shows how these techniques enable AOP features such as logging and transaction handling.

Design PatternsDynamic ProxyJava
0 likes · 12 min read
Understanding the Proxy Pattern: Static vs Dynamic Proxy and AOP in Java
DevOps
DevOps
Jun 13, 2018 · Fundamentals

The Importance of Methodology and Best Practices in Software Development

Understanding and applying solid methodologies—such as design patterns, coding standards, and domain‑driven design—constitutes the core of software development best practices, helping programmers evolve from “wild” coders to professionals who write clean, maintainable code and continuously improve through disciplined practice.

Design PatternsMethodologybest practices
0 likes · 8 min read
The Importance of Methodology and Best Practices in Software Development
Architecture Digest
Architecture Digest
Jun 13, 2018 · Fundamentals

Common Misconceptions About Software Architecture, High Concurrency, and Microservices

The article debunks three prevalent misconceptions—treating a development framework as a substitute for an architect, assuming high concurrency and big‑data challenges are inherently difficult, and believing microservice architecture is a universal solution—by emphasizing the importance of proper design, testing, and realistic evaluation of trade‑offs.

Design PatternsMicroservicesSoftware Architecture
0 likes · 6 min read
Common Misconceptions About Software Architecture, High Concurrency, and Microservices
MaGe Linux Operations
MaGe Linux Operations
Jun 4, 2018 · Fundamentals

From Assembly to OOP: A 7-Day Mythic Journey Through Programming Fundamentals

The article narrates a seven‑day mythic saga where God bestows programming concepts—assembly, functions, data structures, objects, classes, inheritance, polymorphism, and design patterns—on humanity, illustrating how each breakthrough transformed code from tangled sequences into organized, reusable, and abstracted software.

Design PatternsInheritanceobject‑oriented programming
0 likes · 7 min read
From Assembly to OOP: A 7-Day Mythic Journey Through Programming Fundamentals
ITFLY8 Architecture Home
ITFLY8 Architecture Home
May 20, 2018 · Backend Development

Why Microservices Matter: A Complete Guide to Architecture, Patterns, and Pitfalls

Microservice architecture, introduced in 2012, breaks monolithic applications into independent services, offering benefits like scalability and flexibility while introducing challenges such as complexity, communication overhead, and testing, and the article explores its evolution, core characteristics, design patterns, implementation practices, and trade‑offs.

Design PatternsMicroservicesapi-gateway
0 likes · 21 min read
Why Microservices Matter: A Complete Guide to Architecture, Patterns, and Pitfalls
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Apr 29, 2018 · Fundamentals

Unlocking Code Reuse: Design Patterns, Frameworks, Architecture & Platforms Explained

This article explains how design patterns, frameworks, software architecture, and platforms each contribute to different levels of code reuse—from class-level patterns to system-wide architectures—while also detailing key design principles, framework basics, and Java platform classifications for developers seeking deeper engineering insight.

Design PatternsSoftware Architecturecode-reuse
0 likes · 13 min read
Unlocking Code Reuse: Design Patterns, Frameworks, Architecture & Platforms Explained
Java Captain
Java Captain
Apr 23, 2018 · Backend Development

Overview of Common Java Backend Technologies: Spring MVC, Spring, MyBatis, Dubbo, Maven, RabbitMQ, Log4j, Ehcache, Redis, Shiro, and Design Patterns

This article provides a comprehensive introduction to essential Java backend technologies—including Spring MVC, Spring IoC/AOP, MyBatis, Dubbo, Maven, RabbitMQ, Log4j, Ehcache, Redis, Shiro—and outlines basic design‑pattern concepts, helping developers understand their roles, core mechanisms, and practical usage.

Backend DevelopmentDesign PatternsDubbo
0 likes · 13 min read
Overview of Common Java Backend Technologies: Spring MVC, Spring, MyBatis, Dubbo, Maven, RabbitMQ, Log4j, Ehcache, Redis, Shiro, and Design Patterns
Alibaba Cloud Developer
Alibaba Cloud Developer
Apr 23, 2018 · Fundamentals

Top Technical Books Recommended by Alibaba Experts for World Book Day

On World Book Day, nine Alibaba technology veterans share a curated list of essential technical books—covering software testing, design patterns, AI, machine learning, reinforcement learning, Rust, and database architecture—offering concise reasons why each title is valuable for developers and engineers.

Database ArchitectureDesign PatternsRust programming
0 likes · 10 min read
Top Technical Books Recommended by Alibaba Experts for World Book Day
Java Captain
Java Captain
Apr 14, 2018 · Fundamentals

Java Design Patterns: Singleton, Observer, Decorator, Adapter, Factory, Abstract Factory, and Proxy

This article introduces several core Java design patterns—including Singleton (lazy, eager, static inner class, enum, double‑checked locking), Observer, Decorator, Adapter, Factory, Abstract Factory, and Proxy—explaining their intent, providing concise code examples, and showing how they solve common software design problems.

DecoratorDesign PatternsFactory
0 likes · 13 min read
Java Design Patterns: Singleton, Observer, Decorator, Adapter, Factory, Abstract Factory, and Proxy
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Apr 3, 2018 · Fundamentals

How to Cultivate Object‑Oriented Thinking and Architecture Skills as a Junior Developer

After years of coding without guidance, the author shares practical insights on developing object‑oriented design thinking, when to use interfaces, the limits of OOD, and how continuous refactoring and learning design patterns can gradually build a junior developer’s architectural competence.

Design PatternsObject-Oriented DesignSoftware Architecture
0 likes · 11 min read
How to Cultivate Object‑Oriented Thinking and Architecture Skills as a Junior Developer
Architect's Tech Stack
Architect's Tech Stack
Mar 21, 2018 · Fundamentals

Comprehensive Java Interview Questions and Topics Guide

This article compiles over 300 essential Java interview questions covering fundamentals, multithreading, design patterns, JVM internals, data structures, algorithms, databases, Spring, Netty, caching, distributed systems, Linux, and networking to help developers prepare for technical interviews and deepen their understanding of core backend concepts.

BackendDesign PatternsJVM
0 likes · 16 min read
Comprehensive Java Interview Questions and Topics Guide
Java Captain
Java Captain
Mar 9, 2018 · Backend Development

Comprehensive Java Interview Topics and Core Concepts

This guide compiles a thorough list of Java interview questions and key concepts, ranging from basic collections and JVM memory to concurrency, database optimization, messaging systems, NoSQL, Zookeeper, Linux commands, and system design challenges, providing a solid study roadmap for developers.

BackendDesign PatternsJava
0 likes · 7 min read
Comprehensive Java Interview Topics and Core Concepts
360 Quality & Efficiency
360 Quality & Efficiency
Mar 5, 2018 · Backend Development

Design Patterns for Node.js Applications

This article explains key Node.js design patterns—including EventEmitter, streams, control‑flow libraries, coding style, testing, and logging—providing practical guidance and recommended tools for building robust, maintainable backend applications.

Design PatternsEventEmitterNode.js
0 likes · 11 min read
Design Patterns for Node.js Applications
Java Backend Technology
Java Backend Technology
Mar 3, 2018 · Backend Development

Essential Java Interview Questions Every Backend Developer Should Master

A comprehensive collection of Java interview questions covering fundamentals, common collections, concurrency, JVM internals, design patterns, data structures, networking, databases, caching, messaging, frameworks, distributed systems, and micro‑service architecture to help developers prepare for junior to mid‑level positions.

Design PatternsJavaconcurrency
0 likes · 19 min read
Essential Java Interview Questions Every Backend Developer Should Master
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Mar 1, 2018 · Fundamentals

Top 10 Software Architecture Patterns Explained with Pros & Cons

This article introduces the concept of architecture patterns, outlines ten common software architecture styles—including layered, client‑server, master‑slave, pipe‑filter, proxy, peer‑to‑peer, event‑bus, MVC, blackboard, and interpreter—detailing their structures, typical use cases, advantages, and disadvantages.

Architecture PatternsDesign PatternsSoftware Architecture
0 likes · 11 min read
Top 10 Software Architecture Patterns Explained with Pros & Cons
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Feb 8, 2018 · Frontend Development

How Does JavaScript’s Promise Work Under the Hood? A Deep Dive

This article walks through the inner mechanics of JavaScript Promises, explaining their basic prototype, asynchronous handling with the event loop, state management, chainable behavior, and error handling, all illustrated with step‑by‑step code examples and diagrams.

AsynchronousDesign PatternsJavaScript
0 likes · 10 min read
How Does JavaScript’s Promise Work Under the Hood? A Deep Dive
21CTO
21CTO
Feb 3, 2018 · Fundamentals

10 Essential Software Architecture Patterns Every Developer Should Know

Explore ten common software architectural patterns—including layered, client‑server, master‑slave, pipe‑filter, proxy, peer‑to‑peer, event‑bus, MVC, blackboard, and interpreter—detailing their structures, typical use cases, advantages, and drawbacks, to help you choose the right architecture for enterprise‑scale systems.

Design PatternsSoftware ArchitectureSystem Design
0 likes · 12 min read
10 Essential Software Architecture Patterns Every Developer Should Know
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Feb 2, 2018 · Backend Development

From Coder to Web Architect: Essential Skills, Mindset, and Roadmap

This article outlines the philosophical questions, practical steps, and essential knowledge—ranging from object‑oriented fundamentals and design patterns to refactoring, DBA, and operations—that developers need to master in order to evolve into competent web architects.

Career DevelopmentDesign PatternsSoftware Architecture
0 likes · 19 min read
From Coder to Web Architect: Essential Skills, Mindset, and Roadmap
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jan 29, 2018 · Fundamentals

Mastering Software Architecture: Roles, Patterns, Evaluation, and Risk Management

This comprehensive guide explains software architecture fundamentals, the responsibilities and skills of architects, key architectural patterns, evaluation methods like ATAM, risk identification and mitigation, practical view models, domain‑specific frameworks, and common enterprise architecture styles.

ATAT evaluationDesign PatternsSoftware Architecture
0 likes · 30 min read
Mastering Software Architecture: Roles, Patterns, Evaluation, and Risk Management
Java Captain
Java Captain
Jan 5, 2018 · Fundamentals

Overview of Design Patterns, SOLID Principles, and Java Implementations

This article introduces the three major categories of design patterns, explains the six SOLID principles, and provides detailed Java code examples for creational patterns such as Factory Method, Abstract Factory, Singleton, Builder, and Prototype, illustrating their structure and usage.

BuilderCreationalDesign Patterns
0 likes · 14 min read
Overview of Design Patterns, SOLID Principles, and Java Implementations
Java Backend Technology
Java Backend Technology
Dec 25, 2017 · Backend Development

Why Spring Needs AOP: Solving Repetitive Code with Dynamic Proxies

This article explores the pain points of traditional Java web development, demonstrates how design patterns and JDK dynamic proxies introduce Aspect‑Oriented Programming concepts, explains Spring AOP's relationship to AOP, and compares JDK and CGLib proxy implementations for clean, reusable code.

Design PatternsDynamic ProxyJava
0 likes · 9 min read
Why Spring Needs AOP: Solving Repetitive Code with Dynamic Proxies
Java Backend Technology
Java Backend Technology
Dec 24, 2017 · Backend Development

Why Spring Exists: Tracing Java’s Framework Evolution and Core Principles

The article explores the historical evolution of web development—from early Model1 and Model2 approaches through three‑tier architecture to modern Spring and Spring Boot—explaining why Spring was created, its core IoC concepts, design‑pattern foundations, and practical lessons for developers seeking a solid backend foundation.

Design PatternsIoCJava
0 likes · 13 min read
Why Spring Exists: Tracing Java’s Framework Evolution and Core Principles
DevOps
DevOps
Dec 22, 2017 · Cloud Native

Translation of 32 Cloud Design Patterns for Cloud‑Native Applications

This article presents a Chinese translation of 32 cloud design patterns originally documented by the Azure cloud team, explaining how these patterns—covering availability, data management, security, scalability, and more—can guide enterprises in migrating monolithic applications to cloud‑native architectures across any major cloud provider.

Design PatternsMicroservicescloud migration
0 likes · 4 min read
Translation of 32 Cloud Design Patterns for Cloud‑Native Applications
Baixing.com Technical Team
Baixing.com Technical Team
Dec 12, 2017 · Mobile Development

Why Composition Beats Inheritance in Android List Refactoring

This article explains how refactoring the Baixing Android app’s list feature from an inheritance-heavy design to a composition-based architecture improves modularity, reduces coupling, and eases future extensions by applying OOP principles such as dependency inversion and component interfaces.

Component ArchitectureComposition over InheritanceDependency Inversion
0 likes · 11 min read
Why Composition Beats Inheritance in Android List Refactoring
Java Captain
Java Captain
Dec 11, 2017 · Fundamentals

Comprehensive Java Interview Topics: Data Structures, Algorithms, JVM, Concurrency, Linux, Frameworks, Databases, Networking, Caching, and Design Patterns

This document compiles a wide range of Java interview questions covering data structures and algorithms, core Java concepts, JVM internals, multithreading, Linux usage, popular frameworks, database fundamentals, network protocols, caching systems, and common design patterns to help candidates prepare comprehensively.

AlgorithmsDesign PatternsJVM
0 likes · 12 min read
Comprehensive Java Interview Topics: Data Structures, Algorithms, JVM, Concurrency, Linux, Frameworks, Databases, Networking, Caching, and Design Patterns
Architecture Digest
Architecture Digest
Dec 4, 2017 · Fundamentals

Rethinking Object‑Oriented Programming: From Myth to Practical Understanding

The article reflects on a decade of programming experience to demystify object‑oriented programming, arguing that OOP should be taught as a practical tool for reducing complexity rather than an abstract doctrine, and discusses how to organize functions into classes, avoid misuse of inheritance and design patterns, and focus on solving real problems.

Design PatternsInheritancecode organization
0 likes · 10 min read
Rethinking Object‑Oriented Programming: From Myth to Practical Understanding
Java Captain
Java Captain
Nov 30, 2017 · Fundamentals

Module Interaction: Synchronous, Asynchronous, and Callback Calls in Java

This article explains the three main ways modules can call each other—synchronous calls, asynchronous calls, and callbacks—illustrates each with Java code examples, and discusses when to use each approach for flexible and non‑blocking program design.

AsynchronousDesign PatternsSynchronous
0 likes · 10 min read
Module Interaction: Synchronous, Asynchronous, and Callback Calls in Java