BestHub
Sign in
Tagged articles

Design Patterns

967 articles · Page 9 of 10
Selected Java Interview Questions
Selected Java Interview Questions
May 17, 2020 · Backend Development

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

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

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

10 Common Software Architectural Patterns and Their Uses

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

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

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

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

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

Unified Exception Handling and Assertion Techniques in Java Backend Development

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

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

Eliminating Excessive if…else: Patterns and Refactoring Techniques

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

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

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

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

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

Why Design Patterns May Harm Your Projects More Than Help

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

Code MaintainabilityDesign PatternsObject-Oriented Programming
0 likes · 16 min read
Why Design Patterns May Harm Your Projects More Than Help
Top Architect
Top Architect
Apr 29, 2020 · Fundamentals

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Mastering Software Architecture Patterns: From Layered to Cloud‑Native

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

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

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

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

Design PatternsJDKStatic Proxy
0 likes · 13 min read
Master Java Proxy: From Static to JDK Dynamic Proxy with Real Code
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 DesignStrategy Pattern
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 PatternsProduct Designdesign principles
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.

AOPBeanFactoryDependency Injection
0 likes · 14 min read
Summary of Design Patterns Used in the Spring Framework
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Feb 10, 2020 · Fundamentals

Understanding the Prototype Design Pattern with Java Examples

This article explains the Prototype creational design pattern, its definition, key concepts, typical usage scenarios, UML illustrations, and provides a complete Java implementation with code examples, output analysis, and a discussion of its application in Spring's prototype‑scoped beans.

CloneableDesign PatternsPrototype Pattern
0 likes · 11 min read
Understanding the Prototype Design Pattern with Java Examples
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 DevelopmentC++Design 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 PatternsStrategy Patternjava
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.

AndroidArchitectureComponentization
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.

C++Design 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.

C++Design Patternsbest practices
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 PatternsOOP principlesSOLID
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
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.

BackendDesign PatternsMicroservices
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 PatternsJVM
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 PatternsJavaScript
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.

Bean LifecycleConfigurationDependency Injection
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.

AOPDependency InjectionDesign Patterns
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 PatternsSpring
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 PatternsEvent BusMVC
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.

Dependency InjectionDesign PatternsInversion of Control
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.

DTODesign PatternsLombok
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 PatternsJVM
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 DevelopmentDependency InjectionDesign Patterns
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.

Circuit BreakerCloud 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.

API GatewayDesign Patternsbackend architecture
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.

API GatewayDesign Patternsbackend architecture
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 PatternsSpring
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.

BackendDesign PatternsPerformance
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.

Design PatternsMicroservicesbackend architecture
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.

Design Patternsconnection pooldatabase
0 likes · 5 min read
Design and Implementation of a Mini Database Connection Pool
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.

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

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

Asynchronous MessagingDesign 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.

AOPDesign PatternsStatic Proxy
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 Patternsbest practicescoding standards
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 PatternsMicroservicesSystem Design
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.

API GatewayArchitectureDesign Patterns
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 PatternsFrameworkscode 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.

Design PatternsRust programmingdatabase architecture
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 PatternsProxy
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 Designrefactoring
0 likes · 11 min read
How to Cultivate Object‑Oriented Thinking and Architecture Skills as a Junior Developer