BestHub
Sign in
Tagged articles
388 articles
Page 2 of 4
Architecture Digest
Architecture Digest
Apr 21, 2024 · Backend Development

12 Coding Anti‑Patterns That Reduce Readability and Increase Maintenance Difficulty

The article enumerates twelve common coding anti‑patterns—such as over‑splitting microservices, writing excessively long methods, deep nesting, random variable names, misleading comments, copy‑paste code, ignoring logs, and over‑engineered solutions—that dramatically hurt code readability, maintainability, and team productivity.

code qualityrefactoringsoftware anti-patterns
0 likes · 11 min read
12 Coding Anti‑Patterns That Reduce Readability and Increase Maintenance Difficulty
phodal
phodal
Apr 7, 2024 · Artificial Intelligence

How AutoDev 1.8 Boosts AI‑Assisted Refactoring and DevOps Automation

AutoDev 1.8 introduces AI‑driven refactoring, commit‑message generation, CLI assistance, and Chinese prompt support, combining software‑development best practices with knowledge‑engineered AI to streamline code changes, improve code quality, and integrate seamlessly into modern DevOps pipelines.

AI CodingAutoDevCLI assistance
0 likes · 9 min read
How AutoDev 1.8 Boosts AI‑Assisted Refactoring and DevOps Automation
JD Tech
JD Tech
Apr 7, 2024 · Fundamentals

Comprehensive Guide to Effective Code Review: Principles, Practices, and Common Challenges

This article presents an in‑depth guide on modern code review, covering its significance, core principles, preparation checklists, automation tools, good and bad commit messages, code quality metrics, naming conventions, security considerations, common pitfalls, conflict resolution, and time‑management strategies for development teams.

Code reviewSoftware Engineeringrefactoring
0 likes · 20 min read
Comprehensive Guide to Effective Code Review: Principles, Practices, and Common Challenges
Ops Development & AI Practice
Ops Development & AI Practice
Mar 26, 2024 · Fundamentals

Add Parameters or Create a New Function? Choosing the Right Refactor

When extending existing code, developers must decide between adding parameter‑based conditional logic or introducing a new function, weighing benefits such as code centralization against drawbacks like increased complexity, readability, and maintainability, while considering single‑responsibility, reuse, default parameters, overloads, and design patterns.

code maintainabilityfunction designparameter handling
0 likes · 4 min read
Add Parameters or Create a New Function? Choosing the Right Refactor
Architect
Architect
Mar 21, 2024 · Backend Development

Refactoring a Complex Order Process with a Three‑Layer Interface and Strategy Template

This article analyzes the problems of a scattered, poorly‑designed order‑processing codebase, proposes a three‑layer interface combined with a strategy‑template pattern, walks through concrete Java implementations, testing and gray‑release safeguards, and shows how the redesign improves readability, maintainability, and extensibility.

Design PatternsMicroservicesStrategy Pattern
0 likes · 15 min read
Refactoring a Complex Order Process with a Three‑Layer Interface and Strategy Template
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Mar 21, 2024 · Fundamentals

Refactoring Multi‑Board SDK Integration Using Abstract Factory, Adapter, and Facade Patterns

The article analyzes a multi‑board Android SDK integration problem, identifies hard‑coded type checks and inconsistent APIs, and proposes a refactor that employs the Abstract Factory, Adapter, and Facade design patterns with Kotlin examples to achieve loose coupling, extensibility, and clearer business concepts.

Abstract FactoryAdapter PatternDesign Patterns
0 likes · 10 min read
Refactoring Multi‑Board SDK Integration Using Abstract Factory, Adapter, and Facade Patterns
Zhuanzhuan Tech
Zhuanzhuan Tech
Mar 20, 2024 · Backend Development

Technical Refactoring of ZhiZhi Consumer Installment System: Architecture, Design, and Implementation

This article details the background, goals, design decisions, code architecture, deployment process, monitoring setup, and outcomes of a comprehensive backend refactoring effort for the ZhiZhi consumer installment platform, illustrating how modularization, design patterns, and incremental migration improve maintainability and performance.

architecturerefactoring
0 likes · 10 min read
Technical Refactoring of ZhiZhi Consumer Installment System: Architecture, Design, and Implementation
php Courses
php Courses
Mar 15, 2024 · Fundamentals

The Art of Taming Legacy Code: Strategies, Examples, and Future Directions

This article explores the challenges of legacy code through practical examples, offering step‑by‑step refactoring strategies, testing, documentation, environment management, and innovative tooling like ServBay to help developers modernize both backend and frontend systems while fostering professional growth.

Legacy Codebest practicesfrontend
0 likes · 6 min read
The Art of Taming Legacy Code: Strategies, Examples, and Future Directions
dbaplus Community
dbaplus Community
Mar 10, 2024 · Backend Development

How to Seamlessly Refactor MVC Projects into DDD Architecture

This article explains why legacy MVC codebases become tangled, introduces the domain‑driven design (DDD) layered architecture, and provides a step‑by‑step, low‑cost migration path—including layer mapping, call‑chain illustration, common pitfalls, and a concrete refactoring example with design patterns and code snippets.

DDDDesign PatternsMVC
0 likes · 20 min read
How to Seamlessly Refactor MVC Projects into DDD Architecture
Architect's Alchemy Furnace
Architect's Alchemy Furnace
Mar 6, 2024 · Fundamentals

Why Quick Fixes Kill Code Quality and How to Avoid Them

The article warns that relying on quick, superficial bug fixes creates hidden technical debt, explains why deep understanding of code changes matters, and offers practical advice to keep code clean, maintainable, and resilient in complex systems.

DebuggingSoftware EngineeringTechnical Debt
0 likes · 6 min read
Why Quick Fixes Kill Code Quality and How to Avoid Them
Architect's Guide
Architect's Guide
Feb 6, 2024 · Backend Development

12 Counterproductive Coding Practices Illustrated by the Fictional Programmer “Er Gou”

The article humorously lists twelve detrimental coding habits—such as over‑splitting microservices, writing excessively long methods, nesting deep conditionals, random variable names, misleading comments, copy‑pasting code, ignoring logs, and reinventing wheels—that reduce code readability and increase maintenance difficulty.

MicroservicesSoftware Engineeringbad practices
0 likes · 11 min read
12 Counterproductive Coding Practices Illustrated by the Fictional Programmer “Er Gou”
MaGe Linux Operations
MaGe Linux Operations
Feb 4, 2024 · Fundamentals

Why TDD and BDD Matter: Master the Red‑Green‑Refactor Cycle

This article explains the core concepts, rhythms, and practical applications of Test‑Driven Development (TDD) and Behavior‑Driven Development (BDD), illustrating how the red‑green‑refactor loop and business‑focused scenarios improve code quality, design, and collaboration between developers and stakeholders.

BDDBehavior Driven DevelopmentSoftware Testing
0 likes · 19 min read
Why TDD and BDD Matter: Master the Red‑Green‑Refactor Cycle
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Jan 24, 2024 · Mobile Development

Unlock Peak Kotlin Performance with Advanced Refactoring Techniques

This article guides developers through a series of Kotlin refactoring steps—replacing when statements with HashMap, introducing payload mechanisms, infix functions, inline registration, and delegated properties—to dramatically improve event‑handling performance, readability, and maintainability while adhering to the single‑responsibility principle.

HashMapInfix FunctionsKotlin
0 likes · 16 min read
Unlock Peak Kotlin Performance with Advanced Refactoring Techniques
php Courses
php Courses
Jan 22, 2024 · Backend Development

Common PHP Code Smells and Refactoring Solutions

This article explains typical PHP code smells such as long methods, large classes, duplicate code, excessive comments, complex conditionals, and infinite loops, and provides concrete refactoring examples to improve readability, maintainability, and overall code quality.

BackendPHPSoftware Engineering
0 likes · 8 min read
Common PHP Code Smells and Refactoring Solutions
ITPUB
ITPUB
Dec 28, 2023 · Backend Development

How We Refactored a 670k‑Line, 46‑Module Ticket System to Slash Deployment Time

This article details the background, pain points, and step‑by‑step technical solution behind refactoring a massive 670,000‑line, 46‑module ticketing application at Alibaba, highlighting architecture redesign, code simplification, performance gains, and a pragmatic rollout plan.

BackendJavaMicroservices
0 likes · 26 min read
How We Refactored a 670k‑Line, 46‑Module Ticket System to Slash Deployment Time
macrozheng
macrozheng
Dec 21, 2023 · Fundamentals

Keeping Code Clean During Rapid Development: Review and Refactoring Strategies

The article shares practical experiences and advice on maintaining code quality through disciplined code reviews, incremental refactoring, and team-wide coding standards, emphasizing readability and continuous improvement to prevent technical debt and the broken‑window effect in fast‑moving projects.

Code reviewTechnical Debtcode quality
0 likes · 9 min read
Keeping Code Clean During Rapid Development: Review and Refactoring Strategies
Programmer DD
Programmer DD
Dec 15, 2023 · Backend Development

12 Counterproductive Coding Practices That Kill Readability

The article enumerates twelve common defensive coding habits—like per‑table microservices, overly long methods, deep nesting, misleading comments, and unnecessary frameworks—that degrade readability and increase maintenance effort, illustrating each with a fictional programmer’s missteps and their impact on teams.

Javacode qualityrefactoring
0 likes · 11 min read
12 Counterproductive Coding Practices That Kill Readability
转转QA
转转QA
Dec 6, 2023 · Backend Development

Store System Refactoring Types, Challenges, and Testing Strategies

This article analyzes the current store system issues, outlines various refactoring types and their difficulties, presents common efficiency measures, and details testing schemes for both unchanged‑business and changed‑business refactoring cases, highlighting objectives, challenges, processes, and overall effectiveness.

Backendperformancerefactoring
0 likes · 8 min read
Store System Refactoring Types, Challenges, and Testing Strategies
ITPUB
ITPUB
Dec 2, 2023 · Fundamentals

12 Toxic Coding Habits That Destroy Readability (And How to Avoid Them)

The article lists twelve common anti‑patterns—such as over‑splitting microservices, writing excessively long methods, random naming, misleading comments, and avoiding logging—that dramatically reduce code readability and increase maintenance difficulty, illustrating each with a fictional developer’s missteps.

MicroservicesSoftware Engineeringbad practices
0 likes · 11 min read
12 Toxic Coding Habits That Destroy Readability (And How to Avoid Them)
Java Architect Essentials
Java Architect Essentials
Nov 24, 2023 · Fundamentals

12 Coding Practices That Reduce Code Readability

The article lists twelve common coding anti‑patterns—such as over‑splitting microservices, writing excessively long methods, deep nesting, misleading comments, copying code, ignoring logs, and building unnecessary frameworks—that hurt readability and increase maintenance difficulty.

best practicescode readabilityrefactoring
0 likes · 11 min read
12 Coding Practices That Reduce Code Readability
Java High-Performance Architecture
Java High-Performance Architecture
Nov 24, 2023 · Fundamentals

12 Coding Anti‑Patterns That Destroy Readability (And How to Avoid Them)

The article humorously lists twelve common coding “techniques” that reduce readability and increase maintenance difficulty, illustrating each with exaggerated examples of a programmer named Er Gou who over‑splits microservices, writes massive methods, misuses comments, copies code, and ignores logging.

Anti-PatternsMicroservicesSoftware Engineering
0 likes · 10 min read
12 Coding Anti‑Patterns That Destroy Readability (And How to Avoid Them)
Sanyou's Java Diary
Sanyou's Java Diary
Nov 16, 2023 · Fundamentals

Why Readable Code Wins: Practical Tips to Boost Maintainability

This article explores the importance of code readability, comparing simple versus layered implementations, and offers concrete strategies—such as using clear intent, hierarchical structure, concise methods, pure conditions, and minimal comments—to improve maintainability and reduce side effects in everyday software development.

best practicesclean codecode readability
0 likes · 14 min read
Why Readable Code Wins: Practical Tips to Boost Maintainability
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 16, 2023 · Fundamentals

How to Boost Code Readability: Practical Tips and Refactoring Strategies

This article explores why code readability matters, compares two implementation styles, outlines three key readability dimensions—plain expression, clear intent, and hierarchical structure—and provides actionable refactoring tips, code‑generation insights, and best‑practice recommendations for developers seeking maintainable, easy‑to‑understand software.

Software Engineeringcode readabilitymaintainability
0 likes · 14 min read
How to Boost Code Readability: Practical Tips and Refactoring Strategies
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 7, 2023 · Frontend Development

How to Turn Technical Debt into Growth: Refactoring Lessons from Alibaba Cloud

This article shares a developer’s three‑year journey on Alibaba Cloud’s platform, exploring the nature of technical debt, categorizing its causes, and illustrating how micro‑refactorings and configuration‑driven upgrades can steadily improve code quality, accelerate feature delivery, and align engineering with business goals.

ConfigurationSoftware ArchitectureTechnical Debt
0 likes · 10 min read
How to Turn Technical Debt into Growth: Refactoring Lessons from Alibaba Cloud
FunTester
FunTester
Nov 1, 2023 · Fundamentals

Understanding and Managing Technical Debt in Software Development

This article explains what technical debt is, its harmful effects, common scenarios that generate it, common misconceptions, and practical strategies for managing and repaying technical debt to keep software projects maintainable and cost‑effective.

Software EngineeringTechnical Debtcode quality
0 likes · 25 min read
Understanding and Managing Technical Debt in Software Development
Tencent Cloud Developer
Tencent Cloud Developer
Oct 30, 2023 · Fundamentals

Understanding and Managing Technical Debt in Software Development

Technical debt—ranging from low‑level design flaws and inadequate testing to strategic shortcuts and evolving third‑party dependencies—accumulates when urgent product demands bypass best practices, leading to higher costs, slower delivery, and poorer quality, so teams must make debt visible, enforce strong completion criteria, and allocate regular sprint capacity to prioritize, refactor, and repay high‑interest debt while recognizing when legacy code can be retired.

Technical Debtrefactoringrisk management
0 likes · 25 min read
Understanding and Managing Technical Debt in Software Development
Java Interview Crash Guide
Java Interview Crash Guide
Oct 13, 2023 · Backend Development

Eliminate Complex if‑else Chains with Strategy and Chain‑of‑Responsibility Patterns in Java

This article demonstrates how to replace cumbersome if‑else or switch‑case logic in Java receipt processing with clean, extensible solutions using the Strategy pattern combined with a Map dictionary, and the Chain of Responsibility pattern, while preserving the Open/Closed principle.

Chain of ResponsibilityJavaStrategy Pattern
0 likes · 14 min read
Eliminate Complex if‑else Chains with Strategy and Chain‑of‑Responsibility Patterns in Java
Architect
Architect
Oct 5, 2023 · Fundamentals

Mastering Clean Code: Naming, Classes, Functions, and Tests Explained

This article explains why clean code matters, demonstrates how meaningful naming, single‑responsibility classes, well‑structured functions, and disciplined testing (TDD and the FIRST principles) improve readability, maintainability, and productivity, using concrete Java examples, refactorings, and step‑by‑step guidelines.

TDDclean codenaming conventions
0 likes · 17 min read
Mastering Clean Code: Naming, Classes, Functions, and Tests Explained
Java High-Performance Architecture
Java High-Performance Architecture
Oct 1, 2023 · Fundamentals

Why Clean Code Matters: Practical Tips to Write Maintainable Java

This article summarizes key lessons from 'Clean Code', explaining why maintaining clean, readable Java code boosts productivity, reduces bugs and costs, and detailing practical guidelines for naming, class design, functions, testing, and refactoring to help developers write high‑quality, maintainable software.

clean codecoding standardsrefactoring
0 likes · 15 min read
Why Clean Code Matters: Practical Tips to Write Maintainable Java
Architecture Digest
Architecture Digest
Sep 28, 2023 · Fundamentals

How to Write Clean and Maintainable Code: Naming, Classes, Functions, and Testing

This article explains why clean code is essential for productivity and team collaboration, and provides practical guidelines on naming, class design, function design, and testing—including principles like single responsibility, SOLID, meaningful naming, minimal parameters, and test‑driven development—to help developers produce readable, extensible, and reliable software.

SOLIDclean codenaming conventions
0 likes · 14 min read
How to Write Clean and Maintainable Code: Naming, Classes, Functions, and Testing
Java Architect Essentials
Java Architect Essentials
Sep 27, 2023 · Fundamentals

How to Write Clean Code: Naming, Classes, Functions, and Testing Best Practices

This article explains why clean code is essential for productivity and business health, and provides practical guidelines on naming, class design, function design, and testing—including code examples, refactoring techniques, and quality‑checking tools—to help developers produce readable, maintainable, and extensible software.

TDDclean codecode quality
0 likes · 14 min read
How to Write Clean Code: Naming, Classes, Functions, and Testing Best Practices
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Sep 26, 2023 · Fundamentals

Understanding the Strategy Pattern in JavaScript

This article explains the Strategy design pattern, demonstrates its implementation in JavaScript through three code versions, discusses the drawbacks of naïve if‑else approaches, and outlines the pattern's advantages and disadvantages for creating flexible, maintainable code.

Design PatternsJavaScriptSoftware Architecture
0 likes · 6 min read
Understanding the Strategy Pattern in JavaScript
Continuous Delivery 2.0
Continuous Delivery 2.0
Sep 4, 2023 · Fundamentals

Mob Programming: A 2009 Refactoring Case Study

This article recounts a 2009 mob programming session in which the GoCD team refactored a module by introducing a missing domain object, illustrating the benefits of whole‑team collaboration, the prerequisites of a strong development environment and automated tests, and detailing the step‑by‑step code transformations.

Domain-Driven Designrefactoring
0 likes · 7 min read
Mob Programming: A 2009 Refactoring Case Study
Tencent Cloud Developer
Tencent Cloud Developer
Aug 28, 2023 · Backend Development

Effective Code Review and Engineering Best Practices

Effective code review bridges design and implementation by focusing on concrete Go code, enforcing limits on file and function size, nesting depth, and duplication, while promoting early returns, composition over inheritance, clear package structure, and disciplined formatting to prevent hidden technical debt.

Code reviewarchitecturerefactoring
0 likes · 21 min read
Effective Code Review and Engineering Best Practices
Su San Talks Tech
Su San Talks Tech
Aug 20, 2023 · Fundamentals

How to Keep Code Clean During Rapid Java Backend Iterations

The author shares personal experiences of rushed code reviews in a busy Java micro‑service team, highlights the loss of code ownership, discusses common code smells, and explains how disciplined reviews and incremental refactoring can restore readability and maintainability.

Code reviewJavaSoftware Engineering
0 likes · 9 min read
How to Keep Code Clean During Rapid Java Backend Iterations
Selected Java Interview Questions
Selected Java Interview Questions
Aug 17, 2023 · Fundamentals

Understanding the Chain of Responsibility Design Pattern with Java Examples

This article introduces the Chain of Responsibility design pattern, explains its purpose and typical use cases, demonstrates common pitfalls with a naïve implementation, and provides step‑by‑step Java refactorings—including a basic chain, an abstract handler hierarchy, and a factory‑based configuration—to illustrate how to build flexible, maintainable processing pipelines.

Chain of ResponsibilityDesign PatternsJava
0 likes · 11 min read
Understanding the Chain of Responsibility Design Pattern with Java Examples
Zhuanzhuan Tech
Zhuanzhuan Tech
Aug 16, 2023 · Backend Development

Refactoring the Game Account Order Process with a Three‑Layer Interface and Strategy‑Template Pattern

This article describes how a game‑account order system with scattered core code and no design patterns was refactored into a clean three‑layer interface architecture using a strategy‑template approach, detailing the design, implementation, testing, gray‑release strategy, and post‑deployment safeguards.

Backend ArchitectureDesign PatternsJava
0 likes · 12 min read
Refactoring the Game Account Order Process with a Three‑Layer Interface and Strategy‑Template Pattern
macrozheng
macrozheng
Aug 5, 2023 · Fundamentals

Why Code Reviews Fail and How Refactoring Can Rescue Your Project

The author reflects on rushed code reviews during intense development cycles, explains how neglecting thorough reviews leads to loss of code ownership, and advocates systematic reviews, continuous refactoring, and clean‑code practices to maintain project health and improve team collaboration.

Code reviewSoftware Engineeringbest practices
0 likes · 9 min read
Why Code Reviews Fail and How Refactoring Can Rescue Your Project
21CTO
21CTO
Aug 1, 2023 · Artificial Intelligence

How to Set Up and Master CodeGPT in VS Code for AI-Powered Coding

This guide walks you through installing the CodeGPT extension in Visual Studio Code, configuring your OpenAI API key, and using its features—code generation, explanation, refactoring, and unit test creation—to boost productivity with AI-assisted programming.

AI CodingCode GenerationCodeGPT
0 likes · 8 min read
How to Set Up and Master CodeGPT in VS Code for AI-Powered Coding
Tencent Cloud Developer
Tencent Cloud Developer
Jul 25, 2023 · Fundamentals

From Code Design to Refactoring: Improving Code Quality

The article shows how high‑quality code emerges from solid design and disciplined refactoring, using an image‑optimization tool case study to illustrate breaking tangled if‑else logic into Strategy and Template Method patterns, applying SOLID principles, six quality pillars, and managing technical debt and code smells.

SOLIDTechnical Debtrefactoring
0 likes · 30 min read
From Code Design to Refactoring: Improving Code Quality
FunTester
FunTester
Jul 18, 2023 · Fundamentals

9 Common Code Smells and How to Fix Them for Cleaner, Safer Software

This article examines nine frequent coding pitfalls—from inconsistent naming and missing comments to poor error handling, hard‑coded values, inadequate testing, over‑optimization, security oversights, and weak version‑control practices—offering concrete refactoring examples and best‑practice recommendations to improve readability, maintainability, and reliability.

SecuritySoftware EngineeringVersion Control
0 likes · 18 min read
9 Common Code Smells and How to Fix Them for Cleaner, Safer Software
TAL Education Technology
TAL Education Technology
Jul 13, 2023 · Fundamentals

Understanding Cyclomatic Complexity and Code Quality Metrics

This article explains cyclomatic complexity, its calculation formulas, practical examples, and how to measure and improve code quality using tools like SonarQube, ESLint, and codeMetrics, while also presenting refactoring techniques such as single‑responsibility, open‑closed, polymorphism, early returns, and functional programming to reduce complexity.

JavaScriptSonarQubecode metrics
0 likes · 13 min read
Understanding Cyclomatic Complexity and Code Quality Metrics
Ctrip Technology
Ctrip Technology
Jul 13, 2023 · Backend Development

Refactoring Practices and Strategies for Large‑Scale Microservice Systems

This article outlines the definition, motivations, impact levels, planning, communication, layered design, gray‑release techniques, quality improvement measures, and observability considerations for large‑scale backend refactoring in microservice architectures, drawing on practical experience from Ctrip's end‑to‑end refactoring project.

Software Architecturecode qualityrefactoring
0 likes · 11 min read
Refactoring Practices and Strategies for Large‑Scale Microservice Systems
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 29, 2023 · Fundamentals

Can You Write Clean Code Without Comments? Strategies to Eliminate Bad Annotations

This article explores why programmers dislike both reading uncommented code and writing comments, outlines the drawbacks of excessive annotations, categorizes common bad comment patterns, and offers practical techniques—such as self‑descriptive naming, refactoring, and using built‑in validation methods—to produce clear, maintainable code without relying on comments.

Software Engineeringclean codecode comments
0 likes · 7 min read
Can You Write Clean Code Without Comments? Strategies to Eliminate Bad Annotations
JD Tech
JD Tech
Jun 27, 2023 · Fundamentals

How to Quickly Learn and Master Coding Skills: From Learning Mindset to Refactoring Principles

This article explores rapid ways to acquire coding abilities by emphasizing the role of cognition, outlining learning paths such as setting direction, finding role models, applying knowledge, avoiding cognitive traps, studying code examples, and understanding refactoring principles through a practical RocketMQ case study.

Software Engineeringbest practicescoding
0 likes · 21 min read
How to Quickly Learn and Master Coding Skills: From Learning Mindset to Refactoring Principles
Programmer DD
Programmer DD
May 24, 2023 · Fundamentals

Mastering the Chain of Responsibility Pattern: From Flawed IF Chains to Elegant Handlers

This article explains the Chain of Responsibility design pattern, shows why naïve nested if‑statements are problematic, demonstrates a step‑by‑step refactor using linked handlers, introduces an abstract handler hierarchy, and finally presents a factory‑based dynamic configuration for scalable request processing in Java.

Chain of ResponsibilitySoftware Architecturedesign pattern
0 likes · 12 min read
Mastering the Chain of Responsibility Pattern: From Flawed IF Chains to Elegant Handlers
Java Architect Essentials
Java Architect Essentials
May 23, 2023 · Fundamentals

Replacing If‑Else: Five Techniques from Basic to Advanced

This article explores why traditional if‑else statements often lead to complex, hard‑to‑maintain code and presents five progressive techniques—including removing unnecessary else blocks, using fast‑return guard clauses, converting to dictionaries, and applying the strategy pattern—to improve readability, extensibility, and adherence to SOLID principles.

Design PatternsSoftware EngineeringStrategy Pattern
0 likes · 6 min read
Replacing If‑Else: Five Techniques from Basic to Advanced
Continuous Delivery 2.0
Continuous Delivery 2.0
May 22, 2023 · Fundamentals

Improving Code Quality: Five Practical Refactoring Techniques for Better Software

This article outlines five practical strategies for improving code quality—including appropriate commenting, limiting function parameter length, avoiding overly long functions, simplifying nested conditionals, and applying design patterns—while emphasizing the importance of refactoring to enhance readability, maintainability, and testability of software.

Design Patternscode qualityrefactoring
0 likes · 10 min read
Improving Code Quality: Five Practical Refactoring Techniques for Better Software
php Courses
php Courses
May 19, 2023 · Backend Development

Eliminating Duplicate and Redundant Code in PHP: Refactoring Techniques

This article explains how to remove duplicate and redundant PHP code by applying refactoring principles such as the DRY rule, using functions and classes, adopting naming conventions, simplifying conditionals, and externalizing configuration, thereby improving readability, maintainability, and performance.

Backend DevelopmentDRYPHP
0 likes · 7 min read
Eliminating Duplicate and Redundant Code in PHP: Refactoring Techniques
DevOps
DevOps
May 18, 2023 · Fundamentals

Understanding Technical Debt: Definitions, Types, Impacts, and Management Strategies

This article explains the concept of technical debt, its origins, various classifications, the economic analogy with financial debt, the risks of ignoring it, and practical approaches for identifying, prioritizing, and repaying it through regular refactoring and disciplined engineering practices.

DevOpsSoftware EngineeringSoftware quality
0 likes · 22 min read
Understanding Technical Debt: Definitions, Types, Impacts, and Management Strategies
ByteFE
ByteFE
May 17, 2023 · Backend Development

Domain‑Driven Design for Marketing: Abstracting Limits, Rules, Benefits, and Feedback with Node.js

This article explores how to break down the complex marketing domain into modular, atomic components—limits, rules, benefits, and feedback—using Node.js, demonstrates a flexible factory pattern for assembling activities, and provides practical advice for refactoring and product design in real‑world projects.

Domain-Driven Designnodejsrefactoring
0 likes · 24 min read
Domain‑Driven Design for Marketing: Abstracting Limits, Rules, Benefits, and Feedback with Node.js
Top Architect
Top Architect
May 15, 2023 · Fundamentals

Understanding the Chain of Responsibility Design Pattern with Java Examples

This article explains the Chain of Responsibility design pattern, its definition, typical use cases, drawbacks of a naïve implementation, and step‑by‑step refactoring using abstract handlers, a handler factory, and Java code samples to illustrate a clean, extensible solution.

Chain of ResponsibilityDesign PatternsJava
0 likes · 13 min read
Understanding the Chain of Responsibility Design Pattern with Java Examples
Tencent Cloud Developer
Tencent Cloud Developer
May 11, 2023 · Artificial Intelligence

Leveraging ChatGPT‑4 for Code Generation, Refactoring, and Testing in Software Development

The article demonstrates how ChatGPT‑4 outperforms its predecessor in logical reasoning and code generation, helping developers craft regexes, refactor Go functions, implement business logic, fix parsing bugs, and suggest clearer names, while rapidly producing unit tests and accelerating low‑risk development tasks without fully replacing engineers.

AI-assisted programmingChatGPT-4Code Generation
0 likes · 8 min read
Leveraging ChatGPT‑4 for Code Generation, Refactoring, and Testing in Software Development
JD Cloud Developers
JD Cloud Developers
Apr 25, 2023 · Fundamentals

How to Write High-Quality Code: From Learning to Refactoring

This article explores how developers can master coding skills by cultivating learning awareness, choosing good role models, applying knowledge in real projects, avoiding cognitive traps, and practicing systematic refactoring, all illustrated with practical examples and a RocketMQ case study.

Software Engineeringlearningprogramming principles
0 likes · 19 min read
How to Write High-Quality Code: From Learning to Refactoring
21CTO
21CTO
Apr 16, 2023 · Fundamentals

How to Write High‑Quality Code: From Learning to Refactoring

This article explores how developers can master code quality by adopting a learning mindset, studying exemplary code, applying core programming principles, analyzing real‑world examples such as RocketMQ file‑warming, and finally refactoring code to improve maintainability and performance.

Software Engineeringcode qualitylearning
0 likes · 17 min read
How to Write High‑Quality Code: From Learning to Refactoring
Java Captain
Java Captain
Apr 11, 2023 · Backend Development

Improving Java Backend Code: Bean Conversion, DTO Handling, Lombok, Validation, and Refactoring Practices

This article provides comprehensive guidance on Java backend development, covering IDE selection, bean and DTO conversion techniques, validation with JSR‑303, extensive Lombok usage, builder patterns, proxy design, refactoring strategies, and the balance between business‑driven and technology‑driven development.

Design PatternsJavaLombok
0 likes · 25 min read
Improving Java Backend Code: Bean Conversion, DTO Handling, Lombok, Validation, and Refactoring Practices
Alibaba Cloud Developer
Alibaba Cloud Developer
Apr 11, 2023 · Fundamentals

Why Software Gets Complex and How to Measure & Tame It

This article examines the root causes of software complexity, explains how to quantify it using metrics such as Halstead, cyclomatic and Ousterhout complexity, showcases real code examples, and offers practical strategies—including high cohesion, low coupling, strategic design, documentation, and refactoring—to prevent and reduce complexity in large systems.

Halsteadcode metricscyclomatic complexity
0 likes · 22 min read
Why Software Gets Complex and How to Measure & Tame It
Bilibili Tech
Bilibili Tech
Apr 7, 2023 · Mobile Development

Design and Refactoring of Inline Video Playback in Feed Streams

The article describes a modular refactor of Bilibili’s feed‑stream inline video playback, introducing a central ModuleInlineManager, ViewHandler, ViewFetcher, and an InlineController that encapsulate player logic, eliminate duplicated code, simplify maintenance, and enable flexible feature testing across diverse feed pages.

architectureiOSinline video
0 likes · 11 min read
Design and Refactoring of Inline Video Playback in Feed Streams
JD Retail Technology
JD Retail Technology
Apr 3, 2023 · Fundamentals

How to Master Clean Code: From Learning to Refactoring with Real Examples

This article explores a systematic approach to becoming a better programmer, covering learning mindset, selecting role models, applying knowledge, coding principles, performance considerations, and refactoring techniques, illustrated with a RocketMQ file‑prewarm case study and practical guidelines for writing maintainable, high‑quality code.

RocketMQSoftware Engineeringclean code
0 likes · 17 min read
How to Master Clean Code: From Learning to Refactoring with Real Examples
DevOps
DevOps
Mar 21, 2023 · Backend Development

Effective Unit Testing Strategies for Large Legacy Systems

The article shares practical techniques for improving unit test coverage in massive, low‑quality legacy codebases, including creating isolated new modules, applying test‑driven development, decoupling through design patterns, extracting interfaces, using seams, and employing mocking to overcome static dependencies.

Legacy CodeMockingdependency-injection
0 likes · 9 min read
Effective Unit Testing Strategies for Large Legacy Systems
php Courses
php Courses
Mar 14, 2023 · Backend Development

PHP Refactoring Techniques: Naming, Extraction, Early Return, Collections, and Consistency

This article demonstrates practical PHP refactoring techniques—including expressive naming, method extraction, early returns, leveraging Laravel collections, and maintaining code consistency—by showing before-and-after code examples that improve readability, reduce duplication, and simplify logic for backend developers.

Backend DevelopmentLaravelPHP
0 likes · 13 min read
PHP Refactoring Techniques: Naming, Extraction, Early Return, Collections, and Consistency
Alipay Experience Technology
Alipay Experience Technology
Mar 14, 2023 · Frontend Development

Why High-Quality Code Matters: Principles, Bad Smells, and Refactoring Techniques

This article explains why maintainable, robust, and testable code is essential for front‑end development, shares insights from renowned programmers, defines key quality metrics, outlines SOLID and KISS design principles, identifies common code smells, and demonstrates practical refactoring patterns with real JavaScript examples.

KISSSOLIDSoftware Engineering
0 likes · 35 min read
Why High-Quality Code Matters: Principles, Bad Smells, and Refactoring Techniques
High Availability Architecture
High Availability Architecture
Feb 23, 2023 · Backend Development

Clean Code Principles and Practical Java Refactoring Guidelines

This article presents a comprehensive guide to improving Java code quality by emphasizing simplicity, leveraging language features, consolidating similar logic, and structuring APIs to clearly distinguish required and optional parameters, illustrated with side‑by‑side bad and good implementations and practical recommendations.

Javaclean coderefactoring
0 likes · 13 min read
Clean Code Principles and Practical Java Refactoring Guidelines
Alibaba Cloud Developer
Alibaba Cloud Developer
Feb 23, 2023 · Fundamentals

Why Refactoring Matters: Lessons from "Refactoring" for New Engineers

The article reviews the book “Refactoring: Improving the Design of Existing Code”, explains what refactoring is, why it is essential for maintainability and efficiency, and presents practical techniques—such as removing duplicate code, improving naming, simplifying conditions, and using enums—to help engineers with one‑year experience write cleaner, more maintainable Java code.

JavaSoftware Engineeringclean code
0 likes · 17 min read
Why Refactoring Matters: Lessons from "Refactoring" for New Engineers
Code Ape Tech Column
Code Ape Tech Column
Feb 17, 2023 · Backend Development

45 Essential Java Code Quality Tips and Best Practices

This article presents 45 practical Java coding guidelines covering naming conventions, formatting, commenting, method extraction, error handling, thread safety, design patterns, database access, and many other best‑practice techniques to help developers write cleaner, more maintainable backend code.

best practicescode qualitycoding standards
0 likes · 27 min read
45 Essential Java Code Quality Tips and Best Practices
Top Architect
Top Architect
Feb 8, 2023 · Fundamentals

Clean Code Practices: Naming, Classes, Functions, and Testing Guidelines

This article explains why clean code matters and provides practical guidelines on naming, class design, function decomposition, SOLID principles, testing strategies such as TDD and FIRST, as well as tooling like SonarLint to improve code quality and maintainability.

SOLID principlesclean codenaming conventions
0 likes · 18 min read
Clean Code Practices: Naming, Classes, Functions, and Testing Guidelines
macrozheng
macrozheng
Feb 3, 2023 · Fundamentals

Why Clean Code Matters: Practical Tips for Naming, Classes, Functions, and Tests

This article explains why clean, well‑structured code is essential for productivity and project success, and provides concrete guidance on naming, class design, function composition, testing practices, and tools to help developers write maintainable, high‑quality software.

best practicesclean coderefactoring
0 likes · 13 min read
Why Clean Code Matters: Practical Tips for Naming, Classes, Functions, and Tests
IT Architects Alliance
IT Architects Alliance
Jan 30, 2023 · Backend Development

From Monolithic to Distributed Architecture: A Detailed Inventory System Case Study

This article explains the concept of software architecture, why architectural styles are chosen, compares monolithic and distributed architectures, analyzes their pros and cons, and walks through a real‑world inventory system migration from a single‑service design to a micro‑service, CQRS‑based distributed solution with code examples and discussion of distributed transactions.

Software Architecturemonolithicrefactoring
0 likes · 16 min read
From Monolithic to Distributed Architecture: A Detailed Inventory System Case Study
21CTO
21CTO
Jan 17, 2023 · Fundamentals

Mastering Code Review: Proven Practices to Boost Code Quality and Team Collaboration

This guide explains why code review is essential, outlines practical guidelines for reviewers and submitters, shares real‑world practices from leading companies, and highlights common code smells such as DRY, primitive obsession, lock misuse, and pagination problems, helping teams improve code quality and maintainability.

Code reviewcode qualityrefactoring
0 likes · 20 min read
Mastering Code Review: Proven Practices to Boost Code Quality and Team Collaboration
IT Architects Alliance
IT Architects Alliance
Jan 14, 2023 · Backend Development

From Monolithic to Distributed Architecture: A Case Study of an Inventory System and CQRS Refactoring

This article explains the concept of software architecture, compares monolithic and distributed styles, discusses their advantages and drawbacks, and details a real-world inventory system migration from a monolithic design to a distributed architecture using functional and business decomposition, CQRS, and code refactoring.

Software Architecturemonolithicrefactoring
0 likes · 17 min read
From Monolithic to Distributed Architecture: A Case Study of an Inventory System and CQRS Refactoring
Alibaba Cloud Developer
Alibaba Cloud Developer
Jan 3, 2023 · Fundamentals

Mastering Code Review: Proven Practices to Boost Code Quality and Team Collaboration

This comprehensive guide explains why code review matters, shares real‑world practices from leading companies, outlines concrete steps for submitters and reviewers, warns against common pitfalls like DRY violations and poor pagination, and offers actionable tips to make reviews effective and sustainable.

Code reviewSoftware Engineeringcode quality
0 likes · 19 min read
Mastering Code Review: Proven Practices to Boost Code Quality and Team Collaboration
21CTO
21CTO
Nov 17, 2022 · Fundamentals

Why Clean Code Principles Matter for Every Developer

This article shares practical takeaways from the book "Clean Code", covering why messy code hurts productivity, how to name variables and functions better, essential class design rules, error handling, refactoring tips, and a brief look at concurrency and iterative development.

clean codecoding standardsrefactoring
0 likes · 9 min read
Why Clean Code Principles Matter for Every Developer
Top Architect
Top Architect
Oct 21, 2022 · Backend Development

From Monolithic to Distributed Architecture: A Detailed Inventory System Case Study

This article explains the concepts of software architecture, compares monolithic and distributed styles, and walks through a real‑world inventory system migration—including functional and business splitting, CQRS adoption, and distributed transaction challenges—illustrated with Java code examples.

CQRSDistributed SystemsJava
0 likes · 17 min read
From Monolithic to Distributed Architecture: A Detailed Inventory System Case Study
Sanyou's Java Diary
Sanyou's Java Diary
Oct 20, 2022 · Backend Development

45 Essential Java Coding Practices to Rescue Legacy Code

This article compiles 45 practical Java coding tips—from naming conventions and formatting to exception handling, thread safety, design patterns, and refactoring strategies—aimed at improving readability, maintainability, and performance of existing codebases while preventing common pitfalls.

JavaSoftware Engineeringbest practices
0 likes · 29 min read
45 Essential Java Coding Practices to Rescue Legacy Code
Architect's Guide
Architect's Guide
Oct 2, 2022 · Fundamentals

Understanding the Chain of Responsibility Design Pattern with Java Examples

This article explains the Chain of Responsibility design pattern, its typical use cases, shows problematic implementations, and demonstrates step‑by‑step refactorings—including abstract handlers, client simplification, and enum‑based factory configuration—using clear Java code examples.

Chain of ResponsibilityJavarefactoring
0 likes · 11 min read
Understanding the Chain of Responsibility Design Pattern with Java Examples
dbaplus Community
dbaplus Community
Sep 11, 2022 · Backend Development

Refactoring a Monolithic Inventory System to Distributed Microservices with CQRS

Facing rapid growth and stability issues, the team transformed a monolithic inventory platform into a distributed microservice architecture, employing functional and business decomposition, CQRS principles, and careful code refactoring to improve availability, scalability, and maintainability while addressing challenges like distributed transactions and data consistency.

CQRSMicroservicesarchitecture
0 likes · 18 min read
Refactoring a Monolithic Inventory System to Distributed Microservices with CQRS
Selected Java Interview Questions
Selected Java Interview Questions
Sep 11, 2022 · Backend Development

Refactoring Classic Design Patterns with Java 8 Lambdas

This article demonstrates how Java 8’s lambda expressions and functional interfaces can be used to refactor classic design‑pattern implementations—Strategy, Template Method, Observer, and Chain of Responsibility—into more concise, maintainable backend code, providing both traditional Java examples and their streamlined lambda equivalents.

Design PatternsLambdajava8
0 likes · 10 min read
Refactoring Classic Design Patterns with Java 8 Lambdas
Sohu Tech Products
Sohu Tech Products
Sep 7, 2022 · Fundamentals

Refactoring Techniques: Extract Function, Parameterize, Strategy Pattern, and More

This article presents a series of refactoring techniques—including extracting functions, parameterizing functions, applying the strategy pattern, extracting variables, splitting loops, and using guard clauses—illustrated with JavaScript code examples to improve readability, maintainability, and modularity of existing code bases.

Software Engineeringclean coderefactoring
0 likes · 15 min read
Refactoring Techniques: Extract Function, Parameterize, Strategy Pattern, and More
Java High-Performance Architecture
Java High-Performance Architecture
Aug 13, 2022 · Fundamentals

Mastering the Chain of Responsibility Pattern: From Flawed Code to Clean Design

This article explains the Chain of Responsibility design pattern, its typical use cases, shows a problematic nested‑if implementation for a game level system, and demonstrates step‑by‑step refactorings—including a linked‑handler chain and an enum‑based factory—to produce maintainable, extensible Java code.

Chain of ResponsibilityDesign PatternsJava
0 likes · 12 min read
Mastering the Chain of Responsibility Pattern: From Flawed Code to Clean Design
DaTaobao Tech
DaTaobao Tech
Aug 12, 2022 · Backend Development

Evolution and Technical Refactoring of Alibaba's Coupon Package System

Alibaba's coupon package evolved from a 2014 PC‑only tool to a mobile‑centric, marketing‑driven platform, and now to a user‑asset‑center architecture that consolidates assets, upgrades the tech stack, unifies logging, optimizes Docker, and implements performance cuts that shrink machine usage and request expansion by over 90%.

Coupon Systemarchitectureproduct evolution
0 likes · 13 min read
Evolution and Technical Refactoring of Alibaba's Coupon Package System
Architect
Architect
Jun 19, 2022 · Fundamentals

Understanding and Refactoring the Chain of Responsibility Design Pattern in Java

This article explains the Chain of Responsibility design pattern, its typical use cases, shows an anti‑example of overly nested conditional code, and demonstrates step‑by‑step refactoring—including an abstract handler, concrete handlers, and a factory‑based configuration—to achieve cleaner, more maintainable Java implementations.

Chain of ResponsibilityDesign PatternsJava
0 likes · 10 min read
Understanding and Refactoring the Chain of Responsibility Design Pattern in Java
Java Backend Technology
Java Backend Technology
Jun 16, 2022 · Fundamentals

Mastering the Chain of Responsibility Pattern: From Pitfalls to Clean Implementations

This article explains the Chain of Responsibility design pattern, illustrates common misuse with a multi‑if game‑level example, and then shows step‑by‑step refactorings—including linked handlers, an abstract base class, a factory and enum‑based configuration—to produce clean, extensible Java code.

Chain of ResponsibilitySoftware Architecturedesign pattern
0 likes · 12 min read
Mastering the Chain of Responsibility Pattern: From Pitfalls to Clean Implementations
Java Captain
Java Captain
Apr 29, 2022 · Backend Development

Best Practices for Java Bean Conversion, Validation, and Refactoring

This article discusses practical techniques for Java developers, covering bean conversion using DTOs and Spring utilities, validation with JSR‑303, leveraging Lombok for cleaner code, applying design patterns, and systematic refactoring to improve readability, maintainability, and overall code quality in backend projects.

JavaLombokdto
0 likes · 27 min read
Best Practices for Java Bean Conversion, Validation, and Refactoring
Zhuanzhuan Tech
Zhuanzhuan Tech
Mar 16, 2022 · Backend Development

Refactoring Zhaunzhuan App Backend Routing with the Aviator Expression Engine

The article describes how the Zhaunzhuan app backend team replaced a hard‑coded Map‑based routing configuration with a rule‑driven Aviator expression engine, detailing the problem analysis, engine selection, architectural redesign, code changes, a deployment incident, and the resulting improvements in flexibility, maintainability, and performance.

AviatorBackendConfiguration
0 likes · 10 min read
Refactoring Zhaunzhuan App Backend Routing with the Aviator Expression Engine
Python Programming Learning Circle
Python Programming Learning Circle
Mar 11, 2022 · Fundamentals

Refactoring a Python Employee Management System to Eliminate Code Smells

This article explains common Python code smells in an employee‑management example, demonstrates why practices such as using raw strings for roles, duplicated search methods, excessive isinstance checks, and vague boolean flags are problematic, and provides a step‑by‑step refactor using Enums, abstract base classes, list comprehensions, custom exceptions, and clearer method separation.

Abstract Base ClassDesign PatternsPython
0 likes · 14 min read
Refactoring a Python Employee Management System to Eliminate Code Smells